From 1c01b29be7b374d72a5d7b1dc811109095a113dc Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Sun, 22 Feb 2026 16:23:35 +0100
Subject: [PATCH 01/38] s

---
 agents.md                                     |   8 +-
 ...260222_0016_add_publication_identifiers.py | 104 ++++++
 app/api/routers/admin_dbops.py                |  13 +
 app/api/routers/publications.py               |  21 +-
 app/api/schemas.py                            |  12 +
 app/db/models.py                              |  48 +++
 app/services/domains/crossref/application.py  | 127 ++++++-
 app/services/domains/ingestion/application.py |  12 +-
 .../publication_identifiers/__init__.py       |  17 +
 .../publication_identifiers/application.py    | 351 ++++++++++++++++++
 .../publication_identifiers/normalize.py      |  76 ++++
 .../domains/publication_identifiers/types.py  |  30 ++
 app/services/domains/publications/listing.py  |  15 +-
 .../domains/publications/pdf_queue.py         |  39 +-
 .../publications/pdf_resolution_pipeline.py   | 150 ++++++++
 app/services/domains/publications/types.py    |   3 +
 .../domains/scholar/publication_pdf.py        | 232 ++++++++++++
 app/services/domains/scholar/rate_limit.py    |  18 +
 app/services/domains/scholar/source.py        |  10 +
 app/services/domains/unpaywall/application.py |  36 +-
 frontend/src/components/ui/AppHelpHint.vue    |   4 +-
 frontend/src/features/admin_dbops/index.ts    |   9 +
 frontend/src/features/publications/index.ts   |   9 +
 .../features/settings/SettingsAdminPanel.vue  |  10 +-
 frontend/src/pages/PublicationsPage.vue       |  18 +-
 tests/unit/test_crossref_lookup.py            |  32 +-
 tests/unit/test_publication_identifiers.py    |  38 ++
 .../unit/test_publication_pdf_queue_policy.py |  63 ++++
 ...est_publication_pdf_resolution_pipeline.py | 153 ++++++++
 tests/unit/test_scholar_publication_pdf.py    |  76 ++++
 tests/unit/test_unpaywall_resolution.py       |  44 ++-
 31 files changed, 1725 insertions(+), 53 deletions(-)
 create mode 100644 alembic/versions/20260222_0016_add_publication_identifiers.py
 create mode 100644 app/services/domains/publication_identifiers/__init__.py
 create mode 100644 app/services/domains/publication_identifiers/application.py
 create mode 100644 app/services/domains/publication_identifiers/normalize.py
 create mode 100644 app/services/domains/publication_identifiers/types.py
 create mode 100644 app/services/domains/publications/pdf_resolution_pipeline.py
 create mode 100644 app/services/domains/scholar/publication_pdf.py
 create mode 100644 app/services/domains/scholar/rate_limit.py
 create mode 100644 tests/unit/test_publication_identifiers.py
 create mode 100644 tests/unit/test_publication_pdf_resolution_pipeline.py
 create mode 100644 tests/unit/test_scholar_publication_pdf.py

diff --git a/agents.md b/agents.md
index 07b62d2..da59b76 100644
--- a/agents.md
+++ b/agents.md
@@ -7,6 +7,7 @@ Adhere strictly to these constraints.
 * **DRY (Don't Repeat Yourself):** Abstract repetitive logic immediately. No duplicate boilerplate for database queries, API responses, or error handling.
 * **Negative Space Programming:** Utilize explicit assertions and constraints to define invalid states. Fail fast and early. Do not allow silent failures or cascading malformed data, especially in DOM parsing.
 * **Cyclomatic Complexity:** Flatten logic. Use early returns and guard clauses instead of deep nesting.
+no magic numbers
 
 ## 2. Domain Architecture & Data Model
 * **Data Isolation:** Scholar tracking is **user-scoped**. Validate mapping/join tables; never assume global links between users and Scholar IDs.
@@ -29,13 +30,6 @@ These limits prevent IP bans and are not to be optimized away.
 
 ## 5. Domain Service Boundaries
 * **Strict Modularity:** Flat files in the `app/services/` root are strictly prohibited. All business logic and routing must reside exclusively within `app/services/domains/`.
-* **`app/services/domains/scholar/*`:** Parser contract is fail-fast. Layout drift must emit explicit exceptions and `layout_*` reasons/warnings. Never allow silent partial success.
-* **`app/services/domains/ingestion/application.py`:** Orchestrates ingestion runs; validate parser outputs before persistence; enforce publication candidate constraints before upsert.
-* **`app/services/domains/publications/*`:** Publication list/read-state query layer. Includes `doi` + `pdf_url` fields for UI consumption, enforces non-blocking lazy OA enrichment scheduling on list reads, and exposes per-publication PDF retry behavior.
-* **`app/services/domains/crossref/*`:** DOI discovery fallback module. Must use bounded/paced lookups to avoid burst traffic and 429 responses.
-* **`app/services/domains/unpaywall/*`:** OA resolver by DOI only (best OA location + PDF URL extraction). Do not use Google Scholar for PDF resolution to avoid N+1 scrape amplification.
-* **`app/services/domains/portability/*`:** Handles JSON import/export for user-scoped scholars and scholar-publication link state while preserving global publication dedup rules.
-* **`app/services/domains/ingestion/scheduler.py`:** Owns automatic runs and continuation queue retries/drops; do not bypass safety gate or cooldown logic.
 
 
 ## 6. UI rules
diff --git a/alembic/versions/20260222_0016_add_publication_identifiers.py b/alembic/versions/20260222_0016_add_publication_identifiers.py
new file mode 100644
index 0000000..cd824a2
--- /dev/null
+++ b/alembic/versions/20260222_0016_add_publication_identifiers.py
@@ -0,0 +1,104 @@
+"""Add publication identifiers table.
+
+Revision ID: 20260222_0016
+Revises: 20260221_0015
+Create Date: 2026-02-22 12:45:00.000000
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+import sqlalchemy as sa
+
+
+revision: str = "20260222_0016"
+down_revision: str | Sequence[str] | None = "20260221_0015"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def _table_names() -> set[str]:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    return set(inspector.get_table_names())
+
+
+def _create_publication_identifiers_table() -> None:
+    op.create_table(
+        "publication_identifiers",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("publication_id", sa.Integer(), nullable=False),
+        sa.Column("kind", sa.String(length=32), nullable=False),
+        sa.Column("value_raw", sa.Text(), nullable=False),
+        sa.Column("value_normalized", sa.String(length=255), nullable=False),
+        sa.Column("source", sa.String(length=64), nullable=False),
+        sa.Column(
+            "confidence_score",
+            sa.Float(),
+            nullable=False,
+            server_default=sa.text("0"),
+        ),
+        sa.Column("evidence_url", sa.Text(), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.CheckConstraint(
+            "confidence_score >= 0 AND confidence_score <= 1",
+            name="publication_identifiers_confidence_score_range",
+        ),
+        sa.ForeignKeyConstraint(
+            ["publication_id"],
+            ["publications.id"],
+            ondelete="CASCADE",
+        ),
+        sa.PrimaryKeyConstraint("id", name=op.f("pk_publication_identifiers")),
+        sa.UniqueConstraint(
+            "publication_id",
+            "kind",
+            "value_normalized",
+            name="uq_publication_identifiers_publication_kind_value",
+        ),
+    )
+
+
+def _create_publication_identifiers_indexes() -> None:
+    op.create_index(
+        "ix_publication_identifiers_kind_value",
+        "publication_identifiers",
+        ["kind", "value_normalized"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_publication_identifiers_publication_id",
+        "publication_identifiers",
+        ["publication_id"],
+        unique=False,
+    )
+
+
+def _drop_publication_identifiers_indexes() -> None:
+    op.drop_index("ix_publication_identifiers_publication_id", table_name="publication_identifiers")
+    op.drop_index("ix_publication_identifiers_kind_value", table_name="publication_identifiers")
+
+
+def upgrade() -> None:
+    if "publication_identifiers" in _table_names():
+        return
+    _create_publication_identifiers_table()
+    _create_publication_identifiers_indexes()
+
+
+def downgrade() -> None:
+    if "publication_identifiers" not in _table_names():
+        return
+    _drop_publication_identifiers_indexes()
+    op.drop_table("publication_identifiers")
diff --git a/app/api/routers/admin_dbops.py b/app/api/routers/admin_dbops.py
index 16271a0..cd6d924 100644
--- a/app/api/routers/admin_dbops.py
+++ b/app/api/routers/admin_dbops.py
@@ -58,6 +58,7 @@ def _serialize_pdf_queue_item(item) -> dict[str, object]:
         "publication_id": item.publication_id,
         "title": item.title,
         "doi": item.doi,
+        "display_identifier": _serialize_display_identifier(item.display_identifier),
         "pdf_url": item.pdf_url,
         "status": item.status,
         "attempt_count": item.attempt_count,
@@ -73,6 +74,18 @@ def _serialize_pdf_queue_item(item) -> dict[str, object]:
     }
 
 
+def _serialize_display_identifier(value) -> dict[str, object] | None:
+    if value is None:
+        return None
+    return {
+        "kind": value.kind,
+        "value": value.value,
+        "label": value.label,
+        "url": value.url,
+        "confidence_score": float(value.confidence_score),
+    }
+
+
 def _requeue_response_state(*, queued: bool) -> tuple[str, str]:
     if queued:
         return "queued", "PDF lookup queued."
diff --git a/app/api/routers/publications.py b/app/api/routers/publications.py
index 5055c6c..ad8fc55 100644
--- a/app/api/routers/publications.py
+++ b/app/api/routers/publications.py
@@ -21,6 +21,7 @@ from app.api.schemas import (
 )
 from app.db.models import User
 from app.db.session import get_db_session
+from app.services.domains.publication_identifiers import application as identifier_service
 from app.services.domains.publications import application as publication_service
 from app.services.domains.scholars import application as scholar_service
 from app.settings import settings
@@ -62,6 +63,7 @@ def _serialize_publication_item(item) -> dict[str, object]:
         "venue_text": item.venue_text,
         "pub_url": item.pub_url,
         "doi": item.doi,
+        "display_identifier": _serialize_display_identifier(item.display_identifier),
         "pdf_url": item.pdf_url,
         "pdf_status": item.pdf_status,
         "pdf_attempt_count": item.pdf_attempt_count,
@@ -74,6 +76,18 @@ def _serialize_publication_item(item) -> dict[str, object]:
     }
 
 
+def _serialize_display_identifier(value) -> dict[str, object] | None:
+    if value is None:
+        return None
+    return {
+        "kind": value.kind,
+        "value": value.value,
+        "label": value.label,
+        "url": value.url,
+        "confidence_score": float(value.confidence_score),
+    }
+
+
 async def _publication_counts(
     db_session: AsyncSession,
     *,
@@ -280,7 +294,12 @@ async def _favorite_publication_state(
         db_session,
         items=[publication],
     )
-    return hydrated[0] if hydrated else publication
+    current = hydrated[0] if hydrated else publication
+    identifiers = await identifier_service.overlay_publication_items_with_display_identifiers(
+        db_session,
+        items=[current],
+    )
+    return identifiers[0] if identifiers else current
 
 
 def _log_retry_pdf_result(
diff --git a/app/api/schemas.py b/app/api/schemas.py
index 3ae8876..112f672 100644
--- a/app/api/schemas.py
+++ b/app/api/schemas.py
@@ -581,10 +581,21 @@ class AdminDbRepairJobsEnvelope(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
 
+class DisplayIdentifierData(BaseModel):
+    kind: str
+    value: str
+    label: str
+    url: str | None
+    confidence_score: float = Field(ge=0.0, le=1.0)
+
+    model_config = ConfigDict(extra="forbid")
+
+
 class AdminPdfQueueItemData(BaseModel):
     publication_id: int
     title: str
     doi: str | None
+    display_identifier: DisplayIdentifierData | None = None
     pdf_url: str | None
     status: str
     attempt_count: int
@@ -744,6 +755,7 @@ class PublicationItemData(BaseModel):
     venue_text: str | None
     pub_url: str | None
     doi: str | None
+    display_identifier: DisplayIdentifierData | None = None
     pdf_url: str | None
     pdf_status: str = "untracked"
     pdf_attempt_count: int = 0
diff --git a/app/db/models.py b/app/db/models.py
index 43b44c2..1f0b250 100644
--- a/app/db/models.py
+++ b/app/db/models.py
@@ -8,6 +8,7 @@ from sqlalchemy import (
     CheckConstraint,
     DateTime,
     Enum,
+    Float,
     ForeignKey,
     Index,
     Integer,
@@ -237,6 +238,53 @@ class Publication(Base):
     )
 
 
+class PublicationIdentifier(Base):
+    __tablename__ = "publication_identifiers"
+    __table_args__ = (
+        UniqueConstraint(
+            "publication_id",
+            "kind",
+            "value_normalized",
+            name="uq_publication_identifiers_publication_kind_value",
+        ),
+        CheckConstraint(
+            "confidence_score >= 0 AND confidence_score <= 1",
+            name="publication_identifiers_confidence_score_range",
+        ),
+        Index(
+            "ix_publication_identifiers_kind_value",
+            "kind",
+            "value_normalized",
+        ),
+        Index(
+            "ix_publication_identifiers_publication_id",
+            "publication_id",
+        ),
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    publication_id: Mapped[int] = mapped_column(
+        ForeignKey("publications.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    kind: Mapped[str] = mapped_column(String(32), nullable=False)
+    value_raw: Mapped[str] = mapped_column(Text, nullable=False)
+    value_normalized: Mapped[str] = mapped_column(String(255), nullable=False)
+    source: Mapped[str] = mapped_column(String(64), nullable=False)
+    confidence_score: Mapped[float] = mapped_column(
+        Float,
+        nullable=False,
+        server_default=text("0"),
+    )
+    evidence_url: Mapped[str | None] = mapped_column(Text)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
 class PublicationPdfJob(Base):
     __tablename__ = "publication_pdf_jobs"
     __table_args__ = (
diff --git a/app/services/domains/crossref/application.py b/app/services/domains/crossref/application.py
index 569c12d..f0e1311 100644
--- a/app/services/domains/crossref/application.py
+++ b/app/services/domains/crossref/application.py
@@ -21,6 +21,8 @@ STOP_WORDS = {"the", "and", "for", "with", "from", "method", "study", "analysis"
 _RATE_LOCK = threading.Lock()
 _LAST_REQUEST_AT = 0.0
 logger = logging.getLogger(__name__)
+STRICT_TITLE_MATCH_THRESHOLD = 0.75
+RELAXED_TITLE_MATCH_THRESHOLD = 0.85
 
 
 def _rate_limit_wait(min_interval_seconds: float) -> None:
@@ -132,7 +134,42 @@ def _candidate_rank(*, title: str, year: int | None, item: dict) -> tuple[float,
     return score, doi
 
 
-def _best_candidate_doi(
+def _year_delta(source_year: int | None, candidate_year: int | None) -> int | None:
+    if source_year is None or candidate_year is None:
+        return None
+    return abs(int(source_year) - int(candidate_year))
+
+
+def _candidate_rank_relaxed(
+    *,
+    title: str,
+    year: int | None,
+    item: dict,
+    author_surname: str | None,
+) -> tuple[float, str | None]:
+    doi = normalize_doi(str(item.get("DOI") or ""))
+    if doi is None:
+        return 0.0, None
+    score = _title_match_score(title, _candidate_title(item))
+    if score <= 0:
+        return 0.0, None
+    candidate_year = _candidate_year(item)
+    delta = _year_delta(year, candidate_year)
+    if delta is not None:
+        if delta <= 1:
+            score += 0.05
+        elif delta <= 3:
+            score += 0.0
+        elif delta <= 5:
+            score -= 0.03
+        else:
+            score -= 0.08
+    if _candidate_author_match(item, author_surname):
+        score += 0.03
+    return score, doi
+
+
+def _best_candidate_doi_strict(
     *,
     title: str,
     year: int | None,
@@ -149,7 +186,7 @@ def _best_candidate_doi(
             continue
         score, doi = _candidate_rank(title=title, year=year, item=item)
         candidate_year = _candidate_year(item)
-        if doi is None or score < 0.75:
+        if doi is None or score < STRICT_TITLE_MATCH_THRESHOLD:
             continue
         if score > best_score:
             best_score = score
@@ -166,6 +203,92 @@ def _best_candidate_doi(
     return best_doi
 
 
+def _best_candidate_doi_relaxed(
+    *,
+    title: str,
+    year: int | None,
+    items: list[dict],
+    author_surname: str | None,
+) -> str | None:
+    best_score = 0.0
+    best_doi: str | None = None
+    best_author_match = False
+    best_delta: int | None = None
+    best_year: int | None = None
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        score, doi = _candidate_rank_relaxed(
+            title=title,
+            year=year,
+            item=item,
+            author_surname=author_surname,
+        )
+        if doi is None or score < RELAXED_TITLE_MATCH_THRESHOLD:
+            continue
+        candidate_year = _candidate_year(item)
+        candidate_author_match = _candidate_author_match(item, author_surname)
+        candidate_delta = _year_delta(year, candidate_year)
+        if score > best_score:
+            best_score = score
+            best_doi = doi
+            best_author_match = candidate_author_match
+            best_delta = candidate_delta
+            best_year = candidate_year
+            continue
+        if abs(score - best_score) > 0.02:
+            continue
+        if candidate_author_match and not best_author_match:
+            best_doi = doi
+            best_author_match = True
+            best_delta = candidate_delta
+            best_year = candidate_year
+            continue
+        if best_delta is None and candidate_delta is not None:
+            best_doi = doi
+            best_author_match = candidate_author_match
+            best_delta = candidate_delta
+            best_year = candidate_year
+            continue
+        if best_delta is not None and candidate_delta is not None and candidate_delta < best_delta:
+            best_doi = doi
+            best_author_match = candidate_author_match
+            best_delta = candidate_delta
+            best_year = candidate_year
+            continue
+        if best_year is None or candidate_year is None:
+            continue
+        if candidate_year < best_year:
+            best_doi = doi
+            best_author_match = candidate_author_match
+            best_delta = candidate_delta
+            best_year = candidate_year
+    return best_doi
+
+
+def _best_candidate_doi(
+    *,
+    title: str,
+    year: int | None,
+    items: list[dict],
+    author_surname: str | None,
+) -> str | None:
+    strict_match = _best_candidate_doi_strict(
+        title=title,
+        year=year,
+        items=items,
+        author_surname=author_surname,
+    )
+    if strict_match:
+        return strict_match
+    return _best_candidate_doi_relaxed(
+        title=title,
+        year=year,
+        items=items,
+        author_surname=author_surname,
+    )
+
+
 def _works_client(email: str | None) -> Works:
     if email:
         etiquette = Etiquette(settings.app_name, "0.1.0", "https://scholarr.local", email)
diff --git a/app/services/domains/ingestion/application.py b/app/services/domains/ingestion/application.py
index 54a7e25..4cb493d 100644
--- a/app/services/domains/ingestion/application.py
+++ b/app/services/domains/ingestion/application.py
@@ -29,6 +29,7 @@ from app.services.domains.ingestion.constants import (
     RUN_LOCK_NAMESPACE,
 )
 from app.services.domains.doi.normalize import first_doi_from_texts
+from app.services.domains.publication_identifiers import application as identifier_service
 from app.services.domains.ingestion.fingerprints import (
     _build_body_excerpt,
     _dedupe_publication_candidates,
@@ -2071,15 +2072,24 @@ class ScholarIngestionService:
             fingerprint_publication=fingerprint_publication,
         )
         if publication is None:
-            return await self._create_publication(
+            created = await self._create_publication(
                 db_session,
                 candidate=candidate,
                 fingerprint=fingerprint,
             )
+            await identifier_service.sync_identifiers_for_publication_fields(
+                db_session,
+                publication=created,
+            )
+            return created
         self._update_existing_publication(
             publication=publication,
             candidate=candidate,
         )
+        await identifier_service.sync_identifiers_for_publication_fields(
+            db_session,
+            publication=publication,
+        )
         return publication
 
     def _resolve_run_status(
diff --git a/app/services/domains/publication_identifiers/__init__.py b/app/services/domains/publication_identifiers/__init__.py
new file mode 100644
index 0000000..3a35c66
--- /dev/null
+++ b/app/services/domains/publication_identifiers/__init__.py
@@ -0,0 +1,17 @@
+from app.services.domains.publication_identifiers.application import (
+    DisplayIdentifier,
+    derive_display_identifier_from_values,
+    overlay_pdf_queue_items_with_display_identifiers,
+    overlay_publication_items_with_display_identifiers,
+    sync_identifiers_for_publication_fields,
+    sync_identifiers_for_publication_resolution,
+)
+
+__all__ = [
+    "DisplayIdentifier",
+    "derive_display_identifier_from_values",
+    "overlay_pdf_queue_items_with_display_identifiers",
+    "overlay_publication_items_with_display_identifiers",
+    "sync_identifiers_for_publication_fields",
+    "sync_identifiers_for_publication_resolution",
+]
diff --git a/app/services/domains/publication_identifiers/application.py b/app/services/domains/publication_identifiers/application.py
new file mode 100644
index 0000000..d34e757
--- /dev/null
+++ b/app/services/domains/publication_identifiers/application.py
@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import TYPE_CHECKING
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import Publication, PublicationIdentifier
+from app.services.domains.doi.normalize import normalize_doi
+from app.services.domains.publication_identifiers.normalize import (
+    normalize_arxiv_id,
+    normalize_pmcid,
+    normalize_pmid,
+)
+from app.services.domains.publication_identifiers.types import (
+    DisplayIdentifier,
+    IdentifierCandidate,
+    IdentifierKind,
+)
+
+if TYPE_CHECKING:
+    from app.services.domains.publications.pdf_queue import PdfQueueListItem
+    from app.services.domains.publications.types import PublicationListItem
+
+CONFIDENCE_HIGH = 0.98
+CONFIDENCE_MEDIUM = 0.9
+CONFIDENCE_LOW = 0.6
+CONFIDENCE_FALLBACK = 0.4
+PRIORITY_DOI = 400
+PRIORITY_ARXIV = 300
+PRIORITY_PMCID = 200
+PRIORITY_PMID = 100
+
+
+def derive_display_identifier_from_values(
+    *,
+    doi: str | None,
+    pub_url: str | None = None,
+    pdf_url: str | None = None,
+) -> DisplayIdentifier | None:
+    candidates = _fallback_candidates_from_values(doi=doi, pub_url=pub_url, pdf_url=pdf_url)
+    return _best_display_identifier(candidates)
+
+
+def _fallback_candidates_from_values(
+    *,
+    doi: str | None,
+    pub_url: str | None,
+    pdf_url: str | None,
+) -> list[IdentifierCandidate]:
+    values = [value for value in [pub_url, pdf_url] if value]
+    candidates = []
+    if doi:
+        normalized_doi = normalize_doi(doi)
+        if normalized_doi:
+            candidates.append(_candidate(IdentifierKind.DOI, doi, normalized_doi, "legacy_doi", CONFIDENCE_HIGH, pub_url))
+    candidates.extend(_url_identifier_candidates(values=values, source="legacy_urls"))
+    return _dedup_candidates(candidates)
+
+
+def _url_identifier_candidates(*, values: list[str], source: str) -> list[IdentifierCandidate]:
+    candidates: list[IdentifierCandidate] = []
+    for value in values:
+        candidates.extend(_url_candidates_for_value(value=value, source=source))
+    return candidates
+
+
+def _url_candidates_for_value(*, value: str, source: str) -> list[IdentifierCandidate]:
+    candidates: list[IdentifierCandidate] = []
+    arxiv = normalize_arxiv_id(value)
+    if arxiv:
+        candidates.append(_candidate(IdentifierKind.ARXIV, value, arxiv, source, CONFIDENCE_MEDIUM, value))
+    pmcid = normalize_pmcid(value)
+    if pmcid:
+        candidates.append(_candidate(IdentifierKind.PMCID, value, pmcid, source, CONFIDENCE_LOW, value))
+    pmid = normalize_pmid(value)
+    if pmid:
+        candidates.append(_candidate(IdentifierKind.PMID, value, pmid, source, CONFIDENCE_FALLBACK, value))
+    return candidates
+
+
+def _candidate(
+    kind: IdentifierKind,
+    value_raw: str,
+    value_normalized: str,
+    source: str,
+    confidence_score: float,
+    evidence_url: str | None,
+) -> IdentifierCandidate:
+    return IdentifierCandidate(
+        kind=kind,
+        value_raw=value_raw,
+        value_normalized=value_normalized,
+        source=source,
+        confidence_score=float(confidence_score),
+        evidence_url=evidence_url,
+    )
+
+
+def _dedup_candidates(candidates: list[IdentifierCandidate]) -> list[IdentifierCandidate]:
+    deduped: dict[tuple[str, str], IdentifierCandidate] = {}
+    for candidate in candidates:
+        key = (candidate.kind.value, candidate.value_normalized)
+        current = deduped.get(key)
+        if current is None or candidate.confidence_score > current.confidence_score:
+            deduped[key] = candidate
+    return list(deduped.values())
+
+
+async def sync_identifiers_for_publication_fields(
+    db_session: AsyncSession,
+    *,
+    publication: Publication,
+) -> None:
+    candidates = _publication_field_candidates(publication)
+    await _upsert_publication_candidates(db_session, publication_id=int(publication.id), candidates=candidates)
+
+
+def _publication_field_candidates(publication: Publication) -> list[IdentifierCandidate]:
+    return _fallback_candidates_from_values(
+        doi=publication.doi,
+        pub_url=publication.pub_url,
+        pdf_url=publication.pdf_url,
+    )
+
+
+async def sync_identifiers_for_publication_resolution(
+    db_session: AsyncSession,
+    *,
+    publication: Publication,
+    source: str | None,
+) -> None:
+    candidates = _publication_field_candidates(publication)
+    rewritten = [_candidate_with_source(candidate, source=source) for candidate in candidates]
+    await _upsert_publication_candidates(db_session, publication_id=int(publication.id), candidates=rewritten)
+
+
+def _candidate_with_source(candidate: IdentifierCandidate, *, source: str | None) -> IdentifierCandidate:
+    if not source:
+        return candidate
+    return IdentifierCandidate(
+        kind=candidate.kind,
+        value_raw=candidate.value_raw,
+        value_normalized=candidate.value_normalized,
+        source=source,
+        confidence_score=candidate.confidence_score,
+        evidence_url=candidate.evidence_url,
+    )
+
+
+async def _upsert_publication_candidates(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    candidates: list[IdentifierCandidate],
+) -> None:
+    for candidate in _dedup_candidates(candidates):
+        await _upsert_publication_candidate(db_session, publication_id=publication_id, candidate=candidate)
+
+
+async def _upsert_publication_candidate(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    candidate: IdentifierCandidate,
+) -> None:
+    existing = await _existing_identifier(
+        db_session,
+        publication_id=publication_id,
+        kind=candidate.kind.value,
+        value_normalized=candidate.value_normalized,
+    )
+    if existing is None:
+        db_session.add(_new_identifier_row(publication_id=publication_id, candidate=candidate))
+        return
+    _merge_identifier_row(existing, candidate=candidate)
+
+
+async def _existing_identifier(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    kind: str,
+    value_normalized: str,
+) -> PublicationIdentifier | None:
+    result = await db_session.execute(
+        select(PublicationIdentifier).where(
+            PublicationIdentifier.publication_id == publication_id,
+            PublicationIdentifier.kind == kind,
+            PublicationIdentifier.value_normalized == value_normalized,
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+def _new_identifier_row(
+    *,
+    publication_id: int,
+    candidate: IdentifierCandidate,
+) -> PublicationIdentifier:
+    return PublicationIdentifier(
+        publication_id=publication_id,
+        kind=candidate.kind.value,
+        value_raw=candidate.value_raw,
+        value_normalized=candidate.value_normalized,
+        source=candidate.source,
+        confidence_score=candidate.confidence_score,
+        evidence_url=candidate.evidence_url,
+    )
+
+
+def _merge_identifier_row(existing: PublicationIdentifier, *, candidate: IdentifierCandidate) -> None:
+    if candidate.confidence_score >= float(existing.confidence_score):
+        existing.value_raw = candidate.value_raw
+        existing.source = candidate.source
+        existing.confidence_score = candidate.confidence_score
+        if candidate.evidence_url:
+            existing.evidence_url = candidate.evidence_url
+
+
+async def overlay_publication_items_with_display_identifiers(
+    db_session: AsyncSession,
+    *,
+    items: list[PublicationListItem],
+) -> list[PublicationListItem]:
+    if not items:
+        return []
+    mapping = await _display_identifier_map(db_session, publication_ids=[item.publication_id for item in items])
+    return [_overlay_publication_item(item, mapping.get(item.publication_id)) for item in items]
+
+
+def _overlay_publication_item(
+    item: PublicationListItem,
+    display_identifier: DisplayIdentifier | None,
+) -> PublicationListItem:
+    fallback = display_identifier or derive_display_identifier_from_values(doi=item.doi, pub_url=item.pub_url, pdf_url=item.pdf_url)
+    return replace(item, display_identifier=fallback)
+
+
+async def overlay_pdf_queue_items_with_display_identifiers(
+    db_session: AsyncSession,
+    *,
+    items: list[PdfQueueListItem],
+) -> list[PdfQueueListItem]:
+    if not items:
+        return []
+    mapping = await _display_identifier_map(db_session, publication_ids=[item.publication_id for item in items])
+    return [_overlay_queue_item(item, mapping.get(item.publication_id)) for item in items]
+
+
+def _overlay_queue_item(
+    item: PdfQueueListItem,
+    display_identifier: DisplayIdentifier | None,
+) -> PdfQueueListItem:
+    fallback = display_identifier or derive_display_identifier_from_values(doi=item.doi, pdf_url=item.pdf_url)
+    return replace(item, display_identifier=fallback)
+
+
+async def _display_identifier_map(
+    db_session: AsyncSession,
+    *,
+    publication_ids: list[int],
+) -> dict[int, DisplayIdentifier]:
+    normalized_ids = sorted({int(value) for value in publication_ids if int(value) > 0})
+    if not normalized_ids:
+        return {}
+    result = await db_session.execute(
+        select(PublicationIdentifier).where(PublicationIdentifier.publication_id.in_(normalized_ids))
+    )
+    rows = list(result.scalars().all())
+    return _best_display_identifier_map(rows)
+
+
+def _best_display_identifier_map(rows: list[PublicationIdentifier]) -> dict[int, DisplayIdentifier]:
+    grouped: dict[int, list[IdentifierCandidate]] = {}
+    for row in rows:
+        grouped.setdefault(int(row.publication_id), []).append(_candidate_from_row(row))
+    return {
+        publication_id: display
+        for publication_id, display in (
+            (publication_id, _best_display_identifier(candidates))
+            for publication_id, candidates in grouped.items()
+        )
+        if display is not None
+    }
+
+
+def _candidate_from_row(row: PublicationIdentifier) -> IdentifierCandidate:
+    return IdentifierCandidate(
+        kind=IdentifierKind(str(row.kind)),
+        value_raw=str(row.value_raw),
+        value_normalized=str(row.value_normalized),
+        source=str(row.source),
+        confidence_score=float(row.confidence_score),
+        evidence_url=row.evidence_url,
+    )
+
+
+def _best_display_identifier(candidates: list[IdentifierCandidate]) -> DisplayIdentifier | None:
+    if not candidates:
+        return None
+    ordered = sorted(candidates, key=_display_sort_key, reverse=True)
+    return _display_identifier_from_candidate(ordered[0])
+
+
+def _display_sort_key(candidate: IdentifierCandidate) -> tuple[int, float]:
+    return (_kind_priority(candidate.kind), float(candidate.confidence_score))
+
+
+def _kind_priority(kind: IdentifierKind) -> int:
+    if kind == IdentifierKind.DOI:
+        return PRIORITY_DOI
+    if kind == IdentifierKind.ARXIV:
+        return PRIORITY_ARXIV
+    if kind == IdentifierKind.PMCID:
+        return PRIORITY_PMCID
+    return PRIORITY_PMID
+
+
+def _display_identifier_from_candidate(candidate: IdentifierCandidate) -> DisplayIdentifier:
+    value = candidate.value_normalized
+    return DisplayIdentifier(
+        kind=candidate.kind.value,
+        value=value,
+        label=_display_label(candidate.kind, value),
+        url=_identifier_url(candidate.kind, value),
+        confidence_score=float(candidate.confidence_score),
+    )
+
+
+def _display_label(kind: IdentifierKind, value: str) -> str:
+    if kind == IdentifierKind.DOI:
+        return f"DOI: {value}"
+    if kind == IdentifierKind.ARXIV:
+        return f"arXiv: {value}"
+    if kind == IdentifierKind.PMCID:
+        return f"PMCID: {value}"
+    return f"PMID: {value}"
+
+
+def _identifier_url(kind: IdentifierKind, value: str) -> str | None:
+    if kind == IdentifierKind.DOI:
+        return f"https://doi.org/{value}"
+    if kind == IdentifierKind.ARXIV:
+        return f"https://arxiv.org/abs/{value}"
+    if kind == IdentifierKind.PMCID:
+        return f"https://pmc.ncbi.nlm.nih.gov/articles/{value}/"
+    if kind == IdentifierKind.PMID:
+        return f"https://pubmed.ncbi.nlm.nih.gov/{value}/"
+    return None
diff --git a/app/services/domains/publication_identifiers/normalize.py b/app/services/domains/publication_identifiers/normalize.py
new file mode 100644
index 0000000..50036be
--- /dev/null
+++ b/app/services/domains/publication_identifiers/normalize.py
@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import re
+from urllib.parse import urlparse
+
+from app.services.domains.doi.normalize import normalize_doi
+from app.services.domains.publication_identifiers.types import IdentifierKind
+
+ARXIV_ABS_RE = re.compile(r"\barxiv:\s*([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?\b", re.I)
+ARXIV_PATH_RE = re.compile(r"^/(?:abs|pdf)/([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?(?:\.pdf)?/?$", re.I)
+PMCID_RE = re.compile(r"\b(PMC\d+)\b", re.I)
+PUBMED_PATH_RE = re.compile(r"^/(\d+)/?$")
+
+
+def normalize_identifier(kind: IdentifierKind, value: str | None) -> str | None:
+    if kind == IdentifierKind.DOI:
+        return normalize_doi(value)
+    if kind == IdentifierKind.ARXIV:
+        return normalize_arxiv_id(value)
+    if kind == IdentifierKind.PMCID:
+        return normalize_pmcid(value)
+    if kind == IdentifierKind.PMID:
+        return normalize_pmid(value)
+    return None
+
+
+def normalize_arxiv_id(value: str | None) -> str | None:
+    text = (value or "").strip()
+    if not text:
+        return None
+    parsed = urlparse(text)
+    if parsed.scheme in {"http", "https"} and "arxiv.org" in parsed.netloc.lower():
+        return _arxiv_from_path(parsed.path)
+    match = ARXIV_ABS_RE.search(text)
+    if not match:
+        return None
+    version = (match.group(2) or "").lower()
+    return f"{match.group(1).lower()}{version}"
+
+
+def _arxiv_from_path(path: str) -> str | None:
+    match = ARXIV_PATH_RE.match(path or "")
+    if not match:
+        return None
+    version = (match.group(2) or "").lower()
+    return f"{match.group(1).lower()}{version}"
+
+
+def normalize_pmcid(value: str | None) -> str | None:
+    text = (value or "").strip()
+    if not text:
+        return None
+    parsed = urlparse(text)
+    if parsed.scheme in {"http", "https"} and "ncbi.nlm.nih.gov" in parsed.netloc.lower():
+        return _first_match(PMCID_RE, parsed.path)
+    return _first_match(PMCID_RE, text)
+
+
+def normalize_pmid(value: str | None) -> str | None:
+    text = (value or "").strip()
+    if not text:
+        return None
+    parsed = urlparse(text)
+    if parsed.scheme in {"http", "https"} and "pubmed.ncbi.nlm.nih.gov" in parsed.netloc.lower():
+        match = PUBMED_PATH_RE.match(parsed.path or "")
+        if not match:
+            return None
+        return match.group(1)
+    return None
+
+
+def _first_match(pattern: re.Pattern[str], value: str) -> str | None:
+    match = pattern.search(value)
+    if not match:
+        return None
+    return match.group(1).upper()
diff --git a/app/services/domains/publication_identifiers/types.py b/app/services/domains/publication_identifiers/types.py
new file mode 100644
index 0000000..34b20d0
--- /dev/null
+++ b/app/services/domains/publication_identifiers/types.py
@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class IdentifierKind(StrEnum):
+    DOI = "doi"
+    ARXIV = "arxiv"
+    PMCID = "pmcid"
+    PMID = "pmid"
+
+
+@dataclass(frozen=True)
+class DisplayIdentifier:
+    kind: str
+    value: str
+    label: str
+    url: str | None
+    confidence_score: float
+
+
+@dataclass(frozen=True)
+class IdentifierCandidate:
+    kind: IdentifierKind
+    value_raw: str
+    value_normalized: str
+    source: str
+    confidence_score: float
+    evidence_url: str | None
diff --git a/app/services/domains/publications/listing.py b/app/services/domains/publications/listing.py
index f4f518b..0d09d4c 100644
--- a/app/services/domains/publications/listing.py
+++ b/app/services/domains/publications/listing.py
@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.services.domains.publication_identifiers import application as identifier_service
 from app.services.domains.publications.modes import (
     MODE_ALL,
     MODE_UNREAD,
@@ -44,7 +45,10 @@ async def list_for_user(
         publication_list_item_from_row(row, latest_run_id=latest_run_id)
         for row in result.all()
     ]
-    return rows
+    return await identifier_service.overlay_publication_items_with_display_identifiers(
+        db_session,
+        items=rows,
+    )
 
 
 async def retry_pdf_for_user(
@@ -54,12 +58,19 @@ async def retry_pdf_for_user(
     scholar_profile_id: int,
     publication_id: int,
 ) -> PublicationListItem | None:
-    return await get_publication_item_for_user(
+    item = await get_publication_item_for_user(
         db_session,
         user_id=user_id,
         scholar_profile_id=scholar_profile_id,
         publication_id=publication_id,
     )
+    if item is None:
+        return None
+    hydrated = await identifier_service.overlay_publication_items_with_display_identifiers(
+        db_session,
+        items=[item],
+    )
+    return hydrated[0] if hydrated else item
 
 
 async def list_unread_for_user(
diff --git a/app/services/domains/publications/pdf_queue.py b/app/services/domains/publications/pdf_queue.py
index b420d46..3972f7d 100644
--- a/app/services/domains/publications/pdf_queue.py
+++ b/app/services/domains/publications/pdf_queue.py
@@ -17,11 +17,16 @@ from app.db.models import (
     User,
 )
 from app.db.session import get_session_factory
+from app.services.domains.publication_identifiers import application as identifier_service
+from app.services.domains.publication_identifiers.types import DisplayIdentifier
+from app.services.domains.publications.pdf_resolution_pipeline import (
+    PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE,
+    resolve_publication_pdf_outcome_for_row,
+)
 from app.services.domains.publications.types import PublicationListItem
 from app.services.domains.unpaywall.application import (
     FAILURE_RESOLUTION_EXCEPTION,
     OaResolutionOutcome,
-    resolve_publication_oa_outcomes,
 )
 from app.settings import settings
 
@@ -57,6 +62,7 @@ class PdfQueueListItem:
     last_attempt_at: datetime | None
     resolved_at: datetime | None
     updated_at: datetime
+    display_identifier: DisplayIdentifier | None = None
 
 
 @dataclass(frozen=True)
@@ -118,6 +124,7 @@ def _item_from_row_and_job(
         pdf_attempt_count=int(job.attempt_count) if job is not None else 0,
         pdf_failure_reason=job.last_failure_reason if job is not None else None,
         pdf_failure_detail=job.last_failure_detail if job is not None else None,
+        display_identifier=row.display_identifier,
     )
 
 
@@ -366,8 +373,11 @@ async def _fetch_outcome_for_row(
     row: PublicationListItem,
     request_email: str | None,
 ) -> OaResolutionOutcome:
-    outcomes = await resolve_publication_oa_outcomes([row], request_email=request_email)
-    outcome = outcomes.get(row.publication_id)
+    pipeline_result = await resolve_publication_pdf_outcome_for_row(
+        row=row,
+        request_email=request_email,
+    )
+    outcome = pipeline_result.outcome
     if outcome is not None:
         return outcome
     return _failed_outcome(row=row)
@@ -417,6 +427,11 @@ async def _persist_outcome(
         if publication is None or job is None:
             return
         _apply_publication_update(publication, doi=outcome.doi, pdf_url=outcome.pdf_url)
+        await identifier_service.sync_identifiers_for_publication_resolution(
+            db_session,
+            publication=publication,
+            source=outcome.source,
+        )
         _apply_job_outcome(job, outcome=outcome)
         event_type, status = _result_event(outcome)
         db_session.add(
@@ -794,6 +809,18 @@ def _queue_item_from_row(row: tuple) -> PdfQueueListItem:
     )
 
 
+async def _hydrated_queue_items(
+    db_session: AsyncSession,
+    *,
+    rows: list[tuple],
+) -> list[PdfQueueListItem]:
+    items = [_queue_item_from_row(row) for row in rows]
+    return await identifier_service.overlay_pdf_queue_items_with_display_identifiers(
+        db_session,
+        items=items,
+    )
+
+
 async def list_pdf_queue_items(
     db_session: AsyncSession,
     *,
@@ -811,7 +838,7 @@ async def list_pdf_queue_items(
                 offset=bounded_offset,
             )
         )
-        return [_queue_item_from_row(row) for row in result.all()]
+        return await _hydrated_queue_items(db_session, rows=list(result.all()))
     if normalized_status is None:
         result = await db_session.execute(
             _all_queue_select(
@@ -819,7 +846,7 @@ async def list_pdf_queue_items(
                 offset=bounded_offset,
             )
         )
-        return [_queue_item_from_row(row) for row in result.all()]
+        return await _hydrated_queue_items(db_session, rows=list(result.all()))
     result = await db_session.execute(
         _tracked_queue_select(
             limit=bounded_limit,
@@ -827,7 +854,7 @@ async def list_pdf_queue_items(
             status=normalized_status,
         )
     )
-    return [_queue_item_from_row(row) for row in result.all()]
+    return await _hydrated_queue_items(db_session, rows=list(result.all()))
 
 
 async def count_pdf_queue_items(
diff --git a/app/services/domains/publications/pdf_resolution_pipeline.py b/app/services/domains/publications/pdf_resolution_pipeline.py
new file mode 100644
index 0000000..bc41257
--- /dev/null
+++ b/app/services/domains/publications/pdf_resolution_pipeline.py
@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import logging
+from urllib.parse import urlparse
+
+import httpx
+
+from app.services.domains.publications.types import PublicationListItem
+from app.services.domains.scholar.publication_pdf import (
+    ScholarPublicationLinkCandidate,
+    ScholarPublicationLinkCandidates,
+    fetch_link_candidates_from_scholar_publication_page,
+)
+from app.services.domains.unpaywall import pdf_discovery as pdf_discovery_service
+from app.services.domains.unpaywall.application import OaResolutionOutcome, resolve_publication_oa_outcomes
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE = "scholar_publication_page"
+PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE_UNLABELED = "scholar_publication_page_unlabeled_fallback"
+PDF_PATH_TOKEN = "/pdf/"
+HTTP_TIMEOUT_FLOOR_SECONDS = 0.5
+
+
+@dataclass(frozen=True)
+class PipelineOutcome:
+    outcome: OaResolutionOutcome | None
+    scholar_candidates: ScholarPublicationLinkCandidates | None
+
+
+async def resolve_publication_pdf_outcome_for_row(
+    *,
+    row: PublicationListItem,
+    request_email: str | None,
+) -> PipelineOutcome:
+    candidates = await _safe_scholar_candidates(row.pub_url)
+    labeled = _labeled_candidate(candidates)
+    if labeled is not None:
+        return PipelineOutcome(_scholar_outcome(row=row, candidate=labeled), candidates)
+    oa_outcome = await _oa_outcome(row=row, request_email=request_email)
+    if _oa_has_pdf(oa_outcome):
+        return PipelineOutcome(oa_outcome, candidates)
+    unlabeled = _unlabeled_candidate(candidates)
+    if unlabeled is None:
+        return PipelineOutcome(oa_outcome, candidates)
+    fallback_outcome = await _unlabeled_fallback_outcome(row=row, candidate=unlabeled)
+    if fallback_outcome is not None:
+        return PipelineOutcome(fallback_outcome, candidates)
+    return PipelineOutcome(oa_outcome, candidates)
+
+
+async def _safe_scholar_candidates(pub_url: str | None) -> ScholarPublicationLinkCandidates | None:
+    try:
+        return await fetch_link_candidates_from_scholar_publication_page(pub_url)
+    except Exception as exc:  # pragma: no cover - defensive boundary
+        logger.warning(
+            "publications.pdf_resolution.scholar_candidates_failed",
+            extra={"event": "publications.pdf_resolution.scholar_candidates_failed", "error": str(exc)},
+        )
+        return None
+
+
+def _labeled_candidate(
+    candidates: ScholarPublicationLinkCandidates | None,
+) -> ScholarPublicationLinkCandidate | None:
+    if candidates is None:
+        return None
+    return candidates.labeled_candidate
+
+
+def _unlabeled_candidate(
+    candidates: ScholarPublicationLinkCandidates | None,
+) -> ScholarPublicationLinkCandidate | None:
+    if candidates is None:
+        return None
+    return candidates.fallback_candidate
+
+
+def _scholar_outcome(
+    *,
+    row: PublicationListItem,
+    candidate: ScholarPublicationLinkCandidate,
+) -> OaResolutionOutcome:
+    source = (
+        PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE
+        if candidate.label_present
+        else PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE_UNLABELED
+    )
+    return OaResolutionOutcome(
+        publication_id=row.publication_id,
+        doi=row.doi,
+        pdf_url=candidate.url,
+        failure_reason=None,
+        source=source,
+        used_crossref=False,
+    )
+
+
+async def _oa_outcome(
+    *,
+    row: PublicationListItem,
+    request_email: str | None,
+) -> OaResolutionOutcome | None:
+    outcomes = await resolve_publication_oa_outcomes([row], request_email=request_email)
+    return outcomes.get(row.publication_id)
+
+
+def _oa_has_pdf(outcome: OaResolutionOutcome | None) -> bool:
+    return bool(outcome and outcome.pdf_url)
+
+
+async def _unlabeled_fallback_outcome(
+    *,
+    row: PublicationListItem,
+    candidate: ScholarPublicationLinkCandidate,
+) -> OaResolutionOutcome | None:
+    pdf_url = await _validated_pdf_url(candidate.url)
+    if pdf_url is None:
+        return None
+    return _scholar_outcome(row=row, candidate=ScholarPublicationLinkCandidate(
+        url=pdf_url,
+        confidence_score=candidate.confidence_score,
+        label_present=False,
+        reason=candidate.reason,
+    ))
+
+
+async def _validated_pdf_url(candidate_url: str) -> str | None:
+    if _looks_direct_pdf(candidate_url):
+        return candidate_url
+    timeout_seconds = _discovery_timeout_seconds()
+    async with httpx.AsyncClient(timeout=timeout_seconds) as client:
+        if await pdf_discovery_service._candidate_is_pdf(client, candidate_url=candidate_url):
+            return candidate_url
+        return await pdf_discovery_service.resolve_pdf_from_landing_page(client, page_url=candidate_url)
+
+
+def _looks_direct_pdf(url: str | None) -> bool:
+    if pdf_discovery_service.looks_like_pdf_url(url):
+        return True
+    if not isinstance(url, str):
+        return False
+    path = (urlparse(url).path or "").lower()
+    return PDF_PATH_TOKEN in path
+
+
+def _discovery_timeout_seconds() -> float:
+    return max(float(settings.unpaywall_timeout_seconds), HTTP_TIMEOUT_FLOOR_SECONDS)
diff --git a/app/services/domains/publications/types.py b/app/services/domains/publications/types.py
index d1d4bad..3bde82d 100644
--- a/app/services/domains/publications/types.py
+++ b/app/services/domains/publications/types.py
@@ -3,6 +3,8 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import datetime
 
+from app.services.domains.publication_identifiers.types import DisplayIdentifier
+
 
 @dataclass(frozen=True)
 class PublicationListItem:
@@ -24,6 +26,7 @@ class PublicationListItem:
     pdf_attempt_count: int = 0
     pdf_failure_reason: str | None = None
     pdf_failure_detail: str | None = None
+    display_identifier: DisplayIdentifier | None = None
 
 
 @dataclass(frozen=True)
diff --git a/app/services/domains/scholar/publication_pdf.py b/app/services/domains/scholar/publication_pdf.py
new file mode 100644
index 0000000..6f8b6c1
--- /dev/null
+++ b/app/services/domains/scholar/publication_pdf.py
@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from html.parser import HTMLParser
+from urllib.parse import parse_qs, urlparse
+
+from app.services.domains.scholar.parser_types import ScholarDomInvariantError
+from app.services.domains.scholar.parser_utils import attr_href, normalize_space
+from app.services.domains.scholar.rate_limit import wait_for_scholar_slot
+from app.services.domains.scholar.source import LiveScholarSource
+from app.services.domains.settings.application import resolve_request_delay_minimum
+from app.settings import settings
+
+CONTAINER_ID = "gsc_oci_title_gg"
+PDF_LABEL_TOKEN = "[pdf]"
+SCHOLAR_PDF_LABELED_CONFIDENCE = 0.98
+SCHOLAR_PDF_UNLABELED_CONFIDENCE = 0.2
+ALLOWED_URL_SCHEMES = frozenset({"http", "https"})
+
+
+@dataclass(frozen=True)
+class ScholarPublicationLinkCandidate:
+    url: str
+    confidence_score: float
+    label_present: bool
+    reason: str
+
+
+@dataclass(frozen=True)
+class ScholarPublicationLinkCandidates:
+    container_seen: bool
+    labeled_candidate: ScholarPublicationLinkCandidate | None
+    fallback_candidate: ScholarPublicationLinkCandidate | None
+    warnings: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class _ParsedAnchor:
+    href: str | None
+    text: str
+
+
+class _ScholarPublicationPdfParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.container_seen = False
+        self.anchors: list[_ParsedAnchor] = []
+        self._container_depth = 0
+        self._anchor_depth = 0
+        self._anchor_href: str | None = None
+        self._anchor_parts: list[str] = []
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        self._increment_depths()
+        if self._starts_container(tag, attrs):
+            self.container_seen = True
+            self._container_depth = 1
+            return
+        if self._container_depth <= 0 or tag != "a":
+            return
+        if self._anchor_depth > 0:
+            return
+        self._anchor_href = attr_href(attrs)
+        self._anchor_parts = []
+        self._anchor_depth = 1
+
+    def handle_data(self, data: str) -> None:
+        if self._anchor_depth > 0:
+            self._anchor_parts.append(data)
+
+    def handle_endtag(self, tag: str) -> None:
+        if self._anchor_depth > 0:
+            self._anchor_depth -= 1
+            if self._anchor_depth == 0:
+                self._finish_anchor()
+        if self._container_depth > 0:
+            self._container_depth -= 1
+
+    def _increment_depths(self) -> None:
+        if self._container_depth > 0:
+            self._container_depth += 1
+        if self._anchor_depth > 0:
+            self._anchor_depth += 1
+
+    def _starts_container(self, tag: str, attrs: list[tuple[str, str | None]]) -> bool:
+        if tag != "div":
+            return False
+        attrs_map = {name.lower(): (value or "") for name, value in attrs}
+        return attrs_map.get("id") == CONTAINER_ID
+
+    def _finish_anchor(self) -> None:
+        self.anchors.append(
+            _ParsedAnchor(
+                href=self._anchor_href,
+                text=normalize_space("".join(self._anchor_parts)),
+            )
+        )
+        self._anchor_href = None
+        self._anchor_parts = []
+
+
+def is_scholar_publication_detail_url(url: str | None) -> bool:
+    if not isinstance(url, str) or not url.strip():
+        return False
+    parsed = urlparse(url)
+    if parsed.scheme not in ALLOWED_URL_SCHEMES:
+        return False
+    if parsed.netloc.lower() != "scholar.google.com":
+        return False
+    query = parse_qs(parsed.query)
+    return _has_view_citation_params(query)
+
+
+def _has_view_citation_params(query: dict[str, list[str]]) -> bool:
+    view_op = (query.get("view_op") or [""])[0]
+    citation = (query.get("citation_for_view") or [""])[0].strip()
+    return view_op == "view_citation" and bool(citation)
+
+
+def extract_link_candidates_from_publication_detail_html(html: str) -> ScholarPublicationLinkCandidates:
+    parser = _parsed_publication_detail(html)
+    if not parser.container_seen:
+        return ScholarPublicationLinkCandidates(False, None, None)
+    anchors = _validated_container_anchors(parser.anchors)
+    labeled = _select_labeled_candidate(anchors)
+    fallback = _select_fallback_candidate(anchors, labeled=labeled)
+    warnings = _candidate_warnings(labeled=labeled, fallback=fallback)
+    return ScholarPublicationLinkCandidates(True, labeled, fallback, warnings)
+
+
+def _parsed_publication_detail(html: str) -> _ScholarPublicationPdfParser:
+    parser = _ScholarPublicationPdfParser()
+    parser.feed(html)
+    parser.close()
+    return parser
+
+
+def _validated_container_anchors(anchors: list[_ParsedAnchor]) -> list[_ParsedAnchor]:
+    if not anchors:
+        raise ScholarDomInvariantError(
+            code="layout_publication_link_container_missing_anchor",
+            message="Scholar publication link container was present without an anchor.",
+        )
+    validated: list[_ParsedAnchor] = []
+    for anchor in anchors:
+        validated.append(_validated_anchor(anchor))
+    return validated
+
+
+def _validated_anchor(anchor: _ParsedAnchor) -> _ParsedAnchor:
+    href = (anchor.href or "").strip()
+    if not href:
+        raise ScholarDomInvariantError(
+            code="layout_publication_link_missing_href",
+            message="Scholar publication link container anchor was missing href.",
+        )
+    parsed = urlparse(href)
+    if parsed.scheme not in ALLOWED_URL_SCHEMES:
+        raise ScholarDomInvariantError(
+            code="layout_publication_link_invalid_scheme",
+            message="Scholar publication link used a non-http URL.",
+        )
+    return _ParsedAnchor(href=href, text=anchor.text)
+
+
+def _select_labeled_candidate(anchors: list[_ParsedAnchor]) -> ScholarPublicationLinkCandidate | None:
+    for anchor in anchors:
+        if PDF_LABEL_TOKEN in anchor.text.lower():
+            return ScholarPublicationLinkCandidate(
+                url=str(anchor.href),
+                confidence_score=SCHOLAR_PDF_LABELED_CONFIDENCE,
+                label_present=True,
+                reason="scholar_link_labeled_pdf",
+            )
+    return None
+
+
+def _select_fallback_candidate(
+    anchors: list[_ParsedAnchor],
+    *,
+    labeled: ScholarPublicationLinkCandidate | None,
+) -> ScholarPublicationLinkCandidate | None:
+    for anchor in anchors:
+        if labeled and anchor.href == labeled.url:
+            continue
+        return ScholarPublicationLinkCandidate(
+            url=str(anchor.href),
+            confidence_score=SCHOLAR_PDF_UNLABELED_CONFIDENCE,
+            label_present=False,
+            reason="scholar_link_unlabeled_fallback",
+        )
+    if labeled is None and anchors:
+        anchor = anchors[0]
+        return ScholarPublicationLinkCandidate(
+            url=str(anchor.href),
+            confidence_score=SCHOLAR_PDF_UNLABELED_CONFIDENCE,
+            label_present=False,
+            reason="scholar_link_unlabeled_fallback",
+        )
+    return None
+
+
+def _candidate_warnings(
+    *,
+    labeled: ScholarPublicationLinkCandidate | None,
+    fallback: ScholarPublicationLinkCandidate | None,
+) -> tuple[str, ...]:
+    warnings: list[str] = []
+    if labeled is None and fallback is not None:
+        warnings.append("scholar_publication_link_unlabeled_only")
+    return tuple(warnings)
+
+
+def _scholar_request_delay_seconds() -> int:
+    return resolve_request_delay_minimum(settings.ingestion_min_request_delay_seconds)
+
+
+def _fetch_succeeded(fetch_result) -> bool:
+    return int(fetch_result.status_code or 0) == 200 and not fetch_result.error
+
+
+async def fetch_link_candidates_from_scholar_publication_page(
+    publication_url: str | None,
+) -> ScholarPublicationLinkCandidates | None:
+    if not is_scholar_publication_detail_url(publication_url):
+        return None
+    await wait_for_scholar_slot(min_interval_seconds=float(_scholar_request_delay_seconds()))
+    source = LiveScholarSource()
+    fetch_result = await source.fetch_publication_html(str(publication_url))
+    if not _fetch_succeeded(fetch_result):
+        return None
+    return extract_link_candidates_from_publication_detail_html(fetch_result.body)
diff --git a/app/services/domains/scholar/rate_limit.py b/app/services/domains/scholar/rate_limit.py
new file mode 100644
index 0000000..947c91f
--- /dev/null
+++ b/app/services/domains/scholar/rate_limit.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import asyncio
+import time
+
+_REQUEST_LOCK = asyncio.Lock()
+_LAST_REQUEST_AT = 0.0
+
+
+async def wait_for_scholar_slot(*, min_interval_seconds: float) -> None:
+    global _LAST_REQUEST_AT
+    interval = max(float(min_interval_seconds), 0.0)
+    async with _REQUEST_LOCK:
+        elapsed = time.monotonic() - _LAST_REQUEST_AT
+        remaining = interval - elapsed
+        if remaining > 0:
+            await asyncio.sleep(remaining)
+        _LAST_REQUEST_AT = time.monotonic()
diff --git a/app/services/domains/scholar/source.py b/app/services/domains/scholar/source.py
index 83da165..92c6702 100644
--- a/app/services/domains/scholar/source.py
+++ b/app/services/domains/scholar/source.py
@@ -123,6 +123,16 @@ class LiveScholarSource:
         )
         return await asyncio.to_thread(self._fetch_sync, requested_url)
 
+    async def fetch_publication_html(self, publication_url: str) -> FetchResult:
+        logger.debug(
+            "scholar_source.publication_fetch_started",
+            extra={
+                "event": "scholar_source.publication_fetch_started",
+                "requested_url": publication_url,
+            },
+        )
+        return await asyncio.to_thread(self._fetch_sync, publication_url)
+
     def _build_request(self, requested_url: str) -> Request:
         return Request(
             requested_url,
diff --git a/app/services/domains/unpaywall/application.py b/app/services/domains/unpaywall/application.py
index 44c7560..a658818 100644
--- a/app/services/domains/unpaywall/application.py
+++ b/app/services/domains/unpaywall/application.py
@@ -64,20 +64,16 @@ def _extract_explicit_doi(text: str | None) -> str | None:
 
 def _publication_doi(item: PublicationListItem | UnreadPublicationItem) -> str | None:
     stored = normalize_doi(item.doi)
-    if stored:
-        in_metadata = any(
-            normalize_doi(_extract_explicit_doi(value)) == stored
-            for value in (item.pub_url, item.venue_text)
-        )
-        if in_metadata:
-            return stored
-    pub_url_doi = _extract_doi_candidate(item.pub_url)
-    if pub_url_doi:
-        return normalize_doi(pub_url_doi)
-    return (
+    explicit_doi = (
         _extract_explicit_doi(item.pub_url)
         or _extract_explicit_doi(item.venue_text)
     )
+    if explicit_doi:
+        return explicit_doi
+    pub_url_doi = _extract_doi_candidate(item.pub_url)
+    if pub_url_doi:
+        return normalize_doi(pub_url_doi)
+    return stored
 
 
 def _payload_locations(payload: dict) -> list[dict]:
@@ -217,30 +213,30 @@ async def _resolve_item_payload(
     item: PublicationListItem,
     email: str,
     allow_crossref: bool,
-) -> tuple[dict | None, bool]:
+) -> tuple[dict | None, bool, str | None]:
     doi = _publication_doi(item)
     payload: dict | None = None
     if doi:
         payload = await _fetch_unpaywall_payload_by_doi(client=client, doi=doi, email=email)
         if payload is not None and _has_direct_payload_pdf(payload):
-            return payload, False
+            return payload, False, doi
     if not allow_crossref or not settings.crossref_enabled:
-        return payload, False
+        return payload, False, doi
     crossref_doi = await discover_doi_for_publication(
         item=item,
         max_rows=settings.crossref_max_rows,
         email=email,
     )
     if crossref_doi is None or crossref_doi == doi:
-        return payload, crossref_doi is not None
+        return payload, crossref_doi is not None, doi or crossref_doi
     crossref_payload = await _fetch_unpaywall_payload_by_doi(
         client=client,
         doi=crossref_doi,
         email=email,
     )
     if crossref_payload is not None:
-        return crossref_payload, True
-    return payload, True
+        return crossref_payload, True, crossref_doi
+    return payload, True, crossref_doi
 
 
 async def _doi_and_pdf_from_payload(
@@ -265,10 +261,11 @@ def _outcome_with_failure(
     item: PublicationListItem,
     failure_reason: str,
     used_crossref: bool,
+    doi_override: str | None = None,
 ) -> OaResolutionOutcome:
     return OaResolutionOutcome(
         publication_id=item.publication_id,
-        doi=_publication_doi(item),
+        doi=normalize_doi(doi_override) if doi_override is not None else _publication_doi(item),
         pdf_url=None,
         failure_reason=failure_reason,
         source=None,
@@ -323,7 +320,7 @@ async def _resolve_outcome_for_item(
     email: str,
     allow_crossref: bool,
 ) -> OaResolutionOutcome:
-    payload, used_crossref = await _resolve_item_payload(
+    payload, used_crossref, resolved_doi = await _resolve_item_payload(
         client=client,
         item=item,
         email=email,
@@ -334,6 +331,7 @@ async def _resolve_outcome_for_item(
             item=item,
             failure_reason=_missing_payload_failure_reason(item, used_crossref=used_crossref),
             used_crossref=used_crossref,
+            doi_override=resolved_doi,
         )
     doi, pdf_url = await _doi_and_pdf_from_payload(payload, client=client)
     return _outcome_from_payload(
diff --git a/frontend/src/components/ui/AppHelpHint.vue b/frontend/src/components/ui/AppHelpHint.vue
index 6736158..50d5b52 100644
--- a/frontend/src/components/ui/AppHelpHint.vue
+++ b/frontend/src/components/ui/AppHelpHint.vue
@@ -182,7 +182,7 @@ onBeforeUnmount(() => {
       :class="
         hasTriggerSlot
           ? 'cursor-help rounded-sm'
-          : 'h-5 w-5 justify-center rounded-full border border-stroke-interactive/80 bg-surface-card-muted/80 text-[11px] font-semibold text-ink-secondary transition hover:bg-action-secondary-hover-bg'
+          : 'h-5 w-5 justify-center rounded-full border border-stroke-interactive/80 bg-surface-card-muted/80 text-xs font-semibold text-ink-secondary transition hover:bg-action-secondary-hover-bg'
       "
       :aria-label="text"
       @mouseenter="openTooltip"
@@ -200,7 +200,7 @@ onBeforeUnmount(() => {
         role="tooltip"
         :style="tooltipStyle"
         :class="sideClass"
-        class="pointer-events-none fixed z-[90] w-64 max-w-[calc(100vw-2rem)] rounded-lg border border-stroke-default bg-surface-card/95 px-2.5 py-2 text-xs leading-relaxed text-ink-secondary shadow-lg"
+        class="pointer-events-none fixed z-50 w-auto max-w-xs rounded-lg border border-stroke-default bg-surface-card/95 px-2.5 py-2 text-xs leading-relaxed text-ink-secondary shadow-lg"
       >
         {{ text }}
       </span>
diff --git a/frontend/src/features/admin_dbops/index.ts b/frontend/src/features/admin_dbops/index.ts
index e3269e1..2f042f5 100644
--- a/frontend/src/features/admin_dbops/index.ts
+++ b/frontend/src/features/admin_dbops/index.ts
@@ -1,5 +1,13 @@
 import { apiRequest } from "@/lib/api/client";
 
+export interface DisplayIdentifier {
+  kind: string;
+  value: string;
+  label: string;
+  url: string | null;
+  confidence_score: number;
+}
+
 export interface AdminDbIntegrityCheck {
   name: string;
   count: number;
@@ -34,6 +42,7 @@ export interface AdminPdfQueueItem {
   publication_id: number;
   title: string;
   doi: string | null;
+  display_identifier: DisplayIdentifier | null;
   pdf_url: string | null;
   status: string;
   attempt_count: number;
diff --git a/frontend/src/features/publications/index.ts b/frontend/src/features/publications/index.ts
index 2eddfbb..f238a0e 100644
--- a/frontend/src/features/publications/index.ts
+++ b/frontend/src/features/publications/index.ts
@@ -2,6 +2,14 @@ import { apiRequest } from "@/lib/api/client";
 
 export type PublicationMode = "all" | "unread" | "latest";
 
+export interface DisplayIdentifier {
+  kind: string;
+  value: string;
+  label: string;
+  url: string | null;
+  confidence_score: number;
+}
+
 export interface PublicationItem {
   publication_id: number;
   scholar_profile_id: number;
@@ -12,6 +20,7 @@ export interface PublicationItem {
   venue_text: string | null;
   pub_url: string | null;
   doi: string | null;
+  display_identifier: DisplayIdentifier | null;
   pdf_url: string | null;
   pdf_status: "untracked" | "queued" | "running" | "resolved" | "failed";
   pdf_attempt_count: number;
diff --git a/frontend/src/features/settings/SettingsAdminPanel.vue b/frontend/src/features/settings/SettingsAdminPanel.vue
index 7f5788e..7edf67b 100644
--- a/frontend/src/features/settings/SettingsAdminPanel.vue
+++ b/frontend/src/features/settings/SettingsAdminPanel.vue
@@ -748,8 +748,14 @@ watch(
               <td>
                 <div class="grid gap-1">
                   <span class="font-medium text-ink-primary">{{ item.title }}</span>
-                  <a v-if="item.doi" :href="`https://doi.org/${item.doi}`" target="_blank" rel="noreferrer" class="link-inline text-xs">
-                    DOI: {{ item.doi }}
+                  <a
+                    v-if="item.display_identifier?.url"
+                    :href="item.display_identifier.url"
+                    target="_blank"
+                    rel="noreferrer"
+                    class="link-inline text-xs"
+                  >
+                    {{ item.display_identifier.label }}
                   </a>
                 </div>
               </td>
diff --git a/frontend/src/pages/PublicationsPage.vue b/frontend/src/pages/PublicationsPage.vue
index fbecad9..beeedc7 100644
--- a/frontend/src/pages/PublicationsPage.vue
+++ b/frontend/src/pages/PublicationsPage.vue
@@ -169,11 +169,15 @@ function publicationPrimaryUrl(item: PublicationItem): string | null {
   return item.pub_url || item.pdf_url;
 }
 
-function publicationDoiUrl(item: PublicationItem): string | null {
-  if (!item.doi) {
+function publicationIdentifierUrl(item: PublicationItem): string | null {
+  if (!item.display_identifier?.url) {
     return null;
   }
-  return `https://doi.org/${item.doi}`;
+  return item.display_identifier.url;
+}
+
+function publicationIdentifierLabel(item: PublicationItem): string | null {
+  return item.display_identifier?.label ?? null;
 }
 
 const selectedScholarName = computed(() => {
@@ -1043,14 +1047,14 @@ watch(
                   </a>
                   <span v-else class="block truncate font-medium" :title="item.title">{{ item.title }}</span>
                   <a
-                    v-if="publicationDoiUrl(item)"
-                    :href="publicationDoiUrl(item) || ''"
+                    v-if="publicationIdentifierUrl(item)"
+                    :href="publicationIdentifierUrl(item) || ''"
                     target="_blank"
                     rel="noreferrer"
                     class="link-inline block truncate text-xs"
-                    :title="`DOI: ${item.doi}`"
+                    :title="publicationIdentifierLabel(item) || ''"
                   >
-                    DOI: {{ item.doi }}
+                    {{ publicationIdentifierLabel(item) }}
                   </a>
                 </div>
               </td>
diff --git a/tests/unit/test_crossref_lookup.py b/tests/unit/test_crossref_lookup.py
index 5d71281..67712fa 100644
--- a/tests/unit/test_crossref_lookup.py
+++ b/tests/unit/test_crossref_lookup.py
@@ -52,7 +52,9 @@ async def test_crossref_discovers_doi_from_best_title_match(monkeypatch: pytest.
 
 
 @pytest.mark.asyncio
-async def test_crossref_rejects_large_year_mismatch(monkeypatch: pytest.MonkeyPatch) -> None:
+async def test_crossref_relaxed_fallback_allows_large_year_mismatch_for_strong_title_match(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
     async def _fake_fetch_items(**_kwargs):
         return [
             {
@@ -72,4 +74,30 @@ async def test_crossref_rejects_large_year_mismatch(monkeypatch: pytest.MonkeyPa
         max_rows=10,
         email=None,
     )
-    assert doi is None
+    assert doi == "10.1000/wrong-year"
+
+
+@pytest.mark.asyncio
+async def test_crossref_relaxed_fallback_allows_author_mismatch_for_strong_title_match(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    async def _fake_fetch_items(**_kwargs):
+        return [
+            {
+                "DOI": "10.1000/author-fallback",
+                "title": ["Induction of Pluripotent Stem Cells from Adult Human Fibroblasts"],
+                "issued": {"date-parts": [[2007]]},
+                "author": [{"family": "SomeoneElse"}],
+            }
+        ]
+
+    monkeypatch.setattr(crossref_app, "_fetch_items", _fake_fetch_items)
+    doi = await crossref_app.discover_doi_for_publication(
+        item=_item(
+            title="Induction of Pluripotent Stem Cells from Adult Human Fibroblasts",
+            year=2007,
+        ),
+        max_rows=10,
+        email=None,
+    )
+    assert doi == "10.1000/author-fallback"
diff --git a/tests/unit/test_publication_identifiers.py b/tests/unit/test_publication_identifiers.py
new file mode 100644
index 0000000..feab56b
--- /dev/null
+++ b/tests/unit/test_publication_identifiers.py
@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from app.services.domains.publication_identifiers import application as identifier_service
+
+
+def test_derive_display_identifier_prefers_doi_over_arxiv() -> None:
+    display = identifier_service.derive_display_identifier_from_values(
+        doi="10.1000/example",
+        pub_url="https://arxiv.org/abs/1504.08025",
+        pdf_url=None,
+    )
+    assert display is not None
+    assert display.kind == "doi"
+    assert display.value == "10.1000/example"
+    assert display.url == "https://doi.org/10.1000/example"
+
+
+def test_derive_display_identifier_uses_arxiv_when_doi_missing() -> None:
+    display = identifier_service.derive_display_identifier_from_values(
+        doi=None,
+        pub_url="https://arxiv.org/pdf/1504.08025v2",
+        pdf_url=None,
+    )
+    assert display is not None
+    assert display.kind == "arxiv"
+    assert display.value == "1504.08025v2"
+    assert display.label == "arXiv: 1504.08025v2"
+
+
+def test_derive_display_identifier_uses_pmcid_when_present() -> None:
+    display = identifier_service.derive_display_identifier_from_values(
+        doi=None,
+        pub_url=None,
+        pdf_url="https://pmc.ncbi.nlm.nih.gov/articles/PMC2175868/pdf/file.pdf",
+    )
+    assert display is not None
+    assert display.kind == "pmcid"
+    assert display.value == "PMC2175868"
diff --git a/tests/unit/test_publication_pdf_queue_policy.py b/tests/unit/test_publication_pdf_queue_policy.py
index 3d4fe7f..0cc3a7c 100644
--- a/tests/unit/test_publication_pdf_queue_policy.py
+++ b/tests/unit/test_publication_pdf_queue_policy.py
@@ -1,11 +1,14 @@
 from __future__ import annotations
 
 from datetime import datetime, timedelta, timezone
+from types import SimpleNamespace
 
 import pytest
 
 from app.db.models import PublicationPdfJob
 from app.services.domains.publications import pdf_queue
+from app.services.domains.publications.pdf_resolution_pipeline import PipelineOutcome
+from app.services.domains.unpaywall.application import OaResolutionOutcome
 
 
 def _job(
@@ -22,6 +25,25 @@ def _job(
     )
 
 
+def _row(*, pub_url: str | None = "https://scholar.google.com/citations?view_op=view_citation&citation_for_view=abc:xyz") -> SimpleNamespace:
+    return SimpleNamespace(
+        publication_id=1,
+        scholar_profile_id=1,
+        scholar_label="Ada Lovelace",
+        title="A paper",
+        year=2024,
+        citation_count=0,
+        venue_text=None,
+        pub_url=pub_url,
+        doi=None,
+        pdf_url=None,
+        is_read=False,
+        is_favorite=False,
+        first_seen_at=datetime(2026, 2, 22, 12, 0, tzinfo=timezone.utc),
+        is_new_in_latest_run=True,
+    )
+
+
 def test_pdf_queue_auto_enqueue_blocks_recent_attempt(monkeypatch: pytest.MonkeyPatch) -> None:
     now = datetime(2026, 2, 21, 12, 0, tzinfo=timezone.utc)
     monkeypatch.setattr(pdf_queue, "_utcnow", lambda: now)
@@ -107,3 +129,44 @@ def test_pdf_queue_manual_requeue_still_blocks_when_inflight() -> None:
     )
     assert pdf_queue._can_enqueue_job(running, force_retry=True) is False
     assert pdf_queue._can_enqueue_job(queued, force_retry=True) is False
+
+
+@pytest.mark.asyncio
+async def test_fetch_outcome_for_row_uses_pipeline_outcome(monkeypatch: pytest.MonkeyPatch) -> None:
+    async def _fake_pipeline(*, row, request_email=None):
+        assert request_email == "user@example.com"
+        return PipelineOutcome(
+            outcome=OaResolutionOutcome(
+                publication_id=row.publication_id,
+                doi=None,
+                pdf_url="https://arxiv.org/pdf/1703.06103",
+                failure_reason=None,
+                source=pdf_queue.PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE,
+                used_crossref=False,
+            ),
+            scholar_candidates=None,
+        )
+
+    monkeypatch.setattr(pdf_queue, "resolve_publication_pdf_outcome_for_row", _fake_pipeline)
+
+    outcome = await pdf_queue._fetch_outcome_for_row(row=_row(), request_email="user@example.com")
+
+    assert outcome.pdf_url == "https://arxiv.org/pdf/1703.06103"
+    assert outcome.source == pdf_queue.PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE
+    assert outcome.used_crossref is False
+
+
+@pytest.mark.asyncio
+async def test_fetch_outcome_for_row_returns_failed_outcome_when_pipeline_returns_none(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    async def _fake_pipeline(*, row, request_email=None):
+        assert request_email == "user@example.com"
+        return PipelineOutcome(outcome=None, scholar_candidates=None)
+
+    monkeypatch.setattr(pdf_queue, "resolve_publication_pdf_outcome_for_row", _fake_pipeline)
+
+    outcome = await pdf_queue._fetch_outcome_for_row(row=_row(), request_email="user@example.com")
+
+    assert outcome.pdf_url is None
+    assert outcome.failure_reason == pdf_queue.FAILURE_RESOLUTION_EXCEPTION
diff --git a/tests/unit/test_publication_pdf_resolution_pipeline.py b/tests/unit/test_publication_pdf_resolution_pipeline.py
new file mode 100644
index 0000000..bc7bb5c
--- /dev/null
+++ b/tests/unit/test_publication_pdf_resolution_pipeline.py
@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from types import SimpleNamespace
+
+import pytest
+
+from app.services.domains.publications import pdf_resolution_pipeline as pipeline
+from app.services.domains.unpaywall.application import OaResolutionOutcome
+
+
+@dataclass(frozen=True)
+class _Candidate:
+    url: str
+    confidence_score: float
+    label_present: bool
+    reason: str
+
+
+@dataclass(frozen=True)
+class _Candidates:
+    container_seen: bool
+    labeled_candidate: _Candidate | None
+    fallback_candidate: _Candidate | None
+    warnings: tuple[str, ...] = ()
+
+
+def _row(*, doi: str | None = None) -> SimpleNamespace:
+    return SimpleNamespace(
+        publication_id=1,
+        scholar_profile_id=1,
+        scholar_label="Ada Lovelace",
+        title="A paper",
+        year=2024,
+        citation_count=0,
+        venue_text=None,
+        pub_url="https://scholar.google.com/citations?view_op=view_citation&citation_for_view=abc:xyz",
+        doi=doi,
+        pdf_url=None,
+        is_read=False,
+        is_favorite=False,
+        first_seen_at=datetime(2026, 2, 22, 12, 0, tzinfo=timezone.utc),
+        is_new_in_latest_run=True,
+    )
+
+
+def _oa_outcome(*, pdf_url: str | None, source: str = "unpaywall") -> OaResolutionOutcome:
+    return OaResolutionOutcome(
+        publication_id=1,
+        doi="10.1000/example",
+        pdf_url=pdf_url,
+        failure_reason=None if pdf_url else "no_pdf_found",
+        source=source,
+        used_crossref=False,
+    )
+
+
+@pytest.mark.asyncio
+async def test_pipeline_prefers_labeled_scholar_candidate_before_oa(monkeypatch: pytest.MonkeyPatch) -> None:
+    async def _fake_candidates(_url):
+        return _Candidates(
+            container_seen=True,
+            labeled_candidate=_Candidate(
+                url="https://arxiv.org/pdf/1703.06103",
+                confidence_score=0.98,
+                label_present=True,
+                reason="scholar_link_labeled_pdf",
+            ),
+            fallback_candidate=None,
+        )
+
+    async def _fail_oa(*, row, request_email):
+        raise AssertionError(f"OA should not run when labeled Scholar candidate exists: {row.publication_id} {request_email}")
+
+    monkeypatch.setattr(pipeline, "fetch_link_candidates_from_scholar_publication_page", _fake_candidates)
+    monkeypatch.setattr(pipeline, "_oa_outcome", _fail_oa)
+
+    result = await pipeline.resolve_publication_pdf_outcome_for_row(row=_row(), request_email="user@example.com")
+
+    assert result.outcome is not None
+    assert result.outcome.pdf_url == "https://arxiv.org/pdf/1703.06103"
+    assert result.outcome.source == pipeline.PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE
+
+
+@pytest.mark.asyncio
+async def test_pipeline_uses_oa_result_before_unlabeled_fallback(monkeypatch: pytest.MonkeyPatch) -> None:
+    async def _fake_candidates(_url):
+        return _Candidates(
+            container_seen=True,
+            labeled_candidate=None,
+            fallback_candidate=_Candidate(
+                url="https://example.org/download/42",
+                confidence_score=0.2,
+                label_present=False,
+                reason="scholar_link_unlabeled_fallback",
+            ),
+        )
+
+    async def _fake_oa(*, row, request_email):
+        assert request_email == "user@example.com"
+        return _oa_outcome(pdf_url="https://oa.example.org/found.pdf")
+
+    async def _fail_fallback(*, row, candidate):
+        raise AssertionError(f"Unlabeled fallback should not run when OA returns PDF: {row.publication_id} {candidate.url}")
+
+    monkeypatch.setattr(pipeline, "fetch_link_candidates_from_scholar_publication_page", _fake_candidates)
+    monkeypatch.setattr(pipeline, "_oa_outcome", _fake_oa)
+    monkeypatch.setattr(pipeline, "_unlabeled_fallback_outcome", _fail_fallback)
+
+    result = await pipeline.resolve_publication_pdf_outcome_for_row(row=_row(), request_email="user@example.com")
+
+    assert result.outcome is not None
+    assert result.outcome.pdf_url == "https://oa.example.org/found.pdf"
+    assert result.outcome.source == "unpaywall"
+
+
+@pytest.mark.asyncio
+async def test_pipeline_uses_unlabeled_fallback_after_oa_failure(monkeypatch: pytest.MonkeyPatch) -> None:
+    fallback_candidate = _Candidate(
+        url="https://example.org/download/42",
+        confidence_score=0.2,
+        label_present=False,
+        reason="scholar_link_unlabeled_fallback",
+    )
+
+    async def _fake_candidates(_url):
+        return _Candidates(container_seen=True, labeled_candidate=None, fallback_candidate=fallback_candidate)
+
+    async def _fake_oa(*, row, request_email):
+        assert request_email == "user@example.com"
+        return _oa_outcome(pdf_url=None)
+
+    async def _fake_fallback(*, row, candidate):
+        assert candidate == fallback_candidate
+        return OaResolutionOutcome(
+            publication_id=row.publication_id,
+            doi=row.doi,
+            pdf_url="https://example.org/fallback.pdf",
+            failure_reason=None,
+            source=pipeline.PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE_UNLABELED,
+            used_crossref=False,
+        )
+
+    monkeypatch.setattr(pipeline, "fetch_link_candidates_from_scholar_publication_page", _fake_candidates)
+    monkeypatch.setattr(pipeline, "_oa_outcome", _fake_oa)
+    monkeypatch.setattr(pipeline, "_unlabeled_fallback_outcome", _fake_fallback)
+
+    result = await pipeline.resolve_publication_pdf_outcome_for_row(row=_row(), request_email="user@example.com")
+
+    assert result.outcome is not None
+    assert result.outcome.pdf_url == "https://example.org/fallback.pdf"
+    assert result.outcome.source == pipeline.PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE_UNLABELED
diff --git a/tests/unit/test_scholar_publication_pdf.py b/tests/unit/test_scholar_publication_pdf.py
new file mode 100644
index 0000000..7382b77
--- /dev/null
+++ b/tests/unit/test_scholar_publication_pdf.py
@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import pytest
+
+from app.services.domains.scholar.parser_types import ScholarDomInvariantError
+from app.services.domains.scholar.publication_pdf import (
+    extract_link_candidates_from_publication_detail_html,
+    is_scholar_publication_detail_url,
+)
+
+
+def test_extract_link_candidates_from_publication_detail_html_reads_gsc_oci_pdf_link() -> None:
+    html = """
+    <html><body>
+      <div id="gsc_oci_title_gg">
+        <div class="gsc_oci_title_ggi">
+          <a href="https://arxiv.org/pdf/1703.06103" data-clk="x">
+            <span class="gsc_vcd_title_ggt">[PDF]</span> from arxiv.org
+          </a>
+        </div>
+      </div>
+    </body></html>
+    """
+    candidates = extract_link_candidates_from_publication_detail_html(html)
+    assert candidates.labeled_candidate is not None
+    assert candidates.labeled_candidate.url == "https://arxiv.org/pdf/1703.06103"
+
+
+def test_extract_link_candidates_from_publication_detail_html_returns_no_candidates_when_container_missing() -> None:
+    html = "<html><body><div id='gsc_oci_title'>No PDF section</div></body></html>"
+    candidates = extract_link_candidates_from_publication_detail_html(html)
+    assert candidates.container_seen is False
+    assert candidates.labeled_candidate is None
+    assert candidates.fallback_candidate is None
+
+
+def test_extract_pdf_url_from_publication_detail_html_fails_fast_on_malformed_pdf_container() -> None:
+    html = """
+    <html><body>
+      <div id="gsc_oci_title_gg">
+        <div class="gsc_oci_title_ggi">
+          <a data-clk="x"><span class="gsc_vcd_title_ggt">[PDF]</span> from example.org</a>
+        </div>
+      </div>
+    </body></html>
+    """
+    with pytest.raises(ScholarDomInvariantError) as exc:
+        extract_link_candidates_from_publication_detail_html(html)
+    assert exc.value.code == "layout_publication_link_missing_href"
+
+
+def test_extract_link_candidates_from_publication_detail_html_keeps_unlabeled_fallback() -> None:
+    html = """
+    <html><body>
+      <div id="gsc_oci_title_gg">
+        <div class="gsc_oci_title_ggi">
+          <a href="https://example.org/download?id=42">from example.org</a>
+        </div>
+      </div>
+    </body></html>
+    """
+    candidates = extract_link_candidates_from_publication_detail_html(html)
+    assert candidates.container_seen is True
+    assert candidates.labeled_candidate is None
+    assert candidates.fallback_candidate is not None
+    assert candidates.fallback_candidate.url == "https://example.org/download?id=42"
+    assert candidates.fallback_candidate.label_present is False
+    assert "scholar_publication_link_unlabeled_only" in candidates.warnings
+    assert candidates.labeled_candidate is None
+
+
+def test_is_scholar_publication_detail_url_matches_view_citation_links() -> None:
+    assert is_scholar_publication_detail_url(
+        "https://scholar.google.com/citations?view_op=view_citation&hl=en&user=8200InoAAAAJ&citation_for_view=8200InoAAAAJ:gsN89kCJA0AC"
+    ) is True
+    assert is_scholar_publication_detail_url("https://example.org/paper") is False
diff --git a/tests/unit/test_unpaywall_resolution.py b/tests/unit/test_unpaywall_resolution.py
index 5cc34ce..651b33d 100644
--- a/tests/unit/test_unpaywall_resolution.py
+++ b/tests/unit/test_unpaywall_resolution.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import replace
 from datetime import datetime, timezone
 
 import pytest
@@ -38,6 +39,26 @@ def _item(publication_id: int) -> PublicationListItem:
     )
 
 
+def test_publication_doi_uses_stored_value_when_metadata_has_no_doi() -> None:
+    item = replace(
+        _item(99),
+        pub_url="https://scholar.google.com/citations?view_op=view_citation&citation_for_view=abc:123",
+        venue_text="Cell 130 (5), 2007",
+        doi="10.1016/j.cell.2007.11.019",
+    )
+    assert unpaywall_app._publication_doi(item) == "10.1016/j.cell.2007.11.019"
+
+
+def test_publication_doi_prefers_explicit_metadata_doi_over_stored_value() -> None:
+    item = replace(
+        _item(100),
+        pub_url="https://doi.org/10.2000/fresh-value",
+        venue_text="Cell",
+        doi="10.1000/stale-value",
+    )
+    assert unpaywall_app._publication_doi(item) == "10.2000/fresh-value"
+
+
 @pytest.mark.asyncio
 async def test_unpaywall_resolve_prefers_direct_pdf_without_landing_crawl(monkeypatch: pytest.MonkeyPatch) -> None:
     payload = {
@@ -49,7 +70,7 @@ async def test_unpaywall_resolve_prefers_direct_pdf_without_landing_crawl(monkey
     }
 
     async def _fake_resolve_item_payload(**_kwargs):
-        return payload, False
+        return payload, False, "10.1016/j.cell.2007.11.019"
 
     async def _fail_crawl(_client, *, page_url: str):
         raise AssertionError(f"unexpected landing crawl: {page_url}")
@@ -75,7 +96,7 @@ async def test_unpaywall_resolve_crawls_landing_page_when_pdf_url_is_not_direct(
     crawled_pages: list[str] = []
 
     async def _fake_resolve_item_payload(**_kwargs):
-        return payload, False
+        return payload, False, "10.1016/j.cell.2007.11.019"
 
     async def _fake_crawl(_client, *, page_url: str):
         crawled_pages.append(page_url)
@@ -87,3 +108,22 @@ async def test_unpaywall_resolve_crawls_landing_page_when_pdf_url_is_not_direct(
     resolved = await unpaywall_app.resolve_publication_oa_metadata([_item(2)], request_email="user@example.com")
     assert resolved == {2: ("10.1016/j.cell.2007.11.019", "https://oa.example.org/files/paper-42.pdf")}
     assert "https://oa.example.org/landing/42" in crawled_pages
+
+
+@pytest.mark.asyncio
+async def test_unpaywall_preserves_crossref_doi_when_unpaywall_has_no_record(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    async def _fake_resolve_item_payload(**_kwargs):
+        return None, True, "10.2000/crossref-only"
+
+    monkeypatch.setattr(unpaywall_app, "_resolve_item_payload", _fake_resolve_item_payload)
+    monkeypatch.setattr("httpx.AsyncClient", _DummyAsyncClient)
+
+    outcomes = await unpaywall_app.resolve_publication_oa_outcomes([_item(3)], request_email="user@example.com")
+
+    outcome = outcomes[3]
+    assert outcome.doi == "10.2000/crossref-only"
+    assert outcome.pdf_url is None
+    assert outcome.failure_reason == unpaywall_app.FAILURE_NO_RECORD
+    assert outcome.used_crossref is True
-- 
2.49.1


From 8760f27b51417e676a040bede3650958cbd1f935 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Sun, 22 Feb 2026 16:35:39 +0100
Subject: [PATCH 02/38] small ui update

---
 frontend/src/pages/PublicationsPage.vue | 10 ++++++++--
 frontend/src/pages/ScholarsPage.vue     |  2 +-
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/frontend/src/pages/PublicationsPage.vue b/frontend/src/pages/PublicationsPage.vue
index beeedc7..21afc03 100644
--- a/frontend/src/pages/PublicationsPage.vue
+++ b/frontend/src/pages/PublicationsPage.vue
@@ -802,8 +802,13 @@ watch(
 </script>
 
 <template>
-  <AppPage title="Publications" subtitle="Review discoveries, open PDFs, and update read/favorite state in one workspace.">
-    <AppCard class="space-y-4">
+  <AppPage
+    title="Publications"
+    subtitle="Review discoveries, open PDFs, and update read/favorite state in one workspace."
+    fill
+  >
+    <div class="flex min-h-0 flex-1 flex-col gap-4 xl:overflow-hidden">
+      <AppCard class="flex min-h-0 flex-1 flex-col gap-4">
       <div class="grid gap-3 xl:grid-cols-[minmax(0,13rem)_minmax(0,18rem)_minmax(0,1fr)_auto] xl:items-end">
         <div class="grid gap-1 text-xs text-secondary">
           <div class="flex items-center gap-1">
@@ -1116,6 +1121,7 @@ watch(
         </div>
       </div>
     </AppCard>
+    </div>
   </AppPage>
 </template>
 
diff --git a/frontend/src/pages/ScholarsPage.vue b/frontend/src/pages/ScholarsPage.vue
index 4c8fb57..a8794f2 100644
--- a/frontend/src/pages/ScholarsPage.vue
+++ b/frontend/src/pages/ScholarsPage.vue
@@ -869,7 +869,7 @@ onMounted(() => {
               />
 
               <div v-else class="space-y-3 xl:flex xl:h-full xl:min-h-0 xl:flex-col xl:space-y-0 xl:overflow-hidden">
-                <ul class="grid gap-3 lg:hidden">
+                <ul class="flex gap-3 overflow-x-auto p-1 lg:hidden">
                   <li
                     v-for="item in visibleScholars"
                     :key="item.id"
-- 
2.49.1


From 0e9e49df169741402d1a86361f0c618cffc0e50f Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Thu, 26 Feb 2026 12:54:19 +0100
Subject: [PATCH 03/38] temp commit

---
 README.md                                     |   41 +-
 agents.md                                     |   48 +-
 ...8_add_openalex_enriched_to_publications.py |   30 +
 ...0260224_0019_add_resolving_to_runstatus.py |   31 +
 ...60224_0020_add_openalex_last_attempt_at.py |   26 +
 ...0021_enforce_single_active_run_per_user.py |   70 +
 ...dd_canonical_title_hash_to_publications.py |   35 +
 ...ef777_remove_doi_from_publications_and_.py |   27 +
 ...add_api_integration_keys_to_usersetting.py |   39 +
 app/api/routers/admin_dbops.py                |   62 +-
 app/api/routers/publications.py               |   53 +-
 app/api/routers/runs.py                       |  194 +-
 app/api/routers/settings.py                   |    7 +
 app/api/schemas.py                            |   12 +-
 app/db/models.py                              |   25 +-
 app/main.py                                   |   12 +
 app/services/domains/arxiv/application.py     |  110 +
 app/services/domains/ingestion/application.py |  862 +++++-
 .../domains/ingestion/fingerprints.py         |  141 +-
 app/services/domains/ingestion/scheduler.py   |   26 +
 app/services/domains/ingestion/types.py       |    2 +
 app/services/domains/openalex/__init__.py     |    5 +
 app/services/domains/openalex/client.py       |  151 ++
 app/services/domains/openalex/matching.py     |  108 +
 app/services/domains/openalex/types.py        |   71 +
 app/services/domains/portability/exporting.py |    3 -
 .../domains/portability/publication_import.py |    8 -
 .../publication_identifiers/application.py    |   90 +-
 .../publication_identifiers/normalize.py      |    2 +-
 .../domains/publications/application.py       |    4 +-
 app/services/domains/publications/counts.py   |   19 +-
 app/services/domains/publications/dedup.py    |  103 +
 app/services/domains/publications/listing.py  |   16 +-
 .../domains/publications/pdf_queue.py         |  140 +-
 .../publications/pdf_resolution_pipeline.py   |  201 +-
 app/services/domains/publications/queries.py  |   56 +-
 app/services/domains/publications/types.py    |    2 -
 app/services/domains/runs/events.py           |   59 +
 .../domains/scholar/publication_pdf.py        |  232 --
 app/services/domains/settings/application.py  |   15 +-
 app/services/domains/unpaywall/application.py |   10 +-
 app/settings.py                               |   14 +-
 build/lib/app/__init__.py                     |    1 +
 build/lib/app/api/__init__.py                 |    2 +
 build/lib/app/api/deps.py                     |   35 +
 build/lib/app/api/errors.py                   |   85 +
 build/lib/app/api/media.py                    |   63 +
 build/lib/app/api/responses.py                |   64 +
 build/lib/app/api/router.py                   |   14 +
 build/lib/app/api/routers/__init__.py         |    2 +
 build/lib/app/api/routers/admin.py            |  202 ++
 build/lib/app/api/routers/admin_dbops.py      |  349 +++
 build/lib/app/api/routers/auth.py             |  237 ++
 build/lib/app/api/routers/publications.py     |  528 ++++
 build/lib/app/api/routers/runs.py             |  845 ++++++
 build/lib/app/api/routers/scholars.py         |  557 ++++
 build/lib/app/api/routers/settings.py         |  189 ++
 build/lib/app/api/runtime_deps.py             |   16 +
 build/lib/app/api/schemas.py                  |  884 ++++++
 build/lib/app/auth/__init__.py                |    2 +
 build/lib/app/auth/deps.py                    |   27 +
 build/lib/app/auth/rate_limit.py              |   69 +
 build/lib/app/auth/runtime.py                 |   55 +
 build/lib/app/auth/security.py                |   19 +
 build/lib/app/auth/service.py                 |   38 +
 build/lib/app/auth/session.py                 |   50 +
 build/lib/app/db/__init__.py                  |    1 +
 build/lib/app/db/base.py                      |   27 +
 build/lib/app/db/models.py                    |  546 ++++
 build/lib/app/db/session.py                   |   99 +
 build/lib/app/http/__init__.py                |    1 +
 build/lib/app/http/middleware.py              |  205 ++
 build/lib/app/logging_config.py               |  183 ++
 build/lib/app/logging_context.py              |   15 +
 build/lib/app/main.py                         |  168 ++
 build/lib/app/security/__init__.py            |    2 +
 build/lib/app/security/csrf.py                |  133 +
 build/lib/app/services/__init__.py            |    2 +
 build/lib/app/services/domains/__init__.py    |    1 +
 .../app/services/domains/arxiv/application.py |   84 +
 .../app/services/domains/crossref/__init__.py |    5 +
 .../services/domains/crossref/application.py  |  382 +++
 .../app/services/domains/dbops/__init__.py    |    5 +
 .../app/services/domains/dbops/application.py |  364 +++
 .../app/services/domains/dbops/integrity.py   |  175 ++
 build/lib/app/services/domains/dbops/query.py |   22 +
 .../lib/app/services/domains/doi/normalize.py |   23 +
 .../services/domains/ingestion/__init__.py    |    1 +
 .../services/domains/ingestion/application.py | 2413 +++++++++++++++++
 .../services/domains/ingestion/constants.py   |   31 +
 .../domains/ingestion/fingerprints.py         |  175 ++
 .../app/services/domains/ingestion/queue.py   |  348 +++
 .../app/services/domains/ingestion/safety.py  |  282 ++
 .../services/domains/ingestion/scheduler.py   |  622 +++++
 .../app/services/domains/ingestion/types.py   |  110 +
 .../app/services/domains/openalex/__init__.py |    5 +
 .../app/services/domains/openalex/client.py   |  135 +
 .../app/services/domains/openalex/matching.py |  108 +
 .../app/services/domains/openalex/types.py    |   71 +
 .../services/domains/portability/__init__.py  |    1 +
 .../domains/portability/application.py        |   67 +
 .../services/domains/portability/constants.py |    9 +
 .../services/domains/portability/exporting.py |   91 +
 .../services/domains/portability/normalize.py |  109 +
 .../domains/portability/publication_import.py |  370 +++
 .../domains/portability/scholar_import.py     |  107 +
 .../app/services/domains/portability/types.py |   25 +
 .../publication_identifiers/__init__.py       |   17 +
 .../publication_identifiers/application.py    |  433 +++
 .../publication_identifiers/normalize.py      |   76 +
 .../domains/publication_identifiers/types.py  |   30 +
 .../services/domains/publications/__init__.py |    1 +
 .../domains/publications/application.py       |   74 +
 .../services/domains/publications/counts.py   |   90 +
 .../domains/publications/enrichment.py        |   73 +
 .../services/domains/publications/listing.py  |   93 +
 .../services/domains/publications/modes.py    |   14 +
 .../domains/publications/pdf_queue.py         |  915 +++++++
 .../publications/pdf_resolution_pipeline.py   |  108 +
 .../services/domains/publications/queries.py  |  203 ++
 .../domains/publications/read_state.py        |   94 +
 .../services/domains/publications/types.py    |   41 +
 .../lib/app/services/domains/runs/__init__.py |    1 +
 .../app/services/domains/runs/application.py  |   45 +
 build/lib/app/services/domains/runs/events.py |   59 +
 .../services/domains/runs/queue_queries.py    |   70 +
 .../services/domains/runs/queue_service.py    |  182 ++
 .../app/services/domains/runs/runs_service.py |   79 +
 .../lib/app/services/domains/runs/summary.py  |   76 +
 build/lib/app/services/domains/runs/types.py  |   38 +
 .../app/services/domains/scholar/__init__.py  |    1 +
 .../services/domains/scholar/author_rows.py   |  202 ++
 .../app/services/domains/scholar/parser.py    |  165 ++
 .../domains/scholar/parser_constants.py       |   87 +
 .../services/domains/scholar/parser_types.py  |   75 +
 .../services/domains/scholar/parser_utils.py  |   42 +
 .../services/domains/scholar/profile_rows.py  |  270 ++
 .../services/domains/scholar/rate_limit.py    |   18 +
 .../app/services/domains/scholar/source.py    |  235 ++
 .../domains/scholar/state_detection.py        |  164 ++
 .../app/services/domains/scholars/__init__.py |    1 +
 .../services/domains/scholars/application.py  |  974 +++++++
 .../services/domains/scholars/constants.py    |   70 +
 .../services/domains/scholars/exceptions.py   |    5 +
 .../services/domains/scholars/search_hints.py |   67 +
 .../app/services/domains/scholars/uploads.py  |   39 +
 .../services/domains/scholars/validators.py   |   38 +
 .../app/services/domains/settings/__init__.py |    1 +
 .../services/domains/settings/application.py  |  159 ++
 .../services/domains/unpaywall/__init__.py    |   10 +
 .../services/domains/unpaywall/application.py |  458 ++++
 .../domains/unpaywall/pdf_discovery.py        |  156 ++
 .../services/domains/unpaywall/rate_limit.py  |   18 +
 .../app/services/domains/users/__init__.py    |    1 +
 .../app/services/domains/users/application.py |   98 +
 build/lib/app/settings.py                     |  267 ++
 diag_pubs.py                                  |   39 +
 docs/developer/api-contract.md                |   12 +
 docs/developer/architecture.md                |   32 +-
 docs/developer/ingestion.md                   |   26 +
 docs/developer/overview.md                    |    2 +
 frontend/src/components/layout/AppNav.vue     |    4 +
 .../components/patterns/RunStatusBadge.vue    |    6 +
 frontend/src/features/admin_dbops/index.ts    |   17 +-
 frontend/src/features/publications/index.ts   |   18 +-
 frontend/src/features/runs/index.ts           |    7 +
 frontend/src/features/scholars/index.ts       |    3 +-
 .../features/settings/SettingsAdminPanel.vue  |   64 +
 frontend/src/features/settings/index.ts       |    6 +
 frontend/src/pages/DashboardPage.vue          |   63 +-
 frontend/src/pages/PublicationsPage.vue       |  154 +-
 frontend/src/pages/RunsPage.vue               |   43 +-
 frontend/src/pages/SettingsPage.vue           |   56 +
 frontend/src/stores/run_status.test.ts        |   88 +-
 frontend/src/stores/run_status.ts             |  157 +-
 frontend/src/stores/user_settings.test.ts     |    3 +
 pyproject.toml                                |    2 +
 test_enrich.py                                |   42 +
 tests/integration/test_api_v1.py              |  238 +-
 tests/integration/test_deferred_enrichment.py |  103 +
 tests/integration/test_fixture_probe_runs.py  |    4 +-
 tests/integration/test_migrations.py          |   24 +-
 .../test_run_lifecycle_consistency.py         |  514 ++++
 .../services/domains/openalex/test_client.py  |   64 +
 .../domains/openalex/test_matching.py         |   55 +
 .../domains/publications/test_dedup.py        |  163 ++
 tests/unit/test_fingerprints.py               |  242 ++
 tests/unit/test_publication_identifiers.py    |   69 +
 .../unit/test_publication_pdf_queue_policy.py |   72 +-
 ...est_publication_pdf_resolution_pipeline.py |  149 +-
 tests/unit/test_scholar_publication_pdf.py    |   76 -
 tests/unit/test_unpaywall_resolution.py       |   19 +-
 uv.lock                                       |   76 +
 193 files changed, 23228 insertions(+), 935 deletions(-)
 create mode 100644 alembic/versions/20260224_0018_add_openalex_enriched_to_publications.py
 create mode 100644 alembic/versions/20260224_0019_add_resolving_to_runstatus.py
 create mode 100644 alembic/versions/20260224_0020_add_openalex_last_attempt_at.py
 create mode 100644 alembic/versions/20260225_0021_enforce_single_active_run_per_user.py
 create mode 100644 alembic/versions/20260225_0022_add_canonical_title_hash_to_publications.py
 create mode 100644 alembic/versions/44f7e10ef777_remove_doi_from_publications_and_.py
 create mode 100644 alembic/versions/fa0c5e3262d5_add_api_integration_keys_to_usersetting.py
 create mode 100644 app/services/domains/arxiv/application.py
 create mode 100644 app/services/domains/openalex/__init__.py
 create mode 100644 app/services/domains/openalex/client.py
 create mode 100644 app/services/domains/openalex/matching.py
 create mode 100644 app/services/domains/openalex/types.py
 create mode 100644 app/services/domains/publications/dedup.py
 create mode 100644 app/services/domains/runs/events.py
 delete mode 100644 app/services/domains/scholar/publication_pdf.py
 create mode 100644 build/lib/app/__init__.py
 create mode 100644 build/lib/app/api/__init__.py
 create mode 100644 build/lib/app/api/deps.py
 create mode 100644 build/lib/app/api/errors.py
 create mode 100644 build/lib/app/api/media.py
 create mode 100644 build/lib/app/api/responses.py
 create mode 100644 build/lib/app/api/router.py
 create mode 100644 build/lib/app/api/routers/__init__.py
 create mode 100644 build/lib/app/api/routers/admin.py
 create mode 100644 build/lib/app/api/routers/admin_dbops.py
 create mode 100644 build/lib/app/api/routers/auth.py
 create mode 100644 build/lib/app/api/routers/publications.py
 create mode 100644 build/lib/app/api/routers/runs.py
 create mode 100644 build/lib/app/api/routers/scholars.py
 create mode 100644 build/lib/app/api/routers/settings.py
 create mode 100644 build/lib/app/api/runtime_deps.py
 create mode 100644 build/lib/app/api/schemas.py
 create mode 100644 build/lib/app/auth/__init__.py
 create mode 100644 build/lib/app/auth/deps.py
 create mode 100644 build/lib/app/auth/rate_limit.py
 create mode 100644 build/lib/app/auth/runtime.py
 create mode 100644 build/lib/app/auth/security.py
 create mode 100644 build/lib/app/auth/service.py
 create mode 100644 build/lib/app/auth/session.py
 create mode 100644 build/lib/app/db/__init__.py
 create mode 100644 build/lib/app/db/base.py
 create mode 100644 build/lib/app/db/models.py
 create mode 100644 build/lib/app/db/session.py
 create mode 100644 build/lib/app/http/__init__.py
 create mode 100644 build/lib/app/http/middleware.py
 create mode 100644 build/lib/app/logging_config.py
 create mode 100644 build/lib/app/logging_context.py
 create mode 100644 build/lib/app/main.py
 create mode 100644 build/lib/app/security/__init__.py
 create mode 100644 build/lib/app/security/csrf.py
 create mode 100644 build/lib/app/services/__init__.py
 create mode 100644 build/lib/app/services/domains/__init__.py
 create mode 100644 build/lib/app/services/domains/arxiv/application.py
 create mode 100644 build/lib/app/services/domains/crossref/__init__.py
 create mode 100644 build/lib/app/services/domains/crossref/application.py
 create mode 100644 build/lib/app/services/domains/dbops/__init__.py
 create mode 100644 build/lib/app/services/domains/dbops/application.py
 create mode 100644 build/lib/app/services/domains/dbops/integrity.py
 create mode 100644 build/lib/app/services/domains/dbops/query.py
 create mode 100644 build/lib/app/services/domains/doi/normalize.py
 create mode 100644 build/lib/app/services/domains/ingestion/__init__.py
 create mode 100644 build/lib/app/services/domains/ingestion/application.py
 create mode 100644 build/lib/app/services/domains/ingestion/constants.py
 create mode 100644 build/lib/app/services/domains/ingestion/fingerprints.py
 create mode 100644 build/lib/app/services/domains/ingestion/queue.py
 create mode 100644 build/lib/app/services/domains/ingestion/safety.py
 create mode 100644 build/lib/app/services/domains/ingestion/scheduler.py
 create mode 100644 build/lib/app/services/domains/ingestion/types.py
 create mode 100644 build/lib/app/services/domains/openalex/__init__.py
 create mode 100644 build/lib/app/services/domains/openalex/client.py
 create mode 100644 build/lib/app/services/domains/openalex/matching.py
 create mode 100644 build/lib/app/services/domains/openalex/types.py
 create mode 100644 build/lib/app/services/domains/portability/__init__.py
 create mode 100644 build/lib/app/services/domains/portability/application.py
 create mode 100644 build/lib/app/services/domains/portability/constants.py
 create mode 100644 build/lib/app/services/domains/portability/exporting.py
 create mode 100644 build/lib/app/services/domains/portability/normalize.py
 create mode 100644 build/lib/app/services/domains/portability/publication_import.py
 create mode 100644 build/lib/app/services/domains/portability/scholar_import.py
 create mode 100644 build/lib/app/services/domains/portability/types.py
 create mode 100644 build/lib/app/services/domains/publication_identifiers/__init__.py
 create mode 100644 build/lib/app/services/domains/publication_identifiers/application.py
 create mode 100644 build/lib/app/services/domains/publication_identifiers/normalize.py
 create mode 100644 build/lib/app/services/domains/publication_identifiers/types.py
 create mode 100644 build/lib/app/services/domains/publications/__init__.py
 create mode 100644 build/lib/app/services/domains/publications/application.py
 create mode 100644 build/lib/app/services/domains/publications/counts.py
 create mode 100644 build/lib/app/services/domains/publications/enrichment.py
 create mode 100644 build/lib/app/services/domains/publications/listing.py
 create mode 100644 build/lib/app/services/domains/publications/modes.py
 create mode 100644 build/lib/app/services/domains/publications/pdf_queue.py
 create mode 100644 build/lib/app/services/domains/publications/pdf_resolution_pipeline.py
 create mode 100644 build/lib/app/services/domains/publications/queries.py
 create mode 100644 build/lib/app/services/domains/publications/read_state.py
 create mode 100644 build/lib/app/services/domains/publications/types.py
 create mode 100644 build/lib/app/services/domains/runs/__init__.py
 create mode 100644 build/lib/app/services/domains/runs/application.py
 create mode 100644 build/lib/app/services/domains/runs/events.py
 create mode 100644 build/lib/app/services/domains/runs/queue_queries.py
 create mode 100644 build/lib/app/services/domains/runs/queue_service.py
 create mode 100644 build/lib/app/services/domains/runs/runs_service.py
 create mode 100644 build/lib/app/services/domains/runs/summary.py
 create mode 100644 build/lib/app/services/domains/runs/types.py
 create mode 100644 build/lib/app/services/domains/scholar/__init__.py
 create mode 100644 build/lib/app/services/domains/scholar/author_rows.py
 create mode 100644 build/lib/app/services/domains/scholar/parser.py
 create mode 100644 build/lib/app/services/domains/scholar/parser_constants.py
 create mode 100644 build/lib/app/services/domains/scholar/parser_types.py
 create mode 100644 build/lib/app/services/domains/scholar/parser_utils.py
 create mode 100644 build/lib/app/services/domains/scholar/profile_rows.py
 create mode 100644 build/lib/app/services/domains/scholar/rate_limit.py
 create mode 100644 build/lib/app/services/domains/scholar/source.py
 create mode 100644 build/lib/app/services/domains/scholar/state_detection.py
 create mode 100644 build/lib/app/services/domains/scholars/__init__.py
 create mode 100644 build/lib/app/services/domains/scholars/application.py
 create mode 100644 build/lib/app/services/domains/scholars/constants.py
 create mode 100644 build/lib/app/services/domains/scholars/exceptions.py
 create mode 100644 build/lib/app/services/domains/scholars/search_hints.py
 create mode 100644 build/lib/app/services/domains/scholars/uploads.py
 create mode 100644 build/lib/app/services/domains/scholars/validators.py
 create mode 100644 build/lib/app/services/domains/settings/__init__.py
 create mode 100644 build/lib/app/services/domains/settings/application.py
 create mode 100644 build/lib/app/services/domains/unpaywall/__init__.py
 create mode 100644 build/lib/app/services/domains/unpaywall/application.py
 create mode 100644 build/lib/app/services/domains/unpaywall/pdf_discovery.py
 create mode 100644 build/lib/app/services/domains/unpaywall/rate_limit.py
 create mode 100644 build/lib/app/services/domains/users/__init__.py
 create mode 100644 build/lib/app/services/domains/users/application.py
 create mode 100644 build/lib/app/settings.py
 create mode 100644 diag_pubs.py
 create mode 100644 docs/developer/api-contract.md
 create mode 100644 docs/developer/ingestion.md
 create mode 100644 test_enrich.py
 create mode 100644 tests/integration/test_deferred_enrichment.py
 create mode 100644 tests/integration/test_run_lifecycle_consistency.py
 create mode 100644 tests/unit/services/domains/openalex/test_client.py
 create mode 100644 tests/unit/services/domains/openalex/test_matching.py
 create mode 100644 tests/unit/services/domains/publications/test_dedup.py
 create mode 100644 tests/unit/test_fingerprints.py
 delete mode 100644 tests/unit/test_scholar_publication_pdf.py

diff --git a/README.md b/README.md
index 5d5f84f..c05beaa 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 <div align="center">
 
-Self-hosted scholar tracking with a single app image (API + frontend).
+Self-hosted scholar tracking with a single app image (API + frontend). It automates publication discovery, parses Google Scholar, gathers external metadata via Crossref & arXiv APIs, and autonomously downloads Open Access PDFs.
 
 [![CI](https://img.shields.io/github/actions/workflow/status/justinzeus/scholarr/ci.yml?style=for-the-badge)](https://github.com/JustinZeus/scholarr/actions/workflows/ci.yml)
 [![Docker Pulls](https://img.shields.io/docker/pulls/justinzeus/scholarr?style=for-the-badge&logo=docker)](https://hub.docker.com/r/justinzeus/scholarr)
@@ -10,6 +10,25 @@ Self-hosted scholar tracking with a single app image (API + frontend).
 
 </div>
 
+## Key Features
+- **Automated Ingestion**: Background tasks regularly scrape author profiles to pull the latest publications.
+- **Resilient Parsing**: Custom DOM parsing logic falls back heavily across changes, backed by a dynamic `429 Too Many Requests` backoff cycle.
+- **Identifier Subsystem**: Isolates DOIs, PMIDs, and arXiv IDs independently of PDFs mapping fallback external APIs sequentially.
+- **Unpaywall PDF Search**: Leverages a fully automated resolution queue to grab public PDFs via the Unpaywall API on identified entries.
+- **Beautiful UI**: Polished Vue 3 frontend that ships natively inside the same Docker container as the FastAPI backend.
+
+## Architecture Data Flow
+```mermaid
+graph LR
+    HTML(Google Scholar) --> |Scraper| Ingestion
+    Ingestion --> |Extract DOI| DB[(Database)]
+    Ingestion -.-> |Fallback API Search| Crossref/arXiv
+    Crossref/arXiv --> DB
+    
+    DB --> |Identified DOIs| PDFQueue(Unpaywall/PDF Workers)
+    PDFQueue --> |Download & Store File| Storage
+```
+
 ## Quick Start
 
 1. Copy env template:
@@ -36,10 +55,12 @@ Open:
 ## Documentation
 
 Complete documentation is published at:
-
 - https://justinzeus.github.io/scholarr/
 
-Source markdown and docs tooling live under `docs/`.
+You can also read the developer/architecture breakdowns directly within the repository under:
+- `docs/developer/architecture.md`
+- `docs/developer/ingestion.md`
+- `docs/developer/api-contract.md`
 
 ## Quality Gates
 
@@ -53,11 +74,14 @@ docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app uv r
 Frontend:
 
 ```bash
-cd frontend
-npm install
-npm run typecheck
-npm run test:run
-npm run build
+# ALL tests/builds MUST be run within the docker container. Do not run raw npm commands on the host.
+# For automated agents checking outputs, redirect stdout/stderr to files (e.g. > /tmp/npm_typecheck.log 2>&1) 
+# The temp files /tmp/npm_test.log, /tmp/npm_lint.log, /tmp/npm_typecheck.log, and /tmp/pytest_eval.log are pre-authorized for overwrite.
+
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm install
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm run typecheck
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm run test:run
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm run build
 ```
 
 Contract and env checks:
@@ -67,3 +91,4 @@ python3 scripts/check_frontend_api_contract.py
 python3 scripts/check_env_contract.py
 ./scripts/check_no_generated_artifacts.sh
 ```
+thanks arxiv
\ No newline at end of file
diff --git a/agents.md b/agents.md
index da59b76..a114a45 100644
--- a/agents.md
+++ b/agents.md
@@ -3,35 +3,45 @@
 Adhere strictly to these constraints.
 
 ## 1. Coding Standards (Strict Enforcement)
-* **Function Length:** Maximum 50 lines of code per function. Break down complex logic into small, testable, single-responsibility functions.
-* **DRY (Don't Repeat Yourself):** Abstract repetitive logic immediately. No duplicate boilerplate for database queries, API responses, or error handling.
-* **Negative Space Programming:** Utilize explicit assertions and constraints to define invalid states. Fail fast and early. Do not allow silent failures or cascading malformed data, especially in DOM parsing.
-* **Cyclomatic Complexity:** Flatten logic. Use early returns and guard clauses instead of deep nesting.
-no magic numbers
+
+- **Function Length:** Maximum 50 lines of code per function. Break down complex logic into small, testable, single-responsibility functions.
+- **DRY (Don't Repeat Yourself):** Abstract repetitive logic immediately. No duplicate boilerplate for database queries, API responses, or error handling.
+- **Negative Space Programming:** Utilize explicit assertions and constraints to define invalid states. Fail fast and early. Do not allow silent failures or cascading malformed data, especially in DOM parsing.
+- **Cyclomatic Complexity:** Flatten logic. Use early returns and guard clauses instead of deep nesting.
+  no magic numbers
 
 ## 2. Domain Architecture & Data Model
-* **Data Isolation:** Scholar tracking is **user-scoped**. Validate mapping/join tables; never assume global links between users and Scholar IDs.
-* **Data Deduplication:** Publications are **global records**. Deduplicate via Scholar cluster ID and normalized fingerprinting prior to database insertion.
-* **State Management:** Visibility and "read/unread" states exist exclusively on the scholar-publication link table, not the global publication table.
-* **API Contract:** Exact envelope format required:
-    * Success: `{"data": ..., "meta": {"request_id": "..."}}`
-    * Error: `{"error": {"code": "...", "message": "...", "details": ...}, "meta": {"request_id": "..."}}`
+
+- **Data Isolation:** Scholar tracking is **user-scoped**. Validate mapping/join tables; never assume global links between users and Scholar IDs.
+- **Data Deduplication:** Publications are **global records**. Deduplicate via Scholar cluster ID and normalized fingerprinting prior to database insertion.
+- **State Management:** Visibility and "read/unread" states exist exclusively on the scholar-publication link table, not the global publication table.
+- **API Contract:** Exact envelope format required:
+  - Success: `{"data": ..., "meta": {"request_id": "..."}}`
+  - Error: `{"error": {"code": "...", "message": "...", "details": ...}, "meta": {"request_id": "..."}}`
 
 ## 3. Scrape Safety & Rate Limiting (Immutable)
+
 These limits prevent IP bans and are not to be optimized away.
-* **Minimum Delay:** Enforce `INGESTION_MIN_REQUEST_DELAY_SECONDS` (default 2s) between all external requests.
-* **Anti-Detection:** Default to direct ID or profile URL ingestion. Name searches trigger CAPTCHAs.
-* **Cooldowns:** Respect `INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS` (1800s) and `INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS` (900s) upon threshold breaches.
+
+- **Minimum Delay:** Enforce `INGESTION_MIN_REQUEST_DELAY_SECONDS` (default 2s) between all external requests.
+- **Anti-Detection:** Default to direct ID or profile URL ingestion. Name searches trigger CAPTCHAs.
+- **Cooldowns:** Respect `INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS` (1800s) and `INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS` (900s) upon threshold breaches.
 
 ## 4. Current Environment & Stack
-* **Backend:** Python 3.12+, FastAPI, SQLAlchemy (Async/asyncpg), Alembic.
-* **Frontend:** TypeScript, Vue 3, Vite.
-* **Infrastructure:** Multi-stage Docker.
+
+- **Backend:** Python 3.12+, FastAPI, SQLAlchemy (Async/asyncpg), Alembic.
+- **Frontend:** TypeScript, Vue 3, Vite.
+- **Infrastructure:** Multi-stage Docker.
 
 ## 5. Domain Service Boundaries
-* **Strict Modularity:** Flat files in the `app/services/` root are strictly prohibited. All business logic and routing must reside exclusively within `app/services/domains/`.
 
+- **Strict Modularity:** Flat files in the `app/services/` root are strictly prohibited. All business logic and routing must reside exclusively within `app/services/domains/`.
 
 ## 6. UI rules
+
 Make sure to properly integrate tailwind in combination with the preset theming
-Clarity through both styling and language are a priority. all UI elements need to have a proper reason for existing.
\ No newline at end of file
+Clarity through both styling and language are a priority. all UI elements need to have a proper reason for existing.
+
+## 7. Testing
+
+All tests need to be ran using containers. `docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app`
diff --git a/alembic/versions/20260224_0018_add_openalex_enriched_to_publications.py b/alembic/versions/20260224_0018_add_openalex_enriched_to_publications.py
new file mode 100644
index 0000000..1d7ecad
--- /dev/null
+++ b/alembic/versions/20260224_0018_add_openalex_enriched_to_publications.py
@@ -0,0 +1,30 @@
+"""Add openalex_enriched to publications
+
+Revision ID: 20260224_0018
+Revises: fa0c5e3262d5
+Create Date: 2026-02-24 19:10:00.000000
+
+"""
+from collections.abc import Sequence
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '20260224_0018'
+down_revision: str | Sequence[str] | None = 'fa0c5e3262d5'
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('publications', sa.Column('openalex_enriched', sa.Boolean(), server_default=sa.text('false'), nullable=False))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('publications', 'openalex_enriched')
+    # ### end Alembic commands ###
diff --git a/alembic/versions/20260224_0019_add_resolving_to_runstatus.py b/alembic/versions/20260224_0019_add_resolving_to_runstatus.py
new file mode 100644
index 0000000..645a32b
--- /dev/null
+++ b/alembic/versions/20260224_0019_add_resolving_to_runstatus.py
@@ -0,0 +1,31 @@
+"""Add resolving to RunStatus enum
+
+Revision ID: 20260224_0019
+Revises: 20260224_0018
+Create Date: 2026-02-24 22:20:00.000000
+
+"""
+from collections.abc import Sequence
+
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision: str = '20260224_0019'
+down_revision: str | Sequence[str] | None = '20260224_0018'
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # Use COMMIT to break out of the transaction block that Alembic creates in env.py.
+    # Postgres restricts ALTER TYPE ... ADD VALUE inside transactions when the type is in use.
+    # This is the robust, non-patchwork way to ensure the schema evolves correctly.
+    op.execute("COMMIT")
+    op.execute("ALTER TYPE run_status ADD VALUE IF NOT EXISTS 'resolving' AFTER 'running'")
+
+
+def downgrade() -> None:
+    # Enum values cannot be easily removed in Postgres without recreating the type,
+    # which is risky and usually avoided in simple migrations.
+    pass
diff --git a/alembic/versions/20260224_0020_add_openalex_last_attempt_at.py b/alembic/versions/20260224_0020_add_openalex_last_attempt_at.py
new file mode 100644
index 0000000..024f547
--- /dev/null
+++ b/alembic/versions/20260224_0020_add_openalex_last_attempt_at.py
@@ -0,0 +1,26 @@
+"""Add openalex_last_attempt_at to publications
+
+Revision ID: 20260224_0020
+Revises: 20260224_0019
+Create Date: 2026-02-24 22:50:00.000000
+
+"""
+from collections.abc import Sequence
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '20260224_0020'
+down_revision: str | Sequence[str] | None = '20260224_0019'
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.add_column('publications', sa.Column('openalex_last_attempt_at', sa.DateTime(timezone=True), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column('publications', 'openalex_last_attempt_at')
diff --git a/alembic/versions/20260225_0021_enforce_single_active_run_per_user.py b/alembic/versions/20260225_0021_enforce_single_active_run_per_user.py
new file mode 100644
index 0000000..daaa2a6
--- /dev/null
+++ b/alembic/versions/20260225_0021_enforce_single_active_run_per_user.py
@@ -0,0 +1,70 @@
+"""Enforce one active crawl run per user.
+
+Revision ID: 20260225_0021
+Revises: 20260224_0020
+Create Date: 2026-02-25 09:10:00.000000
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "20260225_0021"
+down_revision: str | Sequence[str] | None = "20260224_0020"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+INDEX_NAME = "uq_crawl_runs_user_active"
+ACTIVE_STATUSES = ("running", "resolving")
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    indexes = {index["name"] for index in inspector.get_indexes("crawl_runs")}
+
+    op.execute("ALTER TYPE run_status ADD VALUE IF NOT EXISTS 'canceled'")
+
+    op.execute(
+        """
+        WITH ranked AS (
+            SELECT
+                id,
+                ROW_NUMBER() OVER (
+                    PARTITION BY user_id
+                    ORDER BY start_dt DESC, id DESC
+                ) AS rn
+            FROM crawl_runs
+            WHERE status IN ('running', 'resolving')
+        )
+        UPDATE crawl_runs AS runs
+        SET
+            status = 'failed',
+            end_dt = COALESCE(runs.end_dt, NOW())
+        FROM ranked
+        WHERE runs.id = ranked.id
+          AND ranked.rn > 1
+        """
+    )
+
+    if INDEX_NAME not in indexes:
+        op.create_index(
+            INDEX_NAME,
+            "crawl_runs",
+            ["user_id"],
+            unique=True,
+            postgresql_where=sa.text(
+                "status IN ('running'::run_status, 'resolving'::run_status)"
+            ),
+        )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    indexes = {index["name"] for index in inspector.get_indexes("crawl_runs")}
+    if INDEX_NAME in indexes:
+        op.drop_index(INDEX_NAME, table_name="crawl_runs")
diff --git a/alembic/versions/20260225_0022_add_canonical_title_hash_to_publications.py b/alembic/versions/20260225_0022_add_canonical_title_hash_to_publications.py
new file mode 100644
index 0000000..f73d280
--- /dev/null
+++ b/alembic/versions/20260225_0022_add_canonical_title_hash_to_publications.py
@@ -0,0 +1,35 @@
+"""Add canonical_title_hash to publications for cross-scholar dedup.
+
+Revision ID: 20260225_0022
+Revises: 20260225_0021
+Create Date: 2026-02-25 10:00:00.000000
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "20260225_0022"
+down_revision: str | Sequence[str] | None = "20260225_0021"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "publications",
+        sa.Column("canonical_title_hash", sa.String(64), nullable=True),
+    )
+    op.create_index(
+        "ix_publications_canonical_title_hash",
+        "publications",
+        ["canonical_title_hash"],
+    )
+
+
+def downgrade() -> None:
+    op.drop_index("ix_publications_canonical_title_hash", table_name="publications")
+    op.drop_column("publications", "canonical_title_hash")
diff --git a/alembic/versions/44f7e10ef777_remove_doi_from_publications_and_.py b/alembic/versions/44f7e10ef777_remove_doi_from_publications_and_.py
new file mode 100644
index 0000000..f47adbd
--- /dev/null
+++ b/alembic/versions/44f7e10ef777_remove_doi_from_publications_and_.py
@@ -0,0 +1,27 @@
+"""remove_doi_from_publications_and_migrate_identifiers
+
+Revision ID: 44f7e10ef777
+Revises: 20260222_0016
+Create Date: 2026-02-22 17:03:56.261936
+
+"""
+from collections.abc import Sequence
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '44f7e10ef777'
+down_revision: str | Sequence[str] | None = '20260222_0016'
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    pass
+
+
+def downgrade() -> None:
+    pass
+
diff --git a/alembic/versions/fa0c5e3262d5_add_api_integration_keys_to_usersetting.py b/alembic/versions/fa0c5e3262d5_add_api_integration_keys_to_usersetting.py
new file mode 100644
index 0000000..627a18a
--- /dev/null
+++ b/alembic/versions/fa0c5e3262d5_add_api_integration_keys_to_usersetting.py
@@ -0,0 +1,39 @@
+"""Add API integration keys to UserSetting
+
+Revision ID: fa0c5e3262d5
+Revises: 44f7e10ef777
+Create Date: 2026-02-23 14:25:45.021512
+
+"""
+from collections.abc import Sequence
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'fa0c5e3262d5'
+down_revision: str | Sequence[str] | None = '44f7e10ef777'
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_publications_doi'), table_name='publications')
+    op.drop_column('publications', 'doi')
+    op.add_column('user_settings', sa.Column('openalex_api_key', sa.String(length=255), nullable=True))
+    op.add_column('user_settings', sa.Column('crossref_api_token', sa.String(length=255), nullable=True))
+    op.add_column('user_settings', sa.Column('crossref_api_mailto', sa.String(length=255), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('user_settings', 'crossref_api_mailto')
+    op.drop_column('user_settings', 'crossref_api_token')
+    op.drop_column('user_settings', 'openalex_api_key')
+    op.add_column('publications', sa.Column('doi', sa.VARCHAR(length=255), autoincrement=False, nullable=True))
+    op.create_index(op.f('ix_publications_doi'), 'publications', ['doi'], unique=False)
+    # ### end Alembic commands ###
+
diff --git a/app/api/routers/admin_dbops.py b/app/api/routers/admin_dbops.py
index cd6d924..b3c1fdf 100644
--- a/app/api/routers/admin_dbops.py
+++ b/app/api/routers/admin_dbops.py
@@ -57,7 +57,6 @@ def _serialize_pdf_queue_item(item) -> dict[str, object]:
     return {
         "publication_id": item.publication_id,
         "title": item.title,
-        "doi": item.doi,
         "display_identifier": _serialize_display_identifier(item.display_identifier),
         "pdf_url": item.pdf_url,
         "status": item.status,
@@ -348,3 +347,64 @@ async def trigger_publication_link_repair(
         },
     )
     return success_payload(request, data=result)
+
+
+DROP_PUBLICATIONS_CONFIRMATION = "DROP ALL PUBLICATIONS"
+
+
+@router.post("/drop-all-publications")
+async def drop_all_publications(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    body = await request.json()
+    confirmation_text = (body.get("confirmation_text") or "").strip()
+    if confirmation_text != DROP_PUBLICATIONS_CONFIRMATION:
+        raise ApiException(
+            status_code=400,
+            code="confirmation_required",
+            message=f"Type '{DROP_PUBLICATIONS_CONFIRMATION}' to confirm this destructive action.",
+        )
+
+    from sqlalchemy import delete, func, select, update
+
+    from app.db.models import (
+        Publication,
+        PublicationIdentifier,
+        PublicationPdfJob,
+        PublicationPdfJobEvent,
+        ScholarProfile,
+        ScholarPublication,
+    )
+
+    count_result = await db_session.execute(select(func.count()).select_from(Publication))
+    total_publications = count_result.scalar_one()
+
+    await db_session.execute(delete(ScholarPublication))
+    await db_session.execute(delete(PublicationIdentifier))
+    await db_session.execute(delete(PublicationPdfJobEvent))
+    await db_session.execute(delete(PublicationPdfJob))
+    await db_session.execute(delete(Publication))
+    await db_session.execute(
+        update(ScholarProfile).values(baseline_completed=False)
+    )
+    await db_session.commit()
+
+    logger.warning(
+        "api.admin.db.all_publications_dropped",
+        extra={
+            "event": "api.admin.db.all_publications_dropped",
+            "admin_user_id": int(admin_user.id),
+            "admin_email": admin_user.email,
+            "deleted_count": int(total_publications),
+        },
+    )
+    return success_payload(
+        request,
+        data={
+            "deleted_count": int(total_publications),
+            "message": f"Dropped {total_publications} publication(s) and all related data. "
+            "Scholar baselines have been reset; the next run will re-discover all publications.",
+        },
+    )
diff --git a/app/api/routers/publications.py b/app/api/routers/publications.py
index ad8fc55..b4a616e 100644
--- a/app/api/routers/publications.py
+++ b/app/api/routers/publications.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import datetime, timezone
 import logging
 from typing import Literal
 
@@ -62,7 +63,6 @@ def _serialize_publication_item(item) -> dict[str, object]:
         "citation_count": item.citation_count,
         "venue_text": item.venue_text,
         "pub_url": item.pub_url,
-        "doi": item.doi,
         "display_identifier": _serialize_display_identifier(item.display_identifier),
         "pdf_url": item.pdf_url,
         "pdf_status": item.pdf_status,
@@ -94,23 +94,27 @@ async def _publication_counts(
     user_id: int,
     selected_scholar_id: int | None,
     favorite_only: bool,
+    snapshot_before: datetime | None,
 ) -> tuple[int, int, int, int]:
     unread_count = await publication_service.count_unread_for_user(
         db_session,
         user_id=user_id,
         scholar_profile_id=selected_scholar_id,
         favorite_only=favorite_only,
+        snapshot_before=snapshot_before,
     )
     favorites_count = await publication_service.count_favorite_for_user(
         db_session,
         user_id=user_id,
         scholar_profile_id=selected_scholar_id,
+        snapshot_before=snapshot_before,
     )
     latest_count = await publication_service.count_latest_for_user(
         db_session,
         user_id=user_id,
         scholar_profile_id=selected_scholar_id,
         favorite_only=favorite_only,
+        snapshot_before=snapshot_before,
     )
     total_count = await publication_service.count_for_user(
         db_session,
@@ -118,6 +122,7 @@ async def _publication_counts(
         mode=publication_service.MODE_ALL,
         scholar_profile_id=selected_scholar_id,
         favorite_only=favorite_only,
+        snapshot_before=snapshot_before,
     )
     return unread_count, favorites_count, latest_count, total_count
 
@@ -129,8 +134,12 @@ async def _list_publications_for_request(
     mode: Literal["all", "unread", "latest", "new"] | None,
     favorite_only: bool,
     scholar_profile_id: int | None,
+    search: str | None,
+    sort_by: str,
+    sort_dir: str,
     limit: int,
     offset: int,
+    snapshot_before: datetime | None,
 ) -> tuple[str, int | None, list]:
     resolved_mode = publication_service.resolve_publication_view_mode(mode)
     selected_scholar_id = scholar_profile_id
@@ -145,8 +154,12 @@ async def _list_publications_for_request(
         mode=resolved_mode,
         scholar_profile_id=selected_scholar_id,
         favorite_only=favorite_only,
+        search=search,
+        sort_by=sort_by,
+        sort_dir=sort_dir,
         limit=limit,
         offset=offset,
+        snapshot_before=snapshot_before,
     )
     await publication_service.schedule_missing_pdf_enrichment_for_user(
         db_session,
@@ -162,6 +175,27 @@ async def _list_publications_for_request(
     return resolved_mode, selected_scholar_id, hydrated
 
 
+def _resolve_publications_snapshot(
+    *,
+    snapshot: str | None,
+) -> tuple[datetime, str]:
+    if snapshot is None:
+        now_utc = datetime.now(timezone.utc)
+        return now_utc, now_utc.isoformat()
+    try:
+        parsed = datetime.fromisoformat(snapshot)
+    except ValueError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_snapshot",
+            message="Invalid publications snapshot cursor.",
+        ) from exc
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    normalized = parsed.astimezone(timezone.utc)
+    return normalized, normalized.isoformat()
+
+
 def _resolve_publications_paging(
     *,
     page: int,
@@ -188,6 +222,7 @@ def _publications_list_data(
     page: int,
     page_size: int,
     offset: int,
+    snapshot: str,
 ) -> dict[str, object]:
     return {
         "mode": mode,
@@ -200,6 +235,7 @@ def _publications_list_data(
         "total_count": total_count,
         "page": int(page),
         "page_size": int(page_size),
+        "snapshot": snapshot,
         "has_prev": int(offset) > 0,
         "has_next": int(offset) + int(page_size) < int(total_count),
         "publications": [_serialize_publication_item(item) for item in publications],
@@ -322,7 +358,6 @@ def _log_retry_pdf_result(
             "queued": queued,
             "resolved_pdf": resolved_pdf,
             "pdf_status": pdf_status,
-            "has_doi": bool(doi),
         },
     )
 
@@ -336,10 +371,14 @@ async def list_publications(
     mode: Literal["all", "unread", "latest", "new"] | None = Query(default=None),
     favorite_only: bool = Query(default=False),
     scholar_profile_id: int | None = Query(default=None, ge=1),
+    search: str | None = Query(default=None, min_length=1, max_length=200),
+    sort_by: Literal["first_seen", "title", "year", "citations", "scholar"] = Query(default="first_seen"),
+    sort_dir: Literal["asc", "desc"] = Query(default="desc"),
     page: int = Query(default=1, ge=1),
     page_size: int = Query(default=100, ge=1, le=500),
     limit: int | None = Query(default=None, ge=1, le=1000),
     offset: int | None = Query(default=None, ge=0),
+    snapshot: str | None = Query(default=None, min_length=1, max_length=64),
     db_session: AsyncSession = Depends(get_db_session),
     current_user: User = Depends(get_api_current_user),
 ):
@@ -349,20 +388,27 @@ async def list_publications(
         limit=limit,
         offset=offset,
     )
+    snapshot_before, snapshot_cursor = _resolve_publications_snapshot(snapshot=snapshot)
+    normalized_search = (search or "").strip() or None
     resolved_mode, selected_scholar_id, publications = await _list_publications_for_request(
         db_session,
         current_user=current_user,
         mode=mode,
         favorite_only=favorite_only,
         scholar_profile_id=scholar_profile_id,
+        search=normalized_search,
+        sort_by=sort_by,
+        sort_dir=sort_dir,
         limit=resolved_limit,
         offset=resolved_offset,
+        snapshot_before=snapshot_before,
     )
     unread_count, favorites_count, latest_count, total_count = await _publication_counts(
         db_session,
         user_id=current_user.id,
         selected_scholar_id=selected_scholar_id,
         favorite_only=favorite_only,
+        snapshot_before=snapshot_before,
     )
     data = _publications_list_data(
         mode=resolved_mode,
@@ -376,6 +422,7 @@ async def list_publications(
         page=resolved_page,
         page_size=resolved_limit,
         offset=resolved_offset,
+        snapshot=snapshot_cursor,
     )
     return success_payload(request, data=data)
 
@@ -480,7 +527,7 @@ async def retry_publication_pdf(
         queued=queued,
         resolved_pdf=resolved_pdf,
         pdf_status=current.pdf_status,
-        doi=current.doi,
+        doi=None,
     )
     return success_payload(
         request,
diff --git a/app/api/routers/runs.py b/app/api/routers/runs.py
index ddd5290..b03a45d 100644
--- a/app/api/routers/runs.py
+++ b/app/api/routers/runs.py
@@ -11,6 +11,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from app.api.deps import get_api_current_user
 from app.api.errors import ApiException
 from app.api.responses import success_payload
+from fastapi.responses import StreamingResponse
 from app.api.schemas import (
     ManualRunEnvelope,
     QueueClearEnvelope,
@@ -24,6 +25,7 @@ from app.db.session import get_db_session
 from app.services.domains.ingestion import application as ingestion_service
 from app.services.domains.ingestion import safety as run_safety_service
 from app.services.domains.runs import application as run_service
+from app.services.domains.runs.events import event_generator
 from app.services.domains.settings import application as user_settings_service
 from app.settings import settings
 from app.api.runtime_deps import get_ingestion_service
@@ -31,6 +33,7 @@ from app.api.runtime_deps import get_ingestion_service
 logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/runs", tags=["api-runs"])
+ACTIVE_RUN_STATUSES = {RunStatus.RUNNING, RunStatus.RESOLVING}
 
 IDEMPOTENCY_HEADER = "Idempotency-Key"
 IDEMPOTENCY_MAX_LENGTH = 128
@@ -338,7 +341,7 @@ async def _reused_manual_run_payload(
     )
     if previous_run is None:
         return None
-    if previous_run.status == RunStatus.RUNNING:
+    if previous_run.status in (RunStatus.RUNNING, RunStatus.RESOLVING):
         raise ApiException(
             status_code=409,
             code="run_in_progress",
@@ -410,7 +413,7 @@ async def _recover_integrity_error(
             extra={"event": "api.runs.manual_integrity_error", "user_id": user_id},
         )
         raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
-    if existing_run.status == RunStatus.RUNNING:
+    if existing_run.status in (RunStatus.RUNNING, RunStatus.RESOLVING):
         raise ApiException(
             status_code=409,
             code="run_in_progress",
@@ -586,6 +589,61 @@ async def get_run(
     )
 
 
+@router.post(
+    "/{run_id}/cancel",
+    response_model=RunDetailEnvelope,
+)
+async def cancel_run(
+    run_id: int,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    run = await run_service.get_run_for_user(
+        db_session,
+        user_id=current_user.id,
+        run_id=run_id,
+    )
+    if run is None:
+        raise ApiException(
+            status_code=404,
+            code="run_not_found",
+            message="Run not found.",
+        )
+
+    if run.status in ACTIVE_RUN_STATUSES:
+        run.status = RunStatus.CANCELED
+        await db_session.commit()
+        await db_session.refresh(run)
+    else:
+        raise ApiException(
+            status_code=409,
+            code="run_not_cancelable",
+            message="Run is already terminal and cannot be canceled.",
+            details={"run_id": int(run.id), "status": run.status.value},
+        )
+
+    error_log = run.error_log if isinstance(run.error_log, dict) else {}
+    scholar_results = error_log.get("scholar_results")
+    if not isinstance(scholar_results, list):
+        scholar_results = []
+        
+    safety_state = await _load_safety_state(
+        db_session,
+        user_id=current_user.id,
+    )
+    
+    return success_payload(
+        request,
+        data={
+            "run": _serialize_run(run),
+            "summary": run_service.extract_run_summary(error_log),
+            "scholar_results": [_normalize_scholar_result(item) for item in scholar_results],
+            "safety_state": safety_state,
+        },
+    )
+
+
 @router.post(
     "/manual",
     response_model=ManualRunEnvelope,
@@ -596,10 +654,7 @@ async def run_manual(
     current_user: User = Depends(get_api_current_user),
     ingest_service: ingestion_service.ScholarIngestionService = Depends(get_ingestion_service),
 ):
-    safety_state = await _load_safety_state(
-        db_session,
-        user_id=current_user.id,
-    )
+    safety_state = await _load_safety_state(db_session, user_id=current_user.id)
     if not settings.ingestion_manual_run_allowed:
         _raise_manual_runs_disabled(user_id=current_user.id, safety_state=safety_state)
 
@@ -614,28 +669,90 @@ async def run_manual(
     if reused_payload is not None:
         return reused_payload
 
-    run_summary = await _execute_manual_run(
-        db_session,
-        request=request,
-        ingest_service=ingest_service,
-        user_id=current_user.id,
-        idempotency_key=idempotency_key,
-    )
-    if isinstance(run_summary, dict):
-        return run_summary
-
-    current_safety_state = await _load_safety_state(
-        db_session,
-        user_id=current_user.id,
-    )
-    return success_payload(
-        request,
-        data=_manual_run_success_payload(
-            run_summary=run_summary,
+    try:
+        user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=current_user.id)
+        
+        # Initialize run (creates the record and performs safety checks)
+        run, scholars, start_cstart_map = await ingest_service.initialize_run(
+            db_session,
+            user_id=current_user.id,
+            trigger_type=RunTriggerType.MANUAL,
+            request_delay_seconds=user_settings.request_delay_seconds,
+            network_error_retries=settings.ingestion_network_error_retries,
+            retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
+            max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
+            page_size=settings.ingestion_page_size,
             idempotency_key=idempotency_key,
-            safety_state=current_safety_state,
-        ),
-    )
+            alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
+            alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
+            alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
+        )
+        
+        await db_session.commit()
+        
+        # Kick off background execution
+        from app.db.session import get_session_factory
+        import asyncio
+        
+        asyncio.create_task(
+            ingest_service.execute_run(
+                session_factory=get_session_factory(),
+                run_id=run.id,
+                user_id=current_user.id,
+                scholars=scholars,
+                start_cstart_map=start_cstart_map,
+                request_delay_seconds=user_settings.request_delay_seconds,
+                network_error_retries=settings.ingestion_network_error_retries,
+                retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
+                max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
+                page_size=settings.ingestion_page_size,
+                auto_queue_continuations=settings.ingestion_continuation_queue_enabled,
+                queue_delay_seconds=settings.ingestion_continuation_base_delay_seconds,
+                alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
+                alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
+                alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
+                idempotency_key=idempotency_key,
+            )
+        )
+        
+        return success_payload(
+            request,
+            data={
+                "run_id": int(run.id),
+                "status": run.status.value,
+                "scholar_count": int(run.scholar_count or 0),
+                "succeeded_count": 0,
+                "failed_count": 0,
+                "partial_count": 0,
+                "new_publication_count": 0,
+                "reused_existing_run": False,
+                "idempotency_key": idempotency_key,
+                "safety_state": await _load_safety_state(db_session, user_id=current_user.id),
+            }
+        )
+    except ingestion_service.RunBlockedBySafetyPolicyError as exc:
+        await db_session.rollback()
+        _raise_manual_blocked_safety(exc=exc, user_id=current_user.id)
+    except ingestion_service.RunAlreadyInProgressError as exc:
+        await db_session.rollback()
+        raise ApiException(
+            status_code=409,
+            code="run_in_progress",
+            message="A run is already in progress for this account.",
+        ) from exc
+    except IntegrityError as exc:
+        await db_session.rollback()
+        return await _recover_integrity_error(
+            db_session,
+            request=request,
+            user_id=current_user.id,
+            idempotency_key=idempotency_key,
+            original_exc=exc,
+        )
+    except Exception as exc:
+        await db_session.rollback()
+        _raise_manual_failed(exc=exc, user_id=current_user.id)
+
 
 
 @router.get(
@@ -769,3 +886,26 @@ async def clear_queue_item(
             "message": "Queue item cleared.",
         },
     )
+
+
+@router.get("/{run_id}/stream")
+async def stream_run_events(
+    run_id: int,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    run = await run_service.get_run_for_user(
+        db_session,
+        user_id=current_user.id,
+        run_id=run_id,
+    )
+    if run is None:
+        raise ApiException(
+            status_code=404,
+            code="run_not_found",
+            message="Run not found.",
+        )
+    return StreamingResponse(
+        event_generator(run_id),
+        media_type="text/event-stream"
+    )
diff --git a/app/api/routers/settings.py b/app/api/routers/settings.py
index f5e9cac..5a2ef91 100644
--- a/app/api/routers/settings.py
+++ b/app/api/routers/settings.py
@@ -38,6 +38,9 @@ def _serialize_settings(user_settings) -> dict[str, object]:
             "cooldown_network_seconds": max(60, int(settings_module.ingestion_safety_cooldown_network_seconds)),
         },
         "safety_state": run_safety_service.get_safety_state_payload(user_settings),
+        "openalex_api_key": user_settings.openalex_api_key,
+        "crossref_api_token": user_settings.crossref_api_token,
+        "crossref_api_mailto": user_settings.crossref_api_mailto,
     }
 
 
@@ -107,6 +110,7 @@ def _log_settings_update(*, user_id: int, updated) -> None:
             "run_interval_minutes": updated.run_interval_minutes,
             "request_delay_seconds": updated.request_delay_seconds,
             "nav_visible_pages": updated.nav_visible_pages,
+            "openalex_api_key": "SET" if updated.openalex_api_key else "UNSET",
         },
     )
 
@@ -169,6 +173,9 @@ async def update_settings(
         run_interval_minutes=parsed_interval,
         request_delay_seconds=parsed_delay,
         nav_visible_pages=parsed_nav_visible_pages,
+        openalex_api_key=payload.openalex_api_key,
+        crossref_api_token=payload.crossref_api_token,
+        crossref_api_mailto=payload.crossref_api_mailto,
     )
     await _clear_expired_cooldown_with_log(
         db_session,
diff --git a/app/api/schemas.py b/app/api/schemas.py
index 112f672..07ccedf 100644
--- a/app/api/schemas.py
+++ b/app/api/schemas.py
@@ -205,7 +205,6 @@ class PublicationExportItemData(BaseModel):
     author_text: str | None = None
     venue_text: str | None = None
     pub_url: str | None = None
-    doi: str | None = None
     pdf_url: str | None = None
     is_read: bool = False
 
@@ -594,7 +593,6 @@ class DisplayIdentifierData(BaseModel):
 class AdminPdfQueueItemData(BaseModel):
     publication_id: int
     title: str
-    doi: str | None
     display_identifier: DisplayIdentifierData | None = None
     pdf_url: str | None
     status: str
@@ -725,6 +723,10 @@ class SettingsData(BaseModel):
     nav_visible_pages: list[str]
     policy: SettingsPolicyData
     safety_state: ScrapeSafetyStateData
+    
+    openalex_api_key: str | None = None
+    crossref_api_token: str | None = None
+    crossref_api_mailto: str | None = None
 
     model_config = ConfigDict(extra="forbid")
 
@@ -742,6 +744,10 @@ class SettingsUpdateRequest(BaseModel):
     request_delay_seconds: int
     nav_visible_pages: list[str] | None = None
 
+    openalex_api_key: str | None = None
+    crossref_api_token: str | None = None
+    crossref_api_mailto: str | None = None
+
     model_config = ConfigDict(extra="forbid")
 
 
@@ -754,7 +760,6 @@ class PublicationItemData(BaseModel):
     citation_count: int
     venue_text: str | None
     pub_url: str | None
-    doi: str | None
     display_identifier: DisplayIdentifierData | None = None
     pdf_url: str | None
     pdf_status: str = "untracked"
@@ -780,6 +785,7 @@ class PublicationsListData(BaseModel):
     total_count: int
     page: int
     page_size: int
+    snapshot: str
     has_next: bool = False
     has_prev: bool = False
     publications: list[PublicationItemData]
diff --git a/app/db/models.py b/app/db/models.py
index 1f0b250..c687547 100644
--- a/app/db/models.py
+++ b/app/db/models.py
@@ -31,9 +31,11 @@ class RunTriggerType(StrEnum):
 
 class RunStatus(StrEnum):
     RUNNING = "running"
+    RESOLVING = "resolving"
     SUCCESS = "success"
     PARTIAL_FAILURE = "partial_failure"
     FAILED = "failed"
+    CANCELED = "canceled"
 
 
 class QueueItemStatus(StrEnum):
@@ -113,6 +115,11 @@ class UserSetting(Base):
     )
     scrape_cooldown_until: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
     scrape_cooldown_reason: Mapped[str | None] = mapped_column(String(64))
+    
+    openalex_api_key: Mapped[str | None] = mapped_column(String(255))
+    crossref_api_token: Mapped[str | None] = mapped_column(String(255))
+    crossref_api_mailto: Mapped[str | None] = mapped_column(String(255))
+
     created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True), nullable=False, server_default=func.now()
     )
@@ -161,6 +168,14 @@ class CrawlRun(Base):
     __tablename__ = "crawl_runs"
     __table_args__ = (
         Index("ix_crawl_runs_user_start", "user_id", "start_dt"),
+        Index(
+            "uq_crawl_runs_user_active",
+            "user_id",
+            unique=True,
+            postgresql_where=text(
+                "status IN ('running'::run_status, 'resolving'::run_status)"
+            ),
+        ),
         Index(
             "uq_crawl_runs_user_manual_idempotency_key",
             "user_id",
@@ -228,8 +243,16 @@ class Publication(Base):
     author_text: Mapped[str | None] = mapped_column(Text)
     venue_text: Mapped[str | None] = mapped_column(Text)
     pub_url: Mapped[str | None] = mapped_column(Text)
-    doi: Mapped[str | None] = mapped_column(String(255))
     pdf_url: Mapped[str | None] = mapped_column(Text)
+    canonical_title_hash: Mapped[str | None] = mapped_column(
+        String(64), nullable=True, index=True
+    )
+    openalex_enriched: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, server_default=text("false")
+    )
+    openalex_last_attempt_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True
+    )
     created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True), nullable=False, server_default=func.now()
     )
diff --git a/app/main.py b/app/main.py
index 254eb4a..56ddf58 100644
--- a/app/main.py
+++ b/app/main.py
@@ -66,6 +66,18 @@ def _log_startup_build_marker() -> None:
 @asynccontextmanager
 async def lifespan(_: FastAPI):
     _log_startup_build_marker()
+    
+    from app.db.session import get_session_factory
+    from sqlalchemy import text
+    try:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            await session.execute(text("UPDATE crawl_runs SET status = 'failed' WHERE status::text IN ('running', 'resolving')"))
+            await session.commit()
+            logger.info("app.startup_orphaned_runs_cleaned", extra={"event": "app.startup_orphaned_runs_cleaned"})
+    except Exception as e:
+        logger.error(f"Failed to clean orphaned runs at startup: {e}")
+
     await scheduler_service.start()
     yield
     await scheduler_service.stop()
diff --git a/app/services/domains/arxiv/application.py b/app/services/domains/arxiv/application.py
new file mode 100644
index 0000000..57b1473
--- /dev/null
+++ b/app/services/domains/arxiv/application.py
@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+import xml.etree.ElementTree as ET
+
+import httpx
+
+from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
+from app.settings import settings
+
+if TYPE_CHECKING:
+    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+
+logger = logging.getLogger(__name__)
+
+# arXiv API terms: max 1 request per 3 seconds, single connection at a time.
+_ARXIV_LOCK = asyncio.Lock()
+_ARXIV_MIN_INTERVAL_SECONDS = 4.0
+# Global cooldown: when arXiv returns 429, all batches back off for this long.
+_ARXIV_RATE_LIMIT_COOLDOWN_SECONDS = 60.0
+_arxiv_rate_limited_until: float = 0.0  # asyncio monotonic time
+
+
+class ArxivRateLimitError(Exception):
+    """arXiv returned 429 — stop the batch to avoid hammering."""
+    pass
+
+
+def _build_arxiv_query(title: str, author_surname: str | None) -> str | None:
+    parts = []
+    if title:
+        clean_title = title.replace('"', '').replace("'", "")
+        parts.append(f'ti:"{clean_title}"')
+    if author_surname:
+        parts.append(f'au:"{author_surname}"')
+    if not parts:
+        return None
+    return " AND ".join(parts)
+
+
+async def discover_arxiv_id_for_publication(
+    *,
+    item: PublicationListItem | UnreadPublicationItem,
+    request_email: str | None = None,
+    timeout_seconds: float = 3.0,
+) -> str | None:
+    title = (item.title or "").strip()
+    if not title:
+        return None
+
+    author_surname = None
+    if item.scholar_label:
+        tokens = [t for t in item.scholar_label.strip().split() if t]
+        if tokens:
+            author_surname = tokens[-1].lower()
+
+    query = _build_arxiv_query(title, author_surname)
+    if not query:
+        return None
+
+    url = "https://export.arxiv.org/api/query"
+    params = {"search_query": query, "start": 0, "max_results": 3}
+    headers = {
+        "User-Agent": (
+            f"scholar-scraper/1.0 "
+            f"(mailto:{request_email or settings.crossref_api_mailto or 'unknown@example.com'})"
+        )
+    }
+
+    try:
+        async with _ARXIV_LOCK:
+            global _arxiv_rate_limited_until
+            now = asyncio.get_running_loop().time()
+            if now < _arxiv_rate_limited_until:
+                remaining = _arxiv_rate_limited_until - now
+                raise ArxivRateLimitError(f"arXiv global cooldown active ({remaining:.0f}s remaining)")
+
+            async with httpx.AsyncClient(timeout=timeout_seconds, follow_redirects=True, headers=headers) as client:
+                response = await client.get(url, params=params)
+
+            if response.status_code == 429:
+                _arxiv_rate_limited_until = asyncio.get_running_loop().time() + _ARXIV_RATE_LIMIT_COOLDOWN_SECONDS
+                raise ArxivRateLimitError("arXiv rate limit hit (429) — stopping batch")
+
+            await asyncio.sleep(_ARXIV_MIN_INTERVAL_SECONDS)
+
+        response.raise_for_status()
+
+        root = ET.fromstring(response.text)
+        namespace = {"atom": "http://www.w3.org/2005/Atom"}
+
+        for entry in root.findall("atom:entry", namespace):
+            id_elem = entry.find("atom:id", namespace)
+            if id_elem is not None and id_elem.text:
+                candidate = str(id_elem.text)
+                if "/abs/" in candidate:
+                    candidate = candidate.split("/abs/")[-1]
+                normalized = normalize_arxiv_id(candidate)
+                if normalized:
+                    logger.debug("arxiv.id_discovered", extra={"event": "arxiv.id_discovered", "arxiv_id": normalized})
+                    return normalized
+
+    except ArxivRateLimitError:
+        raise  # propagate so the batch loop can stop
+    except Exception as exc:
+        logger.debug(f"Failed to query arXiv API: {exc}")
+
+    return None
diff --git a/app/services/domains/ingestion/application.py b/app/services/domains/ingestion/application.py
index 4cb493d..a313a6f 100644
--- a/app/services/domains/ingestion/application.py
+++ b/app/services/domains/ingestion/application.py
@@ -1,12 +1,14 @@
 from __future__ import annotations
 
 import asyncio
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 import hashlib
 import logging
+import re
 from typing import Any
 
-from sqlalchemy import select, text
+from sqlalchemy import or_, select, text
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import (
@@ -37,6 +39,7 @@ from app.services.domains.ingestion.fingerprints import (
     build_initial_page_fingerprint,
     build_publication_fingerprint,
     build_publication_url,
+    canonical_title_for_dedup,
     normalize_title,
 )
 from app.services.domains.ingestion import queue as queue_service
@@ -53,6 +56,7 @@ from app.services.domains.ingestion.types import (
     ScholarProcessingOutcome,
 )
 from app.services.domains.settings import application as user_settings_service
+from app.services.domains.runs.events import run_events
 from app.services.domains.scholar.parser import (
     ParseState,
     ParsedProfilePage,
@@ -64,6 +68,21 @@ from app.services.domains.scholar.source import FetchResult, ScholarSource
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
+ACTIVE_RUN_INDEX_NAME = "uq_crawl_runs_user_active"
+
+
+def _is_active_run_integrity_error(exc: IntegrityError) -> bool:
+    original_error = getattr(exc, "orig", None)
+    if ACTIVE_RUN_INDEX_NAME in str(exc):
+        return True
+    if original_error is None:
+        return False
+    if ACTIVE_RUN_INDEX_NAME in str(original_error):
+        return True
+    diagnostics = getattr(original_error, "diag", None)
+    if diagnostics is None:
+        return False
+    return getattr(diagnostics, "constraint_name", None) == ACTIVE_RUN_INDEX_NAME
 
 
 def _int_or_default(value: Any, default: int = 0) -> int:
@@ -357,8 +376,6 @@ class ScholarIngestionService:
             scholar.display_name = first_page.profile_name
         if first_page.profile_image_url:
             scholar.profile_image_url = first_page.profile_image_url
-        if paged_parse_result.first_page_fingerprint_sha256:
-            scholar.last_initial_page_fingerprint_sha256 = paged_parse_result.first_page_fingerprint_sha256
         scholar.last_initial_page_checked_at = run_dt
 
     @staticmethod
@@ -522,12 +539,9 @@ class ScholarIngestionService:
         result_entry: dict[str, Any],
         has_partial_publication_set: bool,
     ) -> ScholarProcessingOutcome:
-        discovered_count = await self._upsert_profile_publications(
-            db_session,
-            run=run,
-            scholar=scholar,
-            publications=paged_parse_result.publications,
-        )
+        # We no longer aggregate and upsert the publications here.
+        # Eager DB insertions have already saved and committed them inside `_fetch_and_parse_all_pages_with_retry` and `_paginate_loop`.
+        discovered_count = paged_parse_result.discovered_publication_count
         is_partial = (
             paged_parse_result.has_more_remaining
             or paged_parse_result.pagination_truncated_reason is not None
@@ -535,6 +549,8 @@ class ScholarIngestionService:
         )
         scholar.last_run_status = RunStatus.PARTIAL_FAILURE if is_partial else RunStatus.SUCCESS
         scholar.last_run_dt = run_dt
+        if not is_partial and paged_parse_result.first_page_fingerprint_sha256:
+            scholar.last_initial_page_fingerprint_sha256 = paged_parse_result.first_page_fingerprint_sha256
         result_entry["outcome"] = "partial" if is_partial else "success"
         if is_partial:
             result_entry["debug"] = self._build_failure_debug_context(
@@ -661,6 +677,8 @@ class ScholarIngestionService:
         request_delay_seconds: int,
         network_error_retries: int,
         retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
         max_pages_per_scholar: int,
         page_size: int,
         start_cstart: int,
@@ -676,6 +694,8 @@ class ScholarIngestionService:
                 request_delay_seconds=request_delay_seconds,
                 network_error_retries=network_error_retries,
                 retry_backoff_seconds=retry_backoff_seconds,
+                rate_limit_retries=rate_limit_retries,
+                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
                 max_pages_per_scholar=max_pages_per_scholar,
                 page_size=page_size,
                 start_cstart=start_cstart,
@@ -700,6 +720,8 @@ class ScholarIngestionService:
         request_delay_seconds: int,
         network_error_retries: int,
         retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
         max_pages_per_scholar: int,
         page_size: int,
         start_cstart: int,
@@ -707,6 +729,7 @@ class ScholarIngestionService:
         queue_delay_seconds: int,
     ) -> ScholarProcessingOutcome:
         run_dt, paged_parse_result, result_entry = await self._fetch_and_prepare_scholar_result(
+            db_session,
             run=run,
             scholar=scholar,
             user_id=user_id,
@@ -714,6 +737,8 @@ class ScholarIngestionService:
             request_delay_seconds=request_delay_seconds,
             network_error_retries=network_error_retries,
             retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
             max_pages_per_scholar=max_pages_per_scholar,
             page_size=page_size,
         )
@@ -740,6 +765,7 @@ class ScholarIngestionService:
 
     async def _fetch_and_prepare_scholar_result(
         self,
+        db_session: AsyncSession,
         *,
         run: CrawlRun,
         scholar: ScholarProfile,
@@ -748,16 +774,22 @@ class ScholarIngestionService:
         request_delay_seconds: int,
         network_error_retries: int,
         retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
         max_pages_per_scholar: int,
         page_size: int,
     ) -> tuple[datetime, PagedParseResult, dict[str, Any]]:
         run_dt = datetime.now(timezone.utc)
         paged_parse_result = await self._fetch_and_parse_all_pages_with_retry(
-            scholar_id=scholar.scholar_id,
+            scholar=scholar,
+            run=run,
+            db_session=db_session,
             start_cstart=start_cstart,
             request_delay_seconds=request_delay_seconds,
             network_error_retries=network_error_retries,
             retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
             max_pages=max_pages_per_scholar,
             page_size=page_size,
             previous_initial_page_fingerprint_sha256=scholar.last_initial_page_fingerprint_sha256,
@@ -808,7 +840,6 @@ class ScholarIngestionService:
         progress.succeeded_count += outcome.succeeded_count_delta
         progress.failed_count += outcome.failed_count_delta
         progress.partial_count += outcome.partial_count_delta
-        run.new_pub_count = int(run.new_pub_count or 0) + outcome.discovered_publication_count
         progress.scholar_results.append(outcome.result_entry)
 
     def _unexpected_scholar_exception_outcome(
@@ -1049,12 +1080,13 @@ class ScholarIngestionService:
         idempotency_key: str | None,
     ) -> None:
         run.end_dt = datetime.now(timezone.utc)
-        run.status = self._resolve_run_status(
-            scholar_count=len(scholars),
-            succeeded_count=progress.succeeded_count,
-            failed_count=progress.failed_count,
-            partial_count=progress.partial_count,
-        )
+        if run.status != RunStatus.CANCELED:
+            run.status = self._resolve_run_status(
+                scholar_count=len(scholars),
+                succeeded_count=progress.succeeded_count,
+                failed_count=progress.failed_count,
+                partial_count=progress.partial_count,
+            )
         run.error_log = {
             "scholar_results": progress.scholar_results,
             "summary": {
@@ -1114,6 +1146,8 @@ class ScholarIngestionService:
         request_delay_seconds: int,
         network_error_retries: int,
         retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
         max_pages_per_scholar: int,
         page_size: int,
     ) -> dict[str, Any]:
@@ -1121,6 +1155,8 @@ class ScholarIngestionService:
             "request_delay_seconds": request_delay_seconds,
             "network_error_retries": network_error_retries,
             "retry_backoff_seconds": retry_backoff_seconds,
+            "rate_limit_retries": rate_limit_retries,
+            "rate_limit_backoff_seconds": rate_limit_backoff_seconds,
             "max_pages_per_scholar": max_pages_per_scholar,
             "page_size": page_size,
         }
@@ -1155,7 +1191,7 @@ class ScholarIngestionService:
             new_publication_count=run.new_pub_count,
         )
 
-    async def _initialize_run_for_user(self, db_session: AsyncSession, *, user_id: int, trigger_type: RunTriggerType, scholar_profile_ids: set[int] | None, start_cstart_by_scholar_id: dict[int, int] | None, request_delay_seconds: int, network_error_retries: int, retry_backoff_seconds: float, max_pages_per_scholar: int, page_size: int, idempotency_key: str | None, alert_blocked_failure_threshold: int, alert_network_failure_threshold: int, alert_retry_scheduled_threshold: int) -> tuple[Any, CrawlRun, list[ScholarProfile], dict[int, int]]:
+    async def _initialize_run_for_user(self, db_session: AsyncSession, *, user_id: int, trigger_type: RunTriggerType, scholar_profile_ids: set[int] | None, start_cstart_by_scholar_id: dict[int, int] | None, request_delay_seconds: int, network_error_retries: int, retry_backoff_seconds: float, rate_limit_retries: int, rate_limit_backoff_seconds: float, max_pages_per_scholar: int, page_size: int, idempotency_key: str | None, alert_blocked_failure_threshold: int, alert_network_failure_threshold: int, alert_retry_scheduled_threshold: int) -> tuple[Any, CrawlRun, list[ScholarProfile], dict[int, int]]:
         user_settings = await self._load_user_settings_for_run(
             db_session,
             user_id=user_id,
@@ -1230,7 +1266,15 @@ class ScholarIngestionService:
             idempotency_key=idempotency_key,
         )
         db_session.add(run)
-        await db_session.flush()
+        try:
+            await db_session.flush()
+        except IntegrityError as exc:
+            if _is_active_run_integrity_error(exc):
+                await db_session.rollback()
+                raise RunAlreadyInProgressError(
+                    f"Run already in progress for user_id={user_id}."
+                ) from exc
+            raise
         return run
 
     async def _run_scholar_iteration(
@@ -1244,13 +1288,27 @@ class ScholarIngestionService:
         request_delay_seconds: int,
         network_error_retries: int,
         retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
         max_pages_per_scholar: int,
         page_size: int,
         auto_queue_continuations: bool,
         queue_delay_seconds: int,
     ) -> RunProgress:
         progress = RunProgress()
+
+        # ── Pass 1: first page of every scholar (breadth-first) ──────────
+        # This ensures all scholars have visible publications as quickly as
+        # possible, rather than fully paginating one scholar before the next.
+        first_pass_cstarts: dict[int, int] = {}
         for index, scholar in enumerate(scholars):
+            await db_session.refresh(run)
+            if run.status == RunStatus.CANCELED:
+                logger.info(
+                    "ingestion.run_canceled",
+                    extra={"event": "ingestion.run_canceled", "run_id": run.id, "user_id": user_id},
+                )
+                return progress
             await self._wait_between_scholars(index=index, request_delay_seconds=request_delay_seconds)
             start_cstart = int(start_cstart_map.get(int(scholar.id), 0))
             outcome = await self._process_scholar(
@@ -1261,9 +1319,50 @@ class ScholarIngestionService:
                 request_delay_seconds=request_delay_seconds,
                 network_error_retries=network_error_retries,
                 retry_backoff_seconds=retry_backoff_seconds,
-                max_pages_per_scholar=max_pages_per_scholar,
+                rate_limit_retries=rate_limit_retries,
+                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+                max_pages_per_scholar=1,
                 page_size=page_size,
                 start_cstart=start_cstart,
+                auto_queue_continuations=False,
+                queue_delay_seconds=queue_delay_seconds,
+            )
+            self._apply_outcome_to_progress(progress=progress, run=run, outcome=outcome)
+            # Track where to resume from for the deep pass
+            resume_cstart = outcome.result_entry.get("continuation_cstart")
+            if resume_cstart is not None and int(resume_cstart) > start_cstart:
+                first_pass_cstarts[int(scholar.id)] = int(resume_cstart)
+
+        # ── Pass 2: remaining pages for each scholar (depth) ─────────────
+        remaining_max = max(max_pages_per_scholar - 1, 0)
+        if remaining_max <= 0:
+            return progress
+
+        for index, scholar in enumerate(scholars):
+            resume_cstart = first_pass_cstarts.get(int(scholar.id))
+            if resume_cstart is None:
+                continue  # first page failed, had no continuation, or was skipped
+            await db_session.refresh(run)
+            if run.status == RunStatus.CANCELED:
+                logger.info(
+                    "ingestion.run_canceled",
+                    extra={"event": "ingestion.run_canceled", "run_id": run.id, "user_id": user_id},
+                )
+                break
+            await self._wait_between_scholars(index=index, request_delay_seconds=request_delay_seconds)
+            outcome = await self._process_scholar(
+                db_session,
+                run=run,
+                scholar=scholar,
+                user_id=user_id,
+                request_delay_seconds=request_delay_seconds,
+                network_error_retries=network_error_retries,
+                retry_backoff_seconds=retry_backoff_seconds,
+                rate_limit_retries=rate_limit_retries,
+                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+                max_pages_per_scholar=remaining_max,
+                page_size=page_size,
+                start_cstart=resume_cstart,
                 auto_queue_continuations=auto_queue_continuations,
                 queue_delay_seconds=queue_delay_seconds,
             )
@@ -1307,17 +1406,50 @@ class ScholarIngestionService:
         )
         return failure_summary, alert_summary
 
-    async def run_for_user(self, db_session: AsyncSession, *, user_id: int, trigger_type: RunTriggerType, request_delay_seconds: int, network_error_retries: int = 1, retry_backoff_seconds: float = 1.0, max_pages_per_scholar: int = 30, page_size: int = 100, scholar_profile_ids: set[int] | None = None, start_cstart_by_scholar_id: dict[int, int] | None = None, auto_queue_continuations: bool = True, queue_delay_seconds: int = 60, idempotency_key: str | None = None, alert_blocked_failure_threshold: int = 1, alert_network_failure_threshold: int = 2, alert_retry_scheduled_threshold: int = 3) -> RunExecutionSummary:
-        effective_request_delay_seconds = self._effective_request_delay_seconds(request_delay_seconds)
-        if effective_request_delay_seconds != _int_or_default(request_delay_seconds, effective_request_delay_seconds):
+    async def initialize_run(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_id: int,
+        trigger_type: RunTriggerType,
+        request_delay_seconds: int,
+        network_error_retries: int = 1,
+        retry_backoff_seconds: float = 1.0,
+        rate_limit_retries: int | None = None,
+        rate_limit_backoff_seconds: float | None = None,
+        max_pages_per_scholar: int = 30,
+        page_size: int = 100,
+        scholar_profile_ids: set[int] | None = None,
+        start_cstart_by_scholar_id: dict[int, int] | None = None,
+        idempotency_key: str | None = None,
+        alert_blocked_failure_threshold: int = 1,
+        alert_network_failure_threshold: int = 2,
+        alert_retry_scheduled_threshold: int = 3,
+    ) -> tuple[CrawlRun, list[ScholarProfile], dict[int, int]]:
+        effective_delay = self._effective_request_delay_seconds(request_delay_seconds)
+        if effective_delay != _int_or_default(request_delay_seconds, effective_delay):
             self._log_request_delay_coercion(
                 user_id=user_id,
                 requested_request_delay_seconds=_int_or_default(request_delay_seconds, 0),
-                effective_request_delay_seconds=effective_request_delay_seconds,
+                effective_request_delay_seconds=effective_delay,
             )
-        paging_kwargs = self._paging_kwargs(request_delay_seconds=effective_request_delay_seconds, network_error_retries=network_error_retries, retry_backoff_seconds=retry_backoff_seconds, max_pages_per_scholar=max_pages_per_scholar, page_size=page_size)
-        threshold_kwargs = self._threshold_kwargs(alert_blocked_failure_threshold=alert_blocked_failure_threshold, alert_network_failure_threshold=alert_network_failure_threshold, alert_retry_scheduled_threshold=alert_retry_scheduled_threshold)
-        user_settings, run, scholars, start_cstart_map = await self._initialize_run_for_user(
+
+        paging_kwargs = self._paging_kwargs(
+            request_delay_seconds=effective_delay,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries if rate_limit_retries is not None else settings.ingestion_rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds if rate_limit_backoff_seconds is not None else settings.ingestion_rate_limit_backoff_seconds,
+            max_pages_per_scholar=max_pages_per_scholar,
+            page_size=page_size,
+        )
+        threshold_kwargs = self._threshold_kwargs(
+            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
+            alert_network_failure_threshold=alert_network_failure_threshold,
+            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+        )
+
+        _, run, scholars, start_cstart_map = await self._initialize_run_for_user(
             db_session,
             user_id=user_id,
             trigger_type=trigger_type,
@@ -1327,6 +1459,224 @@ class ScholarIngestionService:
             **paging_kwargs,
             **threshold_kwargs,
         )
+        return run, scholars, start_cstart_map
+
+    async def execute_run(
+        self,
+        session_factory: Any,
+        *,
+        run_id: int,
+        user_id: int,
+        scholars: list[ScholarProfile],
+        start_cstart_map: dict[int, int],
+        request_delay_seconds: int,
+        network_error_retries: int = 1,
+        retry_backoff_seconds: float = 1.0,
+        rate_limit_retries: int | None = None,
+        rate_limit_backoff_seconds: float | None = None,
+        max_pages_per_scholar: int = 30,
+        page_size: int = 100,
+        auto_queue_continuations: bool = True,
+        queue_delay_seconds: int = 60,
+        alert_blocked_failure_threshold: int = 1,
+        alert_network_failure_threshold: int = 2,
+        alert_retry_scheduled_threshold: int = 3,
+        idempotency_key: str | None = None,
+    ) -> None:
+        async with session_factory() as db_session:
+            try:
+                # Re-fetch everything to ensure attachment to the new session
+                run, user_settings, attached_scholars = await self._prepare_execute_run(
+                    db_session, run_id=run_id, user_id=user_id, scholars=scholars
+                )
+                
+                paging_kwargs = self._paging_kwargs(
+                    request_delay_seconds=request_delay_seconds,
+                    network_error_retries=network_error_retries,
+                    retry_backoff_seconds=retry_backoff_seconds,
+                    rate_limit_retries=rate_limit_retries if rate_limit_retries is not None else settings.ingestion_rate_limit_retries,
+                    rate_limit_backoff_seconds=rate_limit_backoff_seconds if rate_limit_backoff_seconds is not None else settings.ingestion_rate_limit_backoff_seconds,
+                    max_pages_per_scholar=max_pages_per_scholar,
+                    page_size=page_size,
+                )
+                threshold_kwargs = self._threshold_kwargs(
+                    alert_blocked_failure_threshold=alert_blocked_failure_threshold,
+                    alert_network_failure_threshold=alert_network_failure_threshold,
+                    alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+                )
+
+                progress = await self._run_scholar_iteration(
+                    db_session,
+                    run=run,
+                    scholars=attached_scholars,
+                    user_id=user_id,
+                    start_cstart_map=start_cstart_map,
+                    auto_queue_continuations=auto_queue_continuations,
+                    queue_delay_seconds=queue_delay_seconds,
+                    **paging_kwargs,
+                )
+
+                failure_summary, alert_summary = self._complete_run_for_user(
+                    user_settings=user_settings,
+                    run=run,
+                    scholars=attached_scholars,
+                    user_id=user_id,
+                    progress=progress,
+                    idempotency_key=idempotency_key,
+                    **threshold_kwargs,
+                )
+
+                # Capture the final status that _finalize_run_record computed,
+                # then set RESOLVING so the UI shows enrichment is in progress.
+                intended_final_status = run.status
+                if intended_final_status not in (RunStatus.CANCELED,):
+                    run.status = RunStatus.RESOLVING
+                await db_session.commit()
+                self._log_run_completed(user_id=user_id, run=run, scholars=attached_scholars, progress=progress, alert_summary=alert_summary, failure_summary=failure_summary)
+
+                # Fire-and-forget enrichment in a separate background task
+                if intended_final_status not in (RunStatus.CANCELED,):
+                    asyncio.create_task(
+                        self._background_enrich(
+                            session_factory,
+                            run_id=run.id,
+                            intended_final_status=intended_final_status,
+                            openalex_api_key=getattr(user_settings, "openalex_api_key", None),
+                        )
+                    )
+            except Exception as exc:
+                await db_session.rollback()
+                logger.exception("ingestion.background_run_failed", extra={"event": "ingestion.background_run_failed", "run_id": run_id, "user_id": user_id})
+                await self._fail_run_in_background(session_factory, run_id, exc)
+
+    async def _prepare_execute_run(
+        self,
+        db_session: AsyncSession,
+        *,
+        run_id: int,
+        user_id: int,
+        scholars: list[ScholarProfile],
+    ) -> tuple[CrawlRun, Any, list[ScholarProfile]]:
+        run_result = await db_session.execute(select(CrawlRun).where(CrawlRun.id == run_id))
+        run = run_result.scalar_one()
+        user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=user_id)
+
+        scholar_ids = [s.id for s in scholars]
+        scholars_result = await db_session.execute(
+            select(ScholarProfile).where(ScholarProfile.id.in_(scholar_ids))
+            .order_by(ScholarProfile.created_at.asc(), ScholarProfile.id.asc())
+        )
+        return run, user_settings, list(scholars_result.scalars().all())
+
+    async def _fail_run_in_background(self, session_factory: Any, run_id: int, exc: Exception) -> None:
+        async with session_factory() as cleanup_session:
+            run_to_fail = await cleanup_session.get(CrawlRun, run_id)
+            if run_to_fail:
+                run_to_fail.status = RunStatus.FAILED
+                run_to_fail.end_dt = datetime.now(timezone.utc)
+                run_to_fail.error_log["terminal_exception"] = str(exc)
+                await cleanup_session.commit()
+
+    async def _background_enrich(
+        self,
+        session_factory: Any,
+        *,
+        run_id: int,
+        intended_final_status: RunStatus,
+        openalex_api_key: str | None = None,
+    ) -> None:
+        """Run enrichment independently — failures don't affect run status."""
+        try:
+            async with session_factory() as session:
+                await self._enrich_pending_publications(
+                    session,
+                    run_id=run_id,
+                    openalex_api_key=openalex_api_key,
+                )
+                run = await session.get(CrawlRun, run_id)
+                if run is not None and run.status == RunStatus.RESOLVING:
+                    run.status = intended_final_status
+                await session.commit()
+                logger.info(
+                    "ingestion.background_enrichment_complete",
+                    extra={"run_id": run_id, "final_status": str(intended_final_status)},
+                )
+        except Exception:
+            logger.exception(
+                "ingestion.background_enrichment_failed",
+                extra={"run_id": run_id},
+            )
+            # Still transition out of RESOLVING so the run doesn't stay stuck.
+            try:
+                async with session_factory() as fallback_session:
+                    run = await fallback_session.get(CrawlRun, run_id)
+                    if run is not None and run.status == RunStatus.RESOLVING:
+                        run.status = intended_final_status
+                    await fallback_session.commit()
+            except Exception:
+                logger.exception(
+                    "ingestion.background_enrichment_fallback_failed",
+                    extra={"run_id": run_id},
+                )
+
+    async def run_for_user(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_id: int,
+        trigger_type: RunTriggerType,
+        request_delay_seconds: int,
+        network_error_retries: int = 1,
+        retry_backoff_seconds: float = 1.0,
+        rate_limit_retries: int | None = None,
+        rate_limit_backoff_seconds: float | None = None,
+        max_pages_per_scholar: int = 30,
+        page_size: int = 100,
+        scholar_profile_ids: set[int] | None = None,
+        start_cstart_by_scholar_id: dict[int, int] | None = None,
+        auto_queue_continuations: bool = True,
+        queue_delay_seconds: int = 60,
+        idempotency_key: str | None = None,
+        alert_blocked_failure_threshold: int = 1,
+        alert_network_failure_threshold: int = 2,
+        alert_retry_scheduled_threshold: int = 3,
+    ) -> RunExecutionSummary:
+        # Legacy/Synchronous trigger (used by tests or older flows)
+        run, scholars, start_cstart_map = await self.initialize_run(
+            db_session,
+            user_id=user_id,
+            trigger_type=trigger_type,
+            request_delay_seconds=request_delay_seconds,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+            max_pages_per_scholar=max_pages_per_scholar,
+            page_size=page_size,
+            scholar_profile_ids=scholar_profile_ids,
+            start_cstart_by_scholar_id=start_cstart_by_scholar_id,
+            idempotency_key=idempotency_key,
+            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
+            alert_network_failure_threshold=alert_network_failure_threshold,
+            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+        )
+        
+        paging_kwargs = self._paging_kwargs(
+            request_delay_seconds=self._effective_request_delay_seconds(request_delay_seconds),
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries if rate_limit_retries is not None else settings.ingestion_rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds if rate_limit_backoff_seconds is not None else settings.ingestion_rate_limit_backoff_seconds,
+            max_pages_per_scholar=max_pages_per_scholar,
+            page_size=page_size,
+        )
+        
+        threshold_kwargs = self._threshold_kwargs(
+            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
+            alert_network_failure_threshold=alert_network_failure_threshold,
+            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+        )
+
         progress = await self._run_scholar_iteration(
             db_session,
             run=run,
@@ -1337,6 +1687,8 @@ class ScholarIngestionService:
             queue_delay_seconds=queue_delay_seconds,
             **paging_kwargs,
         )
+
+        user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=user_id)
         failure_summary, alert_summary = self._complete_run_for_user(
             user_settings=user_settings,
             run=run,
@@ -1346,7 +1698,27 @@ class ScholarIngestionService:
             idempotency_key=idempotency_key,
             **threshold_kwargs,
         )
+
+        # Set RESOLVING during enrichment (synchronous path).
+        intended_final_status = run.status
+        if intended_final_status not in (RunStatus.CANCELED,):
+            run.status = RunStatus.RESOLVING
         await db_session.commit()
+
+        try:
+            await self._enrich_pending_publications(
+                db_session,
+                run_id=run.id,
+                openalex_api_key=getattr(user_settings, "openalex_api_key", None),
+            )
+        except Exception:
+            logger.exception("ingestion.enrichment_failed", extra={"run_id": run.id})
+
+        # Finalize to the intended status unless the run was canceled during resolving.
+        if run.status == RunStatus.RESOLVING:
+            run.status = intended_final_status
+        await db_session.commit()
+
         self._log_run_completed(user_id=user_id, run=run, scholars=scholars, progress=progress, alert_summary=alert_summary, failure_summary=failure_summary)
         return self._run_execution_summary(run=run, scholars=scholars, progress=progress)
 
@@ -1416,32 +1788,45 @@ class ScholarIngestionService:
         }
 
     @staticmethod
-    def _should_retry_network_page(
+    def _should_retry_page_fetch(
         *,
         parsed_page: ParsedProfilePage,
-        attempt_index: int,
-        max_attempts: int,
+        network_attempt_count: int,
+        rate_limit_attempt_count: int,
+        network_error_retries: int,
+        rate_limit_retries: int,
     ) -> bool:
-        return parsed_page.state == ParseState.NETWORK_ERROR and attempt_index < max_attempts - 1
+        if parsed_page.state == ParseState.NETWORK_ERROR:
+            return network_attempt_count <= network_error_retries
+        if parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA and parsed_page.state_reason == "blocked_http_429_rate_limited":
+            return rate_limit_attempt_count <= rate_limit_retries
+        return False
 
     @staticmethod
     async def _sleep_retry_backoff(
         *,
         scholar_id: str,
         cstart: int,
-        attempt_index: int,
-        backoff: float,
+        network_attempt_count: int,
+        rate_limit_attempt_count: int,
+        retry_backoff_seconds: float,
+        rate_limit_backoff_seconds: float,
         state_reason: str,
     ) -> None:
-        sleep_seconds = backoff * (2**attempt_index)
+        if state_reason == "blocked_http_429_rate_limited":
+            sleep_seconds = rate_limit_backoff_seconds * rate_limit_attempt_count
+            attempt_label = rate_limit_attempt_count
+        else:
+            sleep_seconds = retry_backoff_seconds * (2 ** (network_attempt_count - 1))
+            attempt_label = network_attempt_count
+
         logger.warning(
             "ingestion.scholar_retry_scheduled",
             extra={
                 "event": "ingestion.scholar_retry_scheduled",
                 "scholar_id": scholar_id,
                 "cstart": cstart,
-                "attempt": attempt_index + 1,
-                "next_attempt": attempt_index + 2,
+                "attempt_count": attempt_label,
                 "sleep_seconds": sleep_seconds,
                 "state_reason": state_reason,
             },
@@ -1457,39 +1842,57 @@ class ScholarIngestionService:
         page_size: int,
         network_error_retries: int,
         retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
     ) -> tuple[FetchResult, ParsedProfilePage, list[dict[str, Any]]]:
-        max_attempts = max(1, int(network_error_retries) + 1)
-        backoff = max(float(retry_backoff_seconds), 0.0)
+        network_attempts = 0
+        rate_limit_attempts = 0
         attempt_log: list[dict[str, Any]] = []
         fetch_result: FetchResult | None = None
         parsed_page: ParsedProfilePage | None = None
 
-        for attempt_index in range(max_attempts):
+        while True:
             fetch_result = await self._fetch_profile_page(
                 scholar_id=scholar_id,
                 cstart=cstart,
                 page_size=page_size,
             )
             parsed_page = self._parse_profile_page_or_layout_error(fetch_result=fetch_result)
+            
+            if parsed_page.state == ParseState.NETWORK_ERROR:
+                network_attempts += 1
+                total_attempts = network_attempts
+            elif parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA and parsed_page.state_reason == "blocked_http_429_rate_limited":
+                rate_limit_attempts += 1
+                total_attempts = rate_limit_attempts
+            else:
+                total_attempts = network_attempts + rate_limit_attempts + 1
+
             attempt_log.append(
                 self._attempt_log_entry(
-                    attempt=attempt_index + 1,
+                    attempt=total_attempts,
                     cstart=cstart,
                     fetch_result=fetch_result,
                     parsed_page=parsed_page,
                 )
             )
-            if not self._should_retry_network_page(
+
+            if not self._should_retry_page_fetch(
                 parsed_page=parsed_page,
-                attempt_index=attempt_index,
-                max_attempts=max_attempts,
+                network_attempt_count=network_attempts,
+                rate_limit_attempt_count=rate_limit_attempts,
+                network_error_retries=network_error_retries,
+                rate_limit_retries=rate_limit_retries,
             ):
                 break
+
             await self._sleep_retry_backoff(
                 scholar_id=scholar_id,
                 cstart=cstart,
-                attempt_index=attempt_index,
-                backoff=backoff,
+                network_attempt_count=network_attempts,
+                rate_limit_attempt_count=rate_limit_attempts,
+                retry_backoff_seconds=max(float(retry_backoff_seconds), 0.0),
+                rate_limit_backoff_seconds=max(float(rate_limit_backoff_seconds), 0.0),
                 state_reason=parsed_page.state_reason,
             )
 
@@ -1591,6 +1994,7 @@ class ScholarIngestionService:
             pagination_truncated_reason=None,
             continuation_cstart=None,
             skipped_no_change=True,
+            discovered_publication_count=0,
         )
 
     @staticmethod
@@ -1619,6 +2023,7 @@ class ScholarIngestionService:
             pagination_truncated_reason=None,
             continuation_cstart=continuation_cstart,
             skipped_no_change=False,
+            discovered_publication_count=0,
         )
 
     @staticmethod
@@ -1685,6 +2090,8 @@ class ScholarIngestionService:
         bounded_page_size: int,
         network_error_retries: int,
         retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
     ) -> tuple[FetchResult, ParsedProfilePage, list[dict[str, Any]]]:
         if request_delay_seconds > 0:
             await asyncio.sleep(float(request_delay_seconds))
@@ -1695,6 +2102,8 @@ class ScholarIngestionService:
             page_size=bounded_page_size,
             network_error_retries=network_error_retries,
             retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
         )
 
     @staticmethod
@@ -1747,6 +2156,8 @@ class ScholarIngestionService:
         bounded_page_size: int,
         network_error_retries: int,
         retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
     ) -> tuple[FetchResult, ParsedProfilePage, str | None, list[dict[str, Any]], list[dict[str, Any]]]:
         fetch_result, parsed_page, first_attempt_log = await self._fetch_and_parse_page_with_retry(
             scholar_id=scholar_id,
@@ -1754,6 +2165,8 @@ class ScholarIngestionService:
             page_size=bounded_page_size,
             network_error_retries=network_error_retries,
             retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
         )
         first_page_fingerprint_sha256 = build_initial_page_fingerprint(parsed_page)
         attempt_log = list(first_attempt_log)
@@ -1771,24 +2184,56 @@ class ScholarIngestionService:
     async def _paginate_loop(
         self,
         *,
-        scholar_id: str,
+        scholar: ScholarProfile,
+        run: CrawlRun,
+        db_session: AsyncSession,
         state: PagedLoopState,
         bounded_max_pages: int,
         request_delay_seconds: int,
         bounded_page_size: int,
         network_error_retries: int,
         retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
     ) -> None:
+        # Cross-page canonical dedup state; grows across all pages of this scholar.
+        seen_canonical: set[str] = set()
+
+        if state.parsed_page.publications:
+            deduped_first = _dedupe_publication_candidates(
+                list(state.parsed_page.publications), seen_canonical=seen_canonical
+            )
+            if deduped_first:
+                discovered_count = await self._upsert_profile_publications(
+                    db_session, run=run, scholar=scholar, publications=deduped_first
+                )
+                state.discovered_publication_count += discovered_count
+
         while state.parsed_page.has_show_more_button:
+            await db_session.refresh(run)
+            if run.status == RunStatus.CANCELED:
+                logger.info(
+                    "ingestion.pagination_canceled",
+                    extra={"event": "ingestion.pagination_canceled", "run_id": run.id},
+                )
+                self._set_truncated_state(
+                    state=state,
+                    reason="run_canceled",
+                    continuation_cstart=state.current_cstart,
+                )
+                return
+
             if self._should_stop_pagination(state=state, bounded_max_pages=bounded_max_pages):
                 return
             next_fetch_result, next_parsed_page, next_attempt_log = await self._fetch_next_page(
-                scholar_id=scholar_id,
+                scholar_id=scholar.scholar_id,
                 state=state,
                 request_delay_seconds=request_delay_seconds,
                 bounded_page_size=bounded_page_size,
                 network_error_retries=network_error_retries,
                 retry_backoff_seconds=retry_backoff_seconds,
+                rate_limit_retries=rate_limit_retries,
+                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
             )
             self._record_next_page(
                 state=state,
@@ -1796,6 +2241,19 @@ class ScholarIngestionService:
                 parsed_page=next_parsed_page,
                 page_attempt_log=next_attempt_log,
             )
+
+            # Deduplicate against all publications already committed this run,
+            # then immediately commit the surviving candidates to the DB.
+            if next_parsed_page.publications:
+                deduped_next = _dedupe_publication_candidates(
+                    list(next_parsed_page.publications), seen_canonical=seen_canonical
+                )
+                if deduped_next:
+                    discovered_count = await self._upsert_profile_publications(
+                        db_session, run=run, scholar=scholar, publications=deduped_next
+                    )
+                    state.discovered_publication_count += discovered_count
+
             if self._handle_page_state_transition(state=state):
                 return
 
@@ -1822,6 +2280,7 @@ class ScholarIngestionService:
             pagination_truncated_reason=state.pagination_truncated_reason,
             continuation_cstart=state.continuation_cstart,
             skipped_no_change=False,
+            discovered_publication_count=state.discovered_publication_count,
         )
 
     def _short_circuit_initial_page(
@@ -1859,16 +2318,33 @@ class ScholarIngestionService:
             )
         return None
 
-    async def _fetch_and_parse_all_pages_with_retry(self, *, scholar_id: str, start_cstart: int, request_delay_seconds: int, network_error_retries: int, retry_backoff_seconds: float, max_pages: int, page_size: int, previous_initial_page_fingerprint_sha256: str | None = None) -> PagedParseResult:
+    async def _fetch_and_parse_all_pages_with_retry(
+        self,
+        *,
+        scholar: ScholarProfile,
+        run: CrawlRun,
+        db_session: AsyncSession,
+        start_cstart: int,
+        request_delay_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+        max_pages: int,
+        page_size: int,
+        previous_initial_page_fingerprint_sha256: str | None = None
+    ) -> PagedParseResult:
         bounded_max_pages = max(1, int(max_pages))
         bounded_page_size = max(1, int(page_size))
         fetch_result, parsed_page, first_page_fingerprint_sha256, attempt_log, page_logs = (
             await self._fetch_initial_page_context(
-            scholar_id=scholar_id,
+            scholar_id=scholar.scholar_id,
             start_cstart=start_cstart,
             bounded_page_size=bounded_page_size,
             network_error_retries=network_error_retries,
             retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
         ))
         shortcut_result = self._short_circuit_initial_page(
             start_cstart=start_cstart,
@@ -1889,13 +2365,17 @@ class ScholarIngestionService:
             page_logs=page_logs,
         )
         await self._paginate_loop(
-            scholar_id=scholar_id,
+            scholar=scholar,
+            run=run,
+            db_session=db_session,
             state=state,
             bounded_max_pages=bounded_max_pages,
             request_delay_seconds=request_delay_seconds,
             bounded_page_size=bounded_page_size,
             network_error_retries=network_error_retries,
             retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
         )
         return self._result_from_pagination_state(
             state=state,
@@ -1904,6 +2384,222 @@ class ScholarIngestionService:
             first_page_fingerprint_sha256=first_page_fingerprint_sha256,
         )
 
+    async def _run_is_canceled(
+        self,
+        db_session: AsyncSession,
+        *,
+        run_id: int,
+    ) -> bool:
+        check_result = await db_session.execute(
+            select(CrawlRun.status).where(CrawlRun.id == run_id)
+        )
+        status = check_result.scalar_one_or_none()
+        if status is None:
+            raise RuntimeError(f"Missing crawl_run for run_id={run_id}.")
+        return status == RunStatus.CANCELED
+
+    async def _enrich_pending_publications(
+        self,
+        db_session: AsyncSession,
+        *,
+        run_id: int,
+        openalex_api_key: str | None = None,
+    ) -> None:
+        """Enrich unenriched publications with OpenAlex data.
+
+        Stops immediately on budget exhaustion (429 with $0 remaining).
+        Sleeps 60s and continues on transient rate limits.
+        """
+        from app.services.domains.openalex.client import (
+            OpenAlexBudgetExhaustedError,
+            OpenAlexClient,
+            OpenAlexRateLimitError,
+        )
+        from app.services.domains.openalex.matching import find_best_match
+
+        run_result = await db_session.execute(
+            select(CrawlRun.user_id).where(CrawlRun.id == run_id)
+        )
+        user_id = run_result.scalar_one()
+
+        now = datetime.now(timezone.utc)
+        cooldown_threshold = now - timedelta(days=7)
+
+        stmt = (
+            select(Publication)
+            .join(ScholarPublication)
+            .join(ScholarProfile, ScholarPublication.scholar_profile_id == ScholarProfile.id)
+            .where(
+                ScholarProfile.user_id == user_id,
+                Publication.openalex_enriched.is_(False),
+                or_(
+                    Publication.openalex_last_attempt_at.is_(None),
+                    Publication.openalex_last_attempt_at < cooldown_threshold,
+                ),
+            )
+            .distinct()
+        )
+        result = await db_session.execute(stmt)
+        publications = list(result.scalars().all())
+
+        if not publications:
+            return
+
+        resolved_key = openalex_api_key or settings.openalex_api_key
+        client = OpenAlexClient(api_key=resolved_key, mailto=settings.crossref_api_mailto)
+        batch_size = 25
+
+        for i in range(0, len(publications), batch_size):
+            if await self._run_is_canceled(db_session, run_id=run_id):
+                logger.info("ingestion.enrichment_aborted", extra={"run_id": run_id})
+                return
+            batch = publications[i : i + batch_size]
+            titles = [
+                " ".join(re.sub(r"[^\w\s]", " ", p.title_raw).split())
+                for p in batch
+                if p.title_raw and p.title_raw.strip()
+            ]
+
+            if not titles:
+                continue
+
+            try:
+                openalex_works = await client.get_works_by_filter(
+                    {"title.search": "|".join(titles)}, limit=batch_size * 3
+                )
+            except OpenAlexBudgetExhaustedError:
+                logger.warning(
+                    "ingestion.openalex_budget_exhausted",
+                    extra={"event": "ingestion.openalex_budget_exhausted", "run_id": run_id},
+                )
+                break  # Stop all enrichment — budget won't reset until midnight UTC
+            except OpenAlexRateLimitError:
+                logger.warning(
+                    "ingestion.openalex_rate_limited",
+                    extra={"event": "ingestion.openalex_rate_limited", "run_id": run_id},
+                )
+                await asyncio.sleep(60)
+                continue
+            except Exception as e:
+                logger.warning(
+                    "ingestion.openalex_enrichment_failed",
+                    extra={"event": "ingestion.openalex_enrichment_failed", "error": str(e), "run_id": run_id},
+                )
+                continue
+
+            for p in batch:
+                # Check for cancellation periodically within the batch
+                if await self._run_is_canceled(db_session, run_id=run_id):
+                    logger.info("ingestion.enrichment_aborted", extra={"run_id": run_id})
+                    return
+
+                p.openalex_last_attempt_at = now
+                
+                # Perform identifier discovery (moved from synchronous ingest loop)
+                await identifier_service.discover_and_sync_identifiers_for_publication(
+                    db_session,
+                    publication=p,
+                    scholar_label=p.author_text or "",
+                )
+
+                match = find_best_match(
+                    target_title=p.title_raw,
+                    target_year=p.year,
+                    target_authors=p.author_text or "",
+                    candidates=openalex_works,
+                )
+                if match:
+                    p.year = match.publication_year or p.year
+                    p.citation_count = match.cited_by_count or p.citation_count
+                    p.pdf_url = match.oa_url or p.pdf_url
+                    p.openalex_enriched = True
+
+        await db_session.flush()
+
+        from app.services.domains.publications.dedup import sweep_identifier_duplicates
+
+        merge_count = await sweep_identifier_duplicates(db_session)
+        if merge_count:
+            logger.info(
+                "ingestion.identifier_dedup_sweep",
+                extra={
+                    "event": "ingestion.identifier_dedup_sweep",
+                    "merged_count": merge_count,
+                    "run_id": run_id,
+                },
+            )
+
+    async def _enrich_publications_with_openalex(
+        self,
+        scholar: ScholarProfile,
+        publications: list[PublicationCandidate],
+    ) -> list[PublicationCandidate]:
+        if not publications:
+            return publications
+
+        from app.services.domains.openalex.client import OpenAlexClient
+        from app.services.domains.openalex.matching import find_best_match
+        
+        client = OpenAlexClient(api_key=settings.openalex_api_key, mailto=settings.crossref_api_mailto)
+        
+        # Batch requests by 25 to stay within URL length limits
+        batch_size = 25
+        enriched: list[PublicationCandidate] = []
+        
+        import re
+        for i in range(0, len(publications), batch_size):
+            batch = publications[i:i + batch_size]
+            
+            titles = []
+            for p in batch:
+                if not p.title:
+                    continue
+                # Strip all non-alphanumeric words to prevent OpenAlex API injection crashes
+                # and minimize punctuation-based duplicate misses.
+                safe_title = re.sub(r"[^\w\s]", " ", p.title)
+                safe_title = " ".join(safe_title.split())
+                if safe_title:
+                    titles.append(safe_title)
+            
+            if not titles:
+                enriched.extend(batch)
+                continue
+            
+            query = "|".join(t for t in titles)
+            try:
+                openalex_works = await client.get_works_by_filter(
+                    {"title.search": query}, limit=batch_size * 3
+                )
+            except Exception as e:
+                logger.warning(
+                    "ingestion.openalex_enrichment_failed",
+                    extra={"error": str(e), "batch_size": len(batch), "scholar_id": scholar.id}
+                )
+                openalex_works = []
+                
+            for p in batch:
+                match = find_best_match(
+                    target_title=p.title,
+                    target_year=p.year,
+                    target_authors=p.authors_text or (scholar.display_name or scholar.scholar_id),
+                    candidates=openalex_works
+                )
+                if match:
+                    new_p = PublicationCandidate(
+                        title=p.title,
+                        title_url=p.title_url,
+                        cluster_id=p.cluster_id,
+                        year=match.publication_year or p.year,
+                        citation_count=match.cited_by_count,
+                        authors_text=p.authors_text,
+                        venue_text=p.venue_text,
+                        pdf_url=match.oa_url or p.pdf_url,
+                    )
+                    enriched.append(new_p)
+                else:
+                    enriched.append(p)
+        return enriched
+
     async def _upsert_profile_publications(
         self,
         db_session: AsyncSession,
@@ -1912,6 +2608,7 @@ class ScholarIngestionService:
         scholar: ScholarProfile,
         publications: list[PublicationCandidate],
     ) -> int:
+        # We no longer enrich inline here. Enrichment is now deferred to the end of the run.
         seen_publication_ids: set[int] = set()
         discovered_count = 0
 
@@ -1949,12 +2646,43 @@ class ScholarIngestionService:
                     "crawl_run_id": run.id,
                 },
             )
+            
+            await self._commit_discovered_publication(
+                db_session,
+                run=run,
+                scholar=scholar,
+                publication=publication,
+            )
 
         if not scholar.baseline_completed:
             scholar.baseline_completed = True
 
         return discovered_count
 
+    async def _commit_discovered_publication(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        publication: Publication,
+    ) -> None:
+        run.new_pub_count = int(run.new_pub_count or 0) + 1
+        await db_session.commit()
+        await run_events.publish(
+            run_id=run.id,
+            event_type="publication_discovered",
+            data={
+                "publication_id": publication.id,
+                "title": publication.title_raw,
+                "pub_url": publication.pub_url,
+                "scholar_profile_id": scholar.id,
+                "scholar_label": scholar.display_name or scholar.scholar_id,
+                "first_seen_at": datetime.now(timezone.utc).isoformat(),
+                "new_publication_count": int(run.new_pub_count or 0),
+            },
+        )
+
     @staticmethod
     def _validate_publication_candidate(candidate: PublicationCandidate) -> None:
         if not candidate.title.strip():
@@ -1996,6 +2724,24 @@ class ScholarIngestionService:
             return cluster_publication
         return fingerprint_publication
 
+    @staticmethod
+    def _compute_canonical_title_hash(title: str) -> str:
+        canonical = canonical_title_for_dedup(title)
+        return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+    async def _find_publication_by_canonical_title_hash(
+        self,
+        db_session: AsyncSession,
+        *,
+        canonical_title_hash: str,
+    ) -> Publication | None:
+        result = await db_session.execute(
+            select(Publication).where(
+                Publication.canonical_title_hash == canonical_title_hash
+            )
+        )
+        return result.scalar_one_or_none()
+
     async def _create_publication(
         self,
         db_session: AsyncSession,
@@ -2008,12 +2754,12 @@ class ScholarIngestionService:
             fingerprint_sha256=fingerprint,
             title_raw=candidate.title,
             title_normalized=normalize_title(candidate.title),
+            canonical_title_hash=self._compute_canonical_title_hash(candidate.title),
             year=candidate.year,
             citation_count=int(candidate.citation_count or 0),
             author_text=candidate.authors_text,
             venue_text=candidate.venue_text,
             pub_url=build_publication_url(candidate.title_url),
-            doi=first_doi_from_texts(candidate.title_url, candidate.venue_text, candidate.title),
             pdf_url=None,
         )
         db_session.add(publication)
@@ -2049,8 +2795,6 @@ class ScholarIngestionService:
         if candidate.title_url:
             publication.pub_url = build_publication_url(candidate.title_url)
         local_doi = first_doi_from_texts(candidate.title_url, candidate.venue_text, candidate.title)
-        if local_doi and not publication.doi:
-            publication.doi = local_doi
 
     async def _resolve_publication(
         self,
@@ -2071,12 +2815,21 @@ class ScholarIngestionService:
             cluster_publication=cluster_publication,
             fingerprint_publication=fingerprint_publication,
         )
+        if publication is None:
+            # Fallback: canonical title hash — catches cross-scholar noise variants
+            # (e.g. "Adam preprint (2014)" vs "Adam arXiv 2017" → same normalized form)
+            canonical_hash = self._compute_canonical_title_hash(candidate.title)
+            publication = await self._find_publication_by_canonical_title_hash(
+                db_session,
+                canonical_title_hash=canonical_hash,
+            )
         if publication is None:
             created = await self._create_publication(
                 db_session,
                 candidate=candidate,
                 fingerprint=fingerprint,
             )
+            # Sync identifiers from local fields only for fast UI response
             await identifier_service.sync_identifiers_for_publication_fields(
                 db_session,
                 publication=created,
@@ -2086,6 +2839,7 @@ class ScholarIngestionService:
             publication=publication,
             candidate=candidate,
         )
+        # Sync identifiers from local fields only for fast UI response
         await identifier_service.sync_identifiers_for_publication_fields(
             db_session,
             publication=publication,
diff --git a/app/services/domains/ingestion/fingerprints.py b/app/services/domains/ingestion/fingerprints.py
index cf3e796..30745b0 100644
--- a/app/services/domains/ingestion/fingerprints.py
+++ b/app/services/domains/ingestion/fingerprints.py
@@ -15,12 +15,59 @@ from app.services.domains.ingestion.constants import (
 )
 from app.services.domains.scholar.parser import ParseState, ParsedProfilePage, PublicationCandidate
 
+# Scholar-specific noise patterns stripped before canonical comparison.
+# Applied in order; each targets a different Scholar metadata injection style.
+_NOISE_DOI_RE = re.compile(r"[,.\s]+doi\s*:\s*\S+.*$", re.IGNORECASE)
+_NOISE_ARXIV_RE = re.compile(r"[,.\s]+arxiv\b.*$", re.IGNORECASE)
+_NOISE_PREPRINT_RE = re.compile(
+    r"[,\s]+(?:preprint|extended\s+version|technical\s+report|working\s+paper)\b.*$",
+    re.IGNORECASE,
+)
+_NOISE_TRAILING_YEAR_RE = re.compile(r"\s*[,(]\s*\d{4}\s*[),]?\s*$")
+# Strips ". Capitalised sentence" appended as venue: ". Comput. Sci…", ". Journal of…"
+_NOISE_VENUE_SENTENCE_RE = re.compile(r"(?<=\w{3})\.\s+[A-Z][a-z].*$")
+
+_CANONICAL_DEDUP_THRESHOLD = 0.82
+
 
 def normalize_title(value: str) -> str:
     lowered = value.lower()
     return TITLE_ALNUM_RE.sub("", lowered)
 
 
+def canonical_title_for_dedup(title: str) -> str:
+    """Strip Scholar-specific noise suffixes then normalize for dedup comparison."""
+    t = title.strip()
+    t = _NOISE_DOI_RE.sub("", t)
+    t = _NOISE_ARXIV_RE.sub("", t)
+    t = _NOISE_PREPRINT_RE.sub("", t)
+    t = _NOISE_TRAILING_YEAR_RE.sub("", t)
+    t = _NOISE_VENUE_SENTENCE_RE.sub("", t)
+    return normalize_title(t.strip())
+
+
+def _stripped_title_for_canonical(title: str) -> str:
+    """Apply noise-stripping and lowercase but PRESERVE spaces (for later tokenization)."""
+    t = title.strip()
+    t = _NOISE_DOI_RE.sub("", t)
+    t = _NOISE_ARXIV_RE.sub("", t)
+    t = _NOISE_PREPRINT_RE.sub("", t)
+    t = _NOISE_TRAILING_YEAR_RE.sub("", t)
+    t = _NOISE_VENUE_SENTENCE_RE.sub("", t)
+    return t.lower().strip()
+
+
+def _canonical_title_tokens(title: str) -> set[str]:
+    """Word tokens of the noise-stripped title (preserves token boundaries)."""
+    return set(WORD_RE.findall(_stripped_title_for_canonical(title)))
+
+
+def _jaccard(a: set[str], b: set[str]) -> float:
+    if not a or not b:
+        return 0.0
+    return len(a & b) / len(a | b)
+
+
 def _first_author_last_name(authors_text: str | None) -> str:
     if not authors_text:
         return ""
@@ -100,31 +147,91 @@ def _next_cstart_value(*, articles_range: str | None, fallback: int) -> int:
     return int(fallback)
 
 
+def _title_tokens(value: str) -> set[str]:
+    """Extract normalized word tokens for fuzzy title comparison."""
+    return set(WORD_RE.findall(value.lower()))
+
+
+def fuzzy_titles_match(
+    title_a: str,
+    title_b: str,
+    *,
+    threshold: float = 0.85,
+) -> bool:
+    """Return True if two titles are near-duplicates by token-level Jaccard similarity.
+
+    A threshold of 0.85 catches common academic duplicate patterns:
+    differences in punctuation, minor word variations, subtitle changes.
+    """
+    tokens_a = _title_tokens(title_a)
+    tokens_b = _title_tokens(title_b)
+    return _jaccard(tokens_a, tokens_b) >= threshold
+
+
 def _dedupe_publication_candidates(
     publications: list[PublicationCandidate],
+    *,
+    seen_canonical: set[str] | None = None,
 ) -> list[PublicationCandidate]:
+    """Deduplicate candidates using canonical title matching.
+
+    Args:
+        publications: candidates to filter
+        seen_canonical: optional mutable set shared across pages.  Stores the
+            noise-stripped *lowercased* (but space-preserved) canonical string
+            so it can be tokenized on the next page for cross-page fuzzy dedup.
+            Accepted canonicals are added; existing entries are consulted.
+    """
     deduped: list[PublicationCandidate] = []
-    seen: set[str] = set()
-    for publication in publications:
-        if publication.cluster_id:
-            identity = f"cluster:{publication.cluster_id}"
-        else:
-            identity = "|".join(
-                [
-                    "fallback",
-                    normalize_title(publication.title),
-                    str(publication.year) if publication.year is not None else "",
-                    publication.authors_text or "",
-                    publication.venue_text or "",
-                ]
-            )
-        if identity in seen:
+    seen_exact: set[str] = set()
+    # Token sets for fuzzy comparison; seeded from cross-page state.
+    seen_tokens: list[set[str]] = []
+
+    if seen_canonical:
+        for stripped in seen_canonical:
+            seen_tokens.append(set(WORD_RE.findall(stripped)))
+
+    for pub in publications:
+        identity = _publication_identity(pub)
+        if identity in seen_exact:
             continue
-        seen.add(identity)
-        deduped.append(publication)
+
+        # Use space-preserving stripped form for token-level fuzzy match.
+        tokens = _canonical_title_tokens(pub.title)
+        if _is_fuzzy_dup(tokens, seen_tokens):
+            continue
+
+        seen_exact.add(identity)
+        seen_tokens.append(tokens)
+        if seen_canonical is not None:
+            # Store the noise-stripped lowercased (space-preserved) form.
+            seen_canonical.add(_stripped_title_for_canonical(pub.title))
+        deduped.append(pub)
+
     return deduped
 
 
+def _publication_identity(pub: PublicationCandidate) -> str:
+    if pub.cluster_id:
+        return f"cluster:{pub.cluster_id}"
+    canonical = canonical_title_for_dedup(pub.title)
+    return "|".join(
+        [
+            "fallback",
+            canonical,
+            str(pub.year) if pub.year is not None else "",
+            _first_author_last_name(pub.authors_text),
+        ]
+    )
+
+
+def _is_fuzzy_dup(tokens: set[str], seen: list[set[str]]) -> bool:
+    for existing in seen:
+        if _jaccard(tokens, existing) >= _CANONICAL_DEDUP_THRESHOLD:
+            return True
+    return False
+
+
 def _build_body_excerpt(body: str, *, max_chars: int = 220) -> str | None:
     if not body:
         return None
diff --git a/app/services/domains/ingestion/scheduler.py b/app/services/domains/ingestion/scheduler.py
index 9db0204..b05e84d 100644
--- a/app/services/domains/ingestion/scheduler.py
+++ b/app/services/domains/ingestion/scheduler.py
@@ -146,6 +146,9 @@ class SchedulerService:
     async def _tick_once(self) -> None:
         if self._continuation_queue_enabled:
             await self._drain_continuation_queue()
+        
+        await self._drain_pdf_queue()
+
         candidates = await self._load_candidates()
         if not candidates:
             return
@@ -488,6 +491,8 @@ class SchedulerService:
                     request_delay_seconds=request_delay_seconds,
                     network_error_retries=self._network_error_retries,
                     retry_backoff_seconds=self._retry_backoff_seconds,
+                    rate_limit_retries=settings.ingestion_rate_limit_retries,
+                    rate_limit_backoff_seconds=settings.ingestion_rate_limit_backoff_seconds,
                     max_pages_per_scholar=self._max_pages_per_scholar,
                     page_size=self._page_size,
                     scholar_profile_ids={job.scholar_profile_id},
@@ -583,6 +588,27 @@ class SchedulerService:
             return
         await self._finalize_queue_job_after_run(job, run_summary)
 
+    async def _drain_pdf_queue(self) -> None:
+        from app.services.domains.publications.pdf_queue import drain_ready_jobs
+        
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            try:
+                processed = await drain_ready_jobs(
+                    session,
+                    limit=settings.scheduler_pdf_queue_batch_size,
+                    max_attempts=settings.pdf_auto_retry_max_attempts,
+                )
+                if processed > 0:
+                    logger.info("scheduler.pdf_queue_drain_completed", extra={
+                        "event": "scheduler.pdf_queue_drain_completed",
+                        "processed_count": processed,
+                    })
+            except Exception:
+                logger.exception("scheduler.pdf_queue_drain_failed", extra={
+                    "event": "scheduler.pdf_queue_drain_failed",
+                })
+
     async def _load_request_delay_for_user(
         self,
         db_session: AsyncSession,
diff --git a/app/services/domains/ingestion/types.py b/app/services/domains/ingestion/types.py
index f6de578..09d87f1 100644
--- a/app/services/domains/ingestion/types.py
+++ b/app/services/domains/ingestion/types.py
@@ -35,6 +35,7 @@ class PagedParseResult:
     pagination_truncated_reason: str | None
     continuation_cstart: int | None
     skipped_no_change: bool
+    discovered_publication_count: int
 
 
 @dataclass
@@ -88,6 +89,7 @@ class PagedLoopState:
     has_more_remaining: bool = False
     pagination_truncated_reason: str | None = None
     continuation_cstart: int | None = None
+    discovered_publication_count: int = 0
 
 
 class RunAlreadyInProgressError(RuntimeError):
diff --git a/app/services/domains/openalex/__init__.py b/app/services/domains/openalex/__init__.py
new file mode 100644
index 0000000..a51555a
--- /dev/null
+++ b/app/services/domains/openalex/__init__.py
@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
diff --git a/app/services/domains/openalex/client.py b/app/services/domains/openalex/client.py
new file mode 100644
index 0000000..a85b630
--- /dev/null
+++ b/app/services/domains/openalex/client.py
@@ -0,0 +1,151 @@
+import asyncio
+import logging
+from typing import Any, Mapping
+
+import httpx
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from app.services.domains.openalex.types import OpenAlexWork
+
+logger = logging.getLogger(__name__)
+
+OPENALEX_BASE_URL = "https://api.openalex.org"
+
+
+class OpenAlexClientError(Exception):
+    pass
+
+
+class OpenAlexRateLimitError(OpenAlexClientError):
+    """Transient rate limit (too many requests per second)."""
+    pass
+
+
+class OpenAlexBudgetExhaustedError(OpenAlexClientError):
+    """Daily API budget exhausted — retrying is futile until midnight UTC."""
+    pass
+
+
+class OpenAlexClient:
+    def __init__(
+        self,
+        api_key: str | None = None,
+        mailto: str | None = None,
+        timeout: float = 10.0,
+    ) -> None:
+        self.api_key = api_key
+        self.mailto = mailto
+        self.timeout = timeout
+
+    @property
+    def _base_params(self) -> dict[str, str]:
+        params = {}
+        if self.mailto:
+            params["mailto"] = self.mailto
+        if self.api_key:
+            params["api_key"] = self.api_key
+        return params
+
+    @retry(
+        retry=retry_if_exception_type((httpx.NetworkError, httpx.TimeoutException)),
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        reraise=True,
+    )
+    async def get_work_by_doi(self, doi: str) -> OpenAlexWork | None:
+        """Fetch a single work by DOI directly."""
+        clean_doi = doi.replace("https://doi.org/", "")
+        if not clean_doi:
+            return None
+
+        url = f"{OPENALEX_BASE_URL}/works/{clean_doi}"
+        
+        headers = {}
+        if self.mailto:
+            headers["User-Agent"] = f"scholar-scraper/1.0 (mailto:{self.mailto})"
+        else:
+            headers["User-Agent"] = "scholar-scraper/1.0"
+
+        async with httpx.AsyncClient(timeout=self.timeout, follow_redirects=True, headers=headers) as client:
+            response = await client.get(url, params=self._base_params)
+
+        if response.status_code == 404:
+            return None
+        if response.status_code == 429:
+            remaining = response.headers.get("X-RateLimit-Remaining-USD", "")
+            if remaining == "0" or remaining.startswith("-"):
+                raise OpenAlexBudgetExhaustedError(
+                    "Daily API budget exhausted; retrying won't help until midnight UTC"
+                )
+            raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex work by DOI")
+        if response.status_code >= 400:
+            logger.warning("OpenAlex API error: %s %s", response.status_code, response.text)
+            raise OpenAlexClientError(f"API Error {response.status_code}")
+
+        data = response.json()
+        return OpenAlexWork.from_api_dict(data)
+
+    @retry(
+        retry=retry_if_exception_type((httpx.NetworkError, httpx.TimeoutException)),
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        reraise=True,
+    )
+    async def get_works_by_filter(
+        self,
+        filters: dict[str, str],
+        limit: int = 50,
+    ) -> list[OpenAlexWork]:
+        """
+        Fetch works using the ?filter= query parameter.
+        Supports fetching multiple records by joining filters with | (OR logic).
+        """
+        if not filters:
+            return []
+
+        # Example: {"doi": "10.foo|10.bar", "title.search": "query"}
+        filter_str = ",".join(f"{k}:{v}" for k, v in filters.items())
+        
+        params = self._base_params.copy()
+        params["filter"] = filter_str
+        params["per-page"] = str(limit)
+
+        url = f"{OPENALEX_BASE_URL}/works"
+        
+        headers = {}
+        if self.mailto:
+            headers["User-Agent"] = f"scholar-scraper/1.0 (mailto:{self.mailto})"
+        else:
+            headers["User-Agent"] = "scholar-scraper/1.0"
+
+        async with httpx.AsyncClient(timeout=self.timeout, follow_redirects=True, headers=headers) as client:
+            response = await client.get(url, params=params)
+
+        if response.status_code == 429:
+            remaining = response.headers.get("X-RateLimit-Remaining-USD", "")
+            if remaining == "0" or remaining.startswith("-"):
+                raise OpenAlexBudgetExhaustedError(
+                    "Daily API budget exhausted; retrying won't help until midnight UTC"
+                )
+            raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex works list")
+        if response.status_code >= 400:
+            logger.warning("OpenAlex API error (filters=%s): %s %s", filters, response.status_code, response.text)
+            raise OpenAlexClientError(f"API Error {response.status_code}")
+
+        data = response.json()
+        results = data.get("results") or []
+        
+        parsed_works = []
+        for raw_work in results:
+            try:
+                parsed_works.append(OpenAlexWork.from_api_dict(raw_work))
+            except Exception as e:
+                logger.warning("Failed to parse OpenAlex raw dict: %s", e)
+                continue
+
+        return parsed_works
diff --git a/app/services/domains/openalex/matching.py b/app/services/domains/openalex/matching.py
new file mode 100644
index 0000000..cfa511c
--- /dev/null
+++ b/app/services/domains/openalex/matching.py
@@ -0,0 +1,108 @@
+import logging
+import re
+
+from rapidfuzz import fuzz
+
+from app.services.domains.openalex.types import OpenAlexWork
+
+logger = logging.getLogger(__name__)
+
+# A minimum similarity score out of 100 for a title to be considered a match candidate.
+TITLE_MATCH_THRESHOLD = 90.0
+# The margin within the top score where a secondary tiebreaker (author/year) is necessary.
+TIEBREAKER_MARGIN = 5.0
+
+
+def _clean_string(s: str | None) -> str:
+    if not s:
+        return ""
+    # Strip non-alphanumeric (keep spaces), lowercase, and collapse whitespace
+    cleaned = re.sub(r"[^a-z0-9\s]", " ", s.lower())
+    return " ".join(cleaned.split())
+
+
+def _author_overlap_score(target_authors: str | None, candidate_authors: list[str]) -> bool:
+    if not target_authors or not candidate_authors:
+        return False
+    
+    target_clean = _clean_string(target_authors)
+    if not target_clean:
+        return False
+        
+    for candidate in candidate_authors:
+        cand_clean = _clean_string(candidate)
+        if cand_clean and (cand_clean in target_clean or target_clean in cand_clean):
+            return True
+        # Alternatively check rapidfuzz token_set_ratio
+        if cand_clean and fuzz.token_set_ratio(target_clean, cand_clean) > 80:
+            return True
+            
+    return False
+
+
+def find_best_match(
+    target_title: str,
+    target_year: int | None,
+    target_authors: str | None,
+    candidates: list[OpenAlexWork],
+) -> OpenAlexWork | None:
+    """
+    Finds the best matching OpenAlexWork from a list of candidates, prioritizing title similarity (>90%)
+    with year and author overlap as tiebreakers for close candidates.
+    """
+    if not target_title or not candidates:
+        return None
+
+    clean_target = _clean_string(target_title)
+    if not clean_target:
+        return None
+
+    scored_candidates: list[tuple[float, OpenAlexWork]] = []
+
+    for cand in candidates:
+        if not cand.title:
+            continue
+            
+        clean_cand = _clean_string(cand.title)
+        
+        # Primary sort: string similarity ratio
+        score = fuzz.ratio(clean_target, clean_cand)
+        
+        if score >= TITLE_MATCH_THRESHOLD:
+            scored_candidates.append((score, cand))
+
+    if not scored_candidates:
+        return None
+
+    # Sort descending by score
+    scored_candidates.sort(key=lambda x: x[0], reverse=True)
+    
+    best_score = scored_candidates[0][0]
+    
+    # Extract all candidates within the tiebreaker margin
+    top_scored_candidates = [
+        (score, cand) for score, cand in scored_candidates 
+        if best_score - score <= TIEBREAKER_MARGIN
+    ]
+
+    if len(top_scored_candidates) == 1:
+        return top_scored_candidates[0][1]
+
+    # We have a tie or near-tie. Use year and author overlap to break the tie.
+    # Score candidates: +1 for year match (within 1 year), +1 for author overlap
+    tiebreaker_scores: list[tuple[int, float, OpenAlexWork]] = []
+    
+    for original_score, cand in top_scored_candidates:
+        tb_score = 0
+        if target_year is not None and cand.publication_year is not None:
+            if abs(target_year - cand.publication_year) <= 1:
+                tb_score += 1
+                
+        candidate_author_names = [a.display_name for a in cand.authors if a.display_name]
+        if _author_overlap_score(target_authors, candidate_author_names):
+            tb_score += 1
+            
+        tiebreaker_scores.append((tb_score, original_score, cand))
+        
+    tiebreaker_scores.sort(key=lambda x: (x[0], x[1]), reverse=True)
+    return tiebreaker_scores[0][2]
diff --git a/app/services/domains/openalex/types.py b/app/services/domains/openalex/types.py
new file mode 100644
index 0000000..0d86754
--- /dev/null
+++ b/app/services/domains/openalex/types.py
@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Mapping
+
+
+@dataclass(frozen=True)
+class OpenAlexAuthor:
+    openalex_id: str | None
+    display_name: str | None
+
+
+@dataclass(frozen=True)
+class OpenAlexWork:
+    openalex_id: str
+    doi: str | None
+    pmid: str | None
+    pmcid: str | None
+    title: str | None
+    publication_year: int | None
+    cited_by_count: int
+    is_oa: bool
+    oa_url: str | None
+    authors: list[OpenAlexAuthor] = field(default_factory=list)
+    raw_data: Mapping[str, Any] = field(default_factory=dict, repr=False)
+
+    @classmethod
+    def from_api_dict(cls, data: Mapping[str, Any]) -> OpenAlexWork:
+        ids = data.get("ids") or {}
+        
+        # Extract DOI without the https://doi.org/ prefix
+        doi = ids.get("doi")
+        if doi and doi.startswith("https://doi.org/"):
+            doi = doi[16:]
+            
+        # Extract PMID without the url prefix
+        pmid = ids.get("pmid")
+        if pmid and pmid.startswith("https://pubmed.ncbi.nlm.nih.gov/"):
+            pmid = pmid[32:]
+            
+        # Extract PMCID without the url prefix
+        pmcid = ids.get("pmcid")
+        if pmcid and pmcid.startswith("https://www.ncbi.nlm.nih.gov/pmc/articles/"):
+            pmcid = pmcid[42:]
+
+        open_access = data.get("open_access") or {}
+        
+        authors = []
+        for authorship in data.get("authorships") or []:
+            author_data = authorship.get("author") or {}
+            authors.append(
+                OpenAlexAuthor(
+                    openalex_id=author_data.get("id"),
+                    display_name=author_data.get("display_name"),
+                )
+            )
+
+        return cls(
+            openalex_id=data.get("id", ""),
+            doi=doi,
+            pmid=pmid,
+            pmcid=pmcid,
+            title=data.get("title"),
+            publication_year=data.get("publication_year"),
+            cited_by_count=data.get("cited_by_count", 0),
+            is_oa=bool(open_access.get("is_oa")),
+            oa_url=open_access.get("oa_url"),
+            authors=authors,
+            raw_data=dict(data),
+        )
diff --git a/app/services/domains/portability/exporting.py b/app/services/domains/portability/exporting.py
index ef43a89..5c89006 100644
--- a/app/services/domains/portability/exporting.py
+++ b/app/services/domains/portability/exporting.py
@@ -34,7 +34,6 @@ def _serialize_export_publication(row: tuple[Any, ...]) -> dict[str, Any]:
         author_text,
         venue_text,
         pub_url,
-        doi,
         pdf_url,
         is_read,
     ) = row
@@ -48,7 +47,6 @@ def _serialize_export_publication(row: tuple[Any, ...]) -> dict[str, Any]:
         "author_text": author_text,
         "venue_text": venue_text,
         "pub_url": pub_url,
-        "doi": doi,
         "pdf_url": pdf_url,
         "is_read": bool(is_read),
     }
@@ -75,7 +73,6 @@ async def export_user_data(
             Publication.author_text,
             Publication.venue_text,
             Publication.pub_url,
-            Publication.doi,
             Publication.pdf_url,
             ScholarPublication.is_read,
         )
diff --git a/app/services/domains/portability/publication_import.py b/app/services/domains/portability/publication_import.py
index daa1d5d..7654586 100644
--- a/app/services/domains/portability/publication_import.py
+++ b/app/services/domains/portability/publication_import.py
@@ -71,7 +71,6 @@ def _apply_imported_publication_values(
     author_text: str | None,
     venue_text: str | None,
     pub_url: str | None,
-    doi: str | None,
     pdf_url: str | None,
     cluster_id: str | None,
 ) -> bool:
@@ -98,9 +97,6 @@ def _apply_imported_publication_values(
     if pub_url and publication.pub_url != pub_url:
         publication.pub_url = pub_url
         updated = True
-    if doi and publication.doi != doi:
-        publication.doi = doi
-        updated = True
     if pdf_url and publication.pdf_url != pdf_url:
         publication.pdf_url = pdf_url
         updated = True
@@ -117,7 +113,6 @@ def _new_publication(
     author_text: str | None,
     venue_text: str | None,
     pub_url: str | None,
-    doi: str | None,
     pdf_url: str | None,
 ) -> Publication:
     return Publication(
@@ -130,7 +125,6 @@ def _new_publication(
         author_text=author_text,
         venue_text=venue_text,
         pub_url=pub_url,
-        doi=doi,
         pdf_url=pdf_url,
     )
 
@@ -285,7 +279,6 @@ async def _create_import_publication(
         author_text=payload.author_text,
         venue_text=payload.venue_text,
         pub_url=payload.pub_url,
-        doi=payload.doi,
         pdf_url=payload.pdf_url,
     )
     db_session.add(publication)
@@ -306,7 +299,6 @@ def _update_import_publication(
         author_text=payload.author_text,
         venue_text=payload.venue_text,
         pub_url=payload.pub_url,
-        doi=payload.doi,
         pdf_url=payload.pdf_url,
         cluster_id=payload.cluster_id,
     )
diff --git a/app/services/domains/publication_identifiers/application.py b/app/services/domains/publication_identifiers/application.py
index d34e757..ca57d57 100644
--- a/app/services/domains/publication_identifiers/application.py
+++ b/app/services/domains/publication_identifiers/application.py
@@ -21,7 +21,7 @@ from app.services.domains.publication_identifiers.types import (
 
 if TYPE_CHECKING:
     from app.services.domains.publications.pdf_queue import PdfQueueListItem
-    from app.services.domains.publications.types import PublicationListItem
+    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
 
 CONFIDENCE_HIGH = 0.98
 CONFIDENCE_MEDIUM = 0.9
@@ -117,9 +117,76 @@ async def sync_identifiers_for_publication_fields(
     await _upsert_publication_candidates(db_session, publication_id=int(publication.id), candidates=candidates)
 
 
+async def discover_and_sync_identifiers_for_publication(
+    db_session: AsyncSession,
+    *,
+    publication: Publication,
+    scholar_label: str,
+) -> None:
+    await sync_identifiers_for_publication_fields(db_session, publication=publication)
+    
+    existing_doi = await _existing_identifier_by_kind(
+        db_session,
+        publication_id=int(publication.id),
+        kind=IdentifierKind.DOI.value,
+    )
+    if existing_doi is not None:
+        return
+
+    from app.services.domains.crossref import application as crossref_service
+    from app.services.domains.publications.types import UnreadPublicationItem
+    
+    item = UnreadPublicationItem(
+        publication_id=int(publication.id),
+        scholar_profile_id=0,
+        scholar_label=scholar_label,
+        title=str(publication.title_raw or ""),
+        year=publication.year,
+        citation_count=publication.citation_count,
+        venue_text=publication.venue_text,
+        pub_url=publication.pub_url,
+        pdf_url=publication.pdf_url,
+    )
+    
+    discovered_doi = await crossref_service.discover_doi_for_publication(item=item)
+    if discovered_doi:
+        normalized_doi = normalize_doi(discovered_doi)
+        if normalized_doi:
+            candidate = _candidate(
+                IdentifierKind.DOI,
+                discovered_doi,
+                normalized_doi,
+                "crossref_api",
+                CONFIDENCE_MEDIUM,
+                None,
+            )
+            await _upsert_publication_candidate(db_session, publication_id=int(publication.id), candidate=candidate)
+
+    existing_arxiv = await _existing_identifier_by_kind(
+        db_session,
+        publication_id=int(publication.id),
+        kind=IdentifierKind.ARXIV.value,
+    )
+    if existing_arxiv is None:
+        from app.services.domains.arxiv import application as arxiv_service
+        discovered_arxiv = await arxiv_service.discover_arxiv_id_for_publication(item=item)
+        if discovered_arxiv:
+            normalized_arxiv = normalize_arxiv_id(discovered_arxiv)
+            if normalized_arxiv:
+                candidate = _candidate(
+                    IdentifierKind.ARXIV,
+                    discovered_arxiv,
+                    normalized_arxiv,
+                    "arxiv_api",
+                    CONFIDENCE_MEDIUM,
+                    None,
+                )
+                await _upsert_publication_candidate(db_session, publication_id=int(publication.id), candidate=candidate)
+
+
 def _publication_field_candidates(publication: Publication) -> list[IdentifierCandidate]:
     return _fallback_candidates_from_values(
-        doi=publication.doi,
+        doi=None,
         pub_url=publication.pub_url,
         pdf_url=publication.pdf_url,
     )
@@ -194,6 +261,21 @@ async def _existing_identifier(
     return result.scalar_one_or_none()
 
 
+async def _existing_identifier_by_kind(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    kind: str,
+) -> PublicationIdentifier | None:
+    result = await db_session.execute(
+        select(PublicationIdentifier).where(
+            PublicationIdentifier.publication_id == publication_id,
+            PublicationIdentifier.kind == kind,
+        ).order_by(PublicationIdentifier.confidence_score.desc()).limit(1)
+    )
+    return result.scalar_one_or_none()
+
+
 def _new_identifier_row(
     *,
     publication_id: int,
@@ -234,7 +316,7 @@ def _overlay_publication_item(
     item: PublicationListItem,
     display_identifier: DisplayIdentifier | None,
 ) -> PublicationListItem:
-    fallback = display_identifier or derive_display_identifier_from_values(doi=item.doi, pub_url=item.pub_url, pdf_url=item.pdf_url)
+    fallback = display_identifier or derive_display_identifier_from_values(doi=None, pub_url=item.pub_url, pdf_url=item.pdf_url)
     return replace(item, display_identifier=fallback)
 
 
@@ -253,7 +335,7 @@ def _overlay_queue_item(
     item: PdfQueueListItem,
     display_identifier: DisplayIdentifier | None,
 ) -> PdfQueueListItem:
-    fallback = display_identifier or derive_display_identifier_from_values(doi=item.doi, pdf_url=item.pdf_url)
+    fallback = display_identifier or derive_display_identifier_from_values(doi=None, pdf_url=item.pdf_url)
     return replace(item, display_identifier=fallback)
 
 
diff --git a/app/services/domains/publication_identifiers/normalize.py b/app/services/domains/publication_identifiers/normalize.py
index 50036be..9f7484a 100644
--- a/app/services/domains/publication_identifiers/normalize.py
+++ b/app/services/domains/publication_identifiers/normalize.py
@@ -7,7 +7,7 @@ from app.services.domains.doi.normalize import normalize_doi
 from app.services.domains.publication_identifiers.types import IdentifierKind
 
 ARXIV_ABS_RE = re.compile(r"\barxiv:\s*([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?\b", re.I)
-ARXIV_PATH_RE = re.compile(r"^/(?:abs|pdf)/([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?(?:\.pdf)?/?$", re.I)
+ARXIV_PATH_RE = re.compile(r"^/(?:abs|pdf|html|ps|format)/([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?(?:\.pdf)?/?$", re.I)
 PMCID_RE = re.compile(r"\b(PMC\d+)\b", re.I)
 PUBMED_PATH_RE = re.compile(r"^/(\d+)/?$")
 
diff --git a/app/services/domains/publications/application.py b/app/services/domains/publications/application.py
index b1161fb..f51c79a 100644
--- a/app/services/domains/publications/application.py
+++ b/app/services/domains/publications/application.py
@@ -24,7 +24,7 @@ from app.services.domains.publications.modes import (
     resolve_publication_view_mode,
 )
 from app.services.domains.publications.queries import (
-    get_latest_completed_run_id_for_user,
+    get_latest_run_id_for_user,
     get_publication_item_for_user,
     publications_query,
 )
@@ -50,7 +50,7 @@ __all__ = [
     "PublicationListItem",
     "UnreadPublicationItem",
     "resolve_publication_view_mode",
-    "get_latest_completed_run_id_for_user",
+    "get_latest_run_id_for_user",
     "publications_query",
     "get_publication_item_for_user",
     "list_for_user",
diff --git a/app/services/domains/publications/counts.py b/app/services/domains/publications/counts.py
index 8f65172..51a524d 100644
--- a/app/services/domains/publications/counts.py
+++ b/app/services/domains/publications/counts.py
@@ -1,6 +1,8 @@
 from __future__ import annotations
 
-from sqlalchemy import func, select
+from datetime import datetime
+
+from sqlalchemy import distinct, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import ScholarProfile, ScholarPublication
@@ -10,7 +12,7 @@ from app.services.domains.publications.modes import (
     MODE_UNREAD,
     resolve_publication_view_mode,
 )
-from app.services.domains.publications.queries import get_latest_completed_run_id_for_user
+from app.services.domains.publications.queries import get_latest_run_id_for_user
 
 
 async def count_for_user(
@@ -20,11 +22,12 @@ async def count_for_user(
     mode: str = MODE_ALL,
     scholar_profile_id: int | None = None,
     favorite_only: bool = False,
+    snapshot_before: datetime | None = None,
 ) -> int:
     resolved_mode = resolve_publication_view_mode(mode)
-    latest_run_id = await get_latest_completed_run_id_for_user(db_session, user_id=user_id)
+    latest_run_id = await get_latest_run_id_for_user(db_session, user_id=user_id)
     stmt = (
-        select(func.count())
+        select(func.count(distinct(ScholarPublication.publication_id)))
         .select_from(ScholarPublication)
         .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
         .where(ScholarProfile.user_id == user_id)
@@ -33,6 +36,8 @@ async def count_for_user(
         stmt = stmt.where(ScholarProfile.id == scholar_profile_id)
     if favorite_only:
         stmt = stmt.where(ScholarPublication.is_favorite.is_(True))
+    if snapshot_before is not None:
+        stmt = stmt.where(ScholarPublication.created_at <= snapshot_before)
     if resolved_mode == MODE_UNREAD:
         stmt = stmt.where(ScholarPublication.is_read.is_(False))
     if resolved_mode == MODE_LATEST:
@@ -49,6 +54,7 @@ async def count_unread_for_user(
     user_id: int,
     scholar_profile_id: int | None = None,
     favorite_only: bool = False,
+    snapshot_before: datetime | None = None,
 ) -> int:
     return await count_for_user(
         db_session,
@@ -56,6 +62,7 @@ async def count_unread_for_user(
         mode=MODE_UNREAD,
         scholar_profile_id=scholar_profile_id,
         favorite_only=favorite_only,
+        snapshot_before=snapshot_before,
     )
 
 
@@ -65,6 +72,7 @@ async def count_latest_for_user(
     user_id: int,
     scholar_profile_id: int | None = None,
     favorite_only: bool = False,
+    snapshot_before: datetime | None = None,
 ) -> int:
     return await count_for_user(
         db_session,
@@ -72,6 +80,7 @@ async def count_latest_for_user(
         mode=MODE_LATEST,
         scholar_profile_id=scholar_profile_id,
         favorite_only=favorite_only,
+        snapshot_before=snapshot_before,
     )
 
 
@@ -80,6 +89,7 @@ async def count_favorite_for_user(
     *,
     user_id: int,
     scholar_profile_id: int | None = None,
+    snapshot_before: datetime | None = None,
 ) -> int:
     return await count_for_user(
         db_session,
@@ -87,4 +97,5 @@ async def count_favorite_for_user(
         mode=MODE_ALL,
         scholar_profile_id=scholar_profile_id,
         favorite_only=True,
+        snapshot_before=snapshot_before,
     )
diff --git a/app/services/domains/publications/dedup.py b/app/services/domains/publications/dedup.py
new file mode 100644
index 0000000..8f3c7b7
--- /dev/null
+++ b/app/services/domains/publications/dedup.py
@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import logging
+
+from sqlalchemy import delete, select
+from sqlalchemy.orm import aliased
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import Publication, PublicationIdentifier, ScholarPublication
+
+logger = logging.getLogger(__name__)
+
+
+async def find_identifier_duplicate_pairs(
+    db_session: AsyncSession,
+) -> list[tuple[int, int]]:
+    """Return (winner_id, dup_id) pairs where two publications share the same identifier.
+
+    Winner is always the lower publication_id (earlier-created). Uses the existing
+    ix_publication_identifiers_kind_value index for the self-join.
+    """
+    pi1 = aliased(PublicationIdentifier, name="pi1")
+    pi2 = aliased(PublicationIdentifier, name="pi2")
+    rows = await db_session.execute(
+        select(pi1.publication_id, pi2.publication_id)
+        .join(
+            pi2,
+            (pi1.kind == pi2.kind)
+            & (pi1.value_normalized == pi2.value_normalized)
+            & (pi1.publication_id < pi2.publication_id),
+        )
+        .distinct()
+    )
+    return [(winner_id, dup_id) for winner_id, dup_id in rows]
+
+
+async def merge_duplicate_publication(
+    db_session: AsyncSession,
+    *,
+    winner_id: int,
+    dup_id: int,
+) -> None:
+    """Merge dup_id into winner_id: migrate scholar links, then delete the dup."""
+    await _migrate_scholar_links(db_session, winner_id=winner_id, dup_id=dup_id)
+    await db_session.execute(
+        delete(Publication).where(Publication.id == dup_id)
+    )
+    logger.info(
+        "publications.identifier_merge",
+        extra={
+            "event": "publications.identifier_merge",
+            "winner_id": winner_id,
+            "dup_id": dup_id,
+        },
+    )
+
+
+async def _migrate_scholar_links(
+    db_session: AsyncSession,
+    *,
+    winner_id: int,
+    dup_id: int,
+) -> None:
+    """Move ScholarPublication links from dup to winner, dropping conflicts."""
+    dup_links_result = await db_session.execute(
+        select(ScholarPublication).where(ScholarPublication.publication_id == dup_id)
+    )
+    dup_links = dup_links_result.scalars().all()
+
+    winner_profiles_result = await db_session.execute(
+        select(ScholarPublication.scholar_profile_id).where(
+            ScholarPublication.publication_id == winner_id
+        )
+    )
+    winner_profiles: set[int] = {row for (row,) in winner_profiles_result}
+
+    for link in dup_links:
+        if link.scholar_profile_id in winner_profiles:
+            await db_session.delete(link)
+        else:
+            link.publication_id = winner_id
+
+
+async def sweep_identifier_duplicates(db_session: AsyncSession) -> int:
+    """Find publications sharing an identifier and merge duplicates into the winner.
+
+    Returns the number of duplicate publications removed.
+    """
+    pairs = await find_identifier_duplicate_pairs(db_session)
+    if not pairs:
+        return 0
+
+    # Deduplicate the pairs — a dup may appear multiple times if it shares
+    # several identifiers with the winner; process each dup only once.
+    processed_dups: set[int] = set()
+    for winner_id, dup_id in pairs:
+        if dup_id in processed_dups:
+            continue
+        processed_dups.add(dup_id)
+        await merge_duplicate_publication(db_session, winner_id=winner_id, dup_id=dup_id)
+
+    await db_session.flush()
+    return len(processed_dups)
diff --git a/app/services/domains/publications/listing.py b/app/services/domains/publications/listing.py
index 0d09d4c..5290f6f 100644
--- a/app/services/domains/publications/listing.py
+++ b/app/services/domains/publications/listing.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from datetime import datetime
+
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.services.domains.publication_identifiers import application as identifier_service
@@ -9,7 +11,7 @@ from app.services.domains.publications.modes import (
     resolve_publication_view_mode,
 )
 from app.services.domains.publications.queries import (
-    get_latest_completed_run_id_for_user,
+    get_latest_run_id_for_user,
     get_publication_item_for_user,
     publication_list_item_from_row,
     publications_query,
@@ -25,11 +27,15 @@ async def list_for_user(
     mode: str = MODE_ALL,
     scholar_profile_id: int | None = None,
     favorite_only: bool = False,
-    limit: int = 300,
+    search: str | None = None,
+    sort_by: str = "first_seen",
+    sort_dir: str = "desc",
+    limit: int = 100,
     offset: int = 0,
+    snapshot_before: datetime | None = None,
 ) -> list[PublicationListItem]:
     resolved_mode = resolve_publication_view_mode(mode)
-    latest_run_id = await get_latest_completed_run_id_for_user(db_session, user_id=user_id)
+    latest_run_id = await get_latest_run_id_for_user(db_session, user_id=user_id)
     result = await db_session.execute(
         publications_query(
             user_id=user_id,
@@ -37,8 +43,12 @@ async def list_for_user(
             latest_run_id=latest_run_id,
             scholar_profile_id=scholar_profile_id,
             favorite_only=favorite_only,
+            search=search,
+            sort_by=sort_by,
+            sort_dir=sort_dir,
             limit=limit,
             offset=offset,
+            snapshot_before=snapshot_before,
         )
     )
     rows = [
diff --git a/app/services/domains/publications/pdf_queue.py b/app/services/domains/publications/pdf_queue.py
index 3972f7d..7503138 100644
--- a/app/services/domains/publications/pdf_queue.py
+++ b/app/services/domains/publications/pdf_queue.py
@@ -2,10 +2,10 @@ from __future__ import annotations
 
 import asyncio
 from dataclasses import dataclass
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 import logging
 
-from sqlalchemy import Select, func, literal, or_, select, union_all
+from sqlalchemy import Select, and_, func, literal, or_, select, union_all
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import (
@@ -20,7 +20,6 @@ from app.db.session import get_session_factory
 from app.services.domains.publication_identifiers import application as identifier_service
 from app.services.domains.publication_identifiers.types import DisplayIdentifier
 from app.services.domains.publications.pdf_resolution_pipeline import (
-    PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE,
     resolve_publication_pdf_outcome_for_row,
 )
 from app.services.domains.publications.types import PublicationListItem
@@ -49,7 +48,6 @@ _scheduled_tasks: set[asyncio.Task[None]] = set()
 class PdfQueueListItem:
     publication_id: int
     title: str
-    doi: str | None
     pdf_url: str | None
     status: str
     attempt_count: int
@@ -114,7 +112,6 @@ def _item_from_row_and_job(
         citation_count=row.citation_count,
         venue_text=row.venue_text,
         pub_url=row.pub_url,
-        doi=row.doi,
         pdf_url=row.pdf_url,
         is_read=row.is_read,
         is_favorite=row.is_favorite,
@@ -360,7 +357,7 @@ def _failed_outcome(
 ) -> OaResolutionOutcome:
     return OaResolutionOutcome(
         publication_id=row.publication_id,
-        doi=row.doi,
+        doi=None,
         pdf_url=None,
         failure_reason=FAILURE_RESOLUTION_EXCEPTION,
         source=None,
@@ -372,10 +369,12 @@ async def _fetch_outcome_for_row(
     *,
     row: PublicationListItem,
     request_email: str | None,
+    openalex_api_key: str | None = None,
 ) -> OaResolutionOutcome:
     pipeline_result = await resolve_publication_pdf_outcome_for_row(
         row=row,
         request_email=request_email,
+        openalex_api_key=openalex_api_key,
     )
     outcome = pipeline_result.outcome
     if outcome is not None:
@@ -386,11 +385,8 @@ async def _fetch_outcome_for_row(
 def _apply_publication_update(
     publication: Publication,
     *,
-    doi: str | None,
     pdf_url: str | None,
 ) -> None:
-    if doi and publication.doi != doi:
-        publication.doi = doi
     if pdf_url and publication.pdf_url != pdf_url:
         publication.pdf_url = pdf_url
 
@@ -426,7 +422,7 @@ async def _persist_outcome(
         job = await db_session.get(PublicationPdfJob, publication_id)
         if publication is None or job is None:
             return
-        _apply_publication_update(publication, doi=outcome.doi, pdf_url=outcome.pdf_url)
+        _apply_publication_update(publication, pdf_url=outcome.pdf_url)
         await identifier_service.sync_identifiers_for_publication_resolution(
             db_session,
             publication=publication,
@@ -453,10 +449,26 @@ async def _resolve_publication_row(
     user_id: int,
     request_email: str | None,
     row: PublicationListItem,
+    openalex_api_key: str | None = None,
 ) -> None:
+    from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
+    from app.services.domains.arxiv.application import ArxivRateLimitError
     await _mark_attempt_started(publication_id=row.publication_id, user_id=user_id)
     try:
-        outcome = await _fetch_outcome_for_row(row=row, request_email=request_email)
+        outcome = await _fetch_outcome_for_row(
+            row=row,
+            request_email=request_email,
+            openalex_api_key=openalex_api_key,
+        )
+    except (OpenAlexBudgetExhaustedError, ArxivRateLimitError):
+        # Persist a terminal outcome so jobs do not remain stuck in "running".
+        await _persist_outcome(
+            publication_id=row.publication_id,
+            user_id=user_id,
+            outcome=_failed_outcome(row=row),
+        )
+        # Propagate upward so the batch loop can stop immediately.
+        raise
     except Exception as exc:  # pragma: no cover - defensive network boundary
         logger.warning(
             "publications.pdf_queue.resolve_failed",
@@ -480,12 +492,44 @@ async def _run_resolution_task(
     request_email: str | None,
     rows: list[PublicationListItem],
 ) -> None:
+    from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
+    from app.services.domains.arxiv.application import ArxivRateLimitError
+    from app.services.domains.settings import application as user_settings_service
+
+    # Resolve the best available API key: per-user setting → env var fallback.
+    openalex_api_key: str | None = None
+    try:
+        session_factory = get_session_factory()
+        async with session_factory() as key_session:
+            user_settings = await user_settings_service.get_or_create_settings(key_session, user_id=user_id)
+            openalex_api_key = getattr(user_settings, "openalex_api_key", None) or settings.openalex_api_key
+    except Exception:
+        openalex_api_key = settings.openalex_api_key
+
     for row in rows:
-        await _resolve_publication_row(
-            user_id=user_id,
-            request_email=request_email,
-            row=row,
-        )
+        try:
+            await _resolve_publication_row(
+                user_id=user_id,
+                request_email=request_email,
+                row=row,
+                openalex_api_key=openalex_api_key,
+            )
+        except OpenAlexBudgetExhaustedError:
+            logger.warning(
+                "publications.pdf_queue.budget_exhausted",
+                extra={"event": "publications.pdf_queue.budget_exhausted",
+                       "detail": "Stopping PDF resolution batch — OpenAlex daily budget exhausted"},
+            )
+            break
+        except ArxivRateLimitError:
+            logger.warning(
+                "publications.pdf_queue.arxiv_rate_limited",
+                extra={
+                    "event": "publications.pdf_queue.arxiv_rate_limited",
+                    "detail": "Stopping PDF resolution batch — arXiv rate limit hit (429)",
+                },
+            )
+            break
 
 
 def _schedule_rows(
@@ -571,7 +615,6 @@ def _retry_item_from_publication(
         citation_count=int(publication.citation_count or 0),
         venue_text=publication.venue_text,
         pub_url=publication.pub_url,
-        doi=publication.doi,
         pdf_url=publication.pdf_url,
         is_read=is_read,
         first_seen_at=first_seen_at,
@@ -629,13 +672,12 @@ def _queue_candidate_from_publication(publication: Publication) -> PublicationLi
     return PublicationListItem(
         publication_id=int(publication.id),
         scholar_profile_id=0,
-        scholar_label="admin",
+        scholar_label="",
         title=publication.title_raw,
         year=publication.year,
         citation_count=int(publication.citation_count or 0),
         venue_text=publication.venue_text,
         pub_url=publication.pub_url,
-        doi=publication.doi,
         pdf_url=publication.pdf_url,
         is_read=True,
         first_seen_at=publication.created_at or _utcnow(),
@@ -649,6 +691,9 @@ async def _missing_pdf_candidates(
     limit: int,
 ) -> list[PublicationListItem]:
     bounded_limit = max(1, min(int(limit), 5000))
+    now = datetime.now(timezone.utc)
+    cooldown_threshold = now - timedelta(days=7)
+
     result = await db_session.execute(
         select(Publication)
         .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
@@ -656,7 +701,13 @@ async def _missing_pdf_candidates(
         .where(
             or_(
                 PublicationPdfJob.publication_id.is_(None),
-                PublicationPdfJob.status.notin_([PDF_STATUS_QUEUED, PDF_STATUS_RUNNING]),
+                and_(
+                    PublicationPdfJob.status.notin_([PDF_STATUS_QUEUED, PDF_STATUS_RUNNING]),
+                    or_(
+                        PublicationPdfJob.last_attempt_at.is_(None),
+                        PublicationPdfJob.last_attempt_at < cooldown_threshold,
+                    ),
+                ),
             )
         )
         .order_by(Publication.updated_at.desc(), Publication.id.desc())
@@ -694,7 +745,6 @@ def _tracked_queue_select_base(*, status: str | None) -> Select[tuple]:
         select(
             PublicationPdfJob.publication_id,
             Publication.title_raw,
-            Publication.doi,
             Publication.pdf_url,
             PublicationPdfJob.status,
             PublicationPdfJob.attempt_count,
@@ -730,7 +780,6 @@ def _untracked_queue_select_base() -> Select[tuple]:
         select(
             Publication.id,
             Publication.title_raw,
-            Publication.doi,
             Publication.pdf_url,
             literal(PDF_STATUS_UNTRACKED),
             literal(0),
@@ -793,19 +842,18 @@ def _queue_item_from_row(row: tuple) -> PdfQueueListItem:
     return PdfQueueListItem(
         publication_id=int(row[0]),
         title=str(row[1] or ""),
-        doi=row[2],
-        pdf_url=row[3],
-        status=str(row[4] or PDF_STATUS_UNTRACKED),
-        attempt_count=int(row[5] or 0),
-        last_failure_reason=row[6],
-        last_failure_detail=row[7],
-        last_source=row[8],
-        requested_by_user_id=int(row[9]) if row[9] is not None else None,
-        requested_by_email=row[10],
-        queued_at=row[11],
-        last_attempt_at=row[12],
-        resolved_at=row[13],
-        updated_at=row[14],
+        pdf_url=row[2],
+        status=str(row[3] or PDF_STATUS_UNTRACKED),
+        attempt_count=int(row[4] or 0),
+        last_failure_reason=row[5],
+        last_failure_detail=row[6],
+        last_source=row[7],
+        requested_by_user_id=int(row[8]) if row[8] is not None else None,
+        requested_by_email=row[9],
+        queued_at=row[10],
+        last_attempt_at=row[11],
+        resolved_at=row[12],
+        updated_at=row[13],
     )
 
 
@@ -902,3 +950,25 @@ async def list_pdf_queue_page(
         limit=bounded_limit,
         offset=bounded_offset,
     )
+
+
+async def drain_ready_jobs(
+    db_session: AsyncSession,
+    *,
+    limit: int,
+    max_attempts: int,
+) -> int:
+    result = await db_session.execute(
+        select(User.id).where(User.is_active.is_(True)).order_by(User.id.asc()).limit(1)
+    )
+    system_user_id = result.scalar_one_or_none()
+    if system_user_id is None:
+        return 0
+
+    bulk_result = await enqueue_all_missing_pdf_jobs(
+        db_session,
+        user_id=system_user_id,
+        request_email=settings.unpaywall_email,
+        limit=limit,
+    )
+    return bulk_result.queued_count
diff --git a/app/services/domains/publications/pdf_resolution_pipeline.py b/app/services/domains/publications/pdf_resolution_pipeline.py
index bc41257..0dc133c 100644
--- a/app/services/domains/publications/pdf_resolution_pipeline.py
+++ b/app/services/domains/publications/pdf_resolution_pipeline.py
@@ -2,100 +2,114 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 import logging
-from urllib.parse import urlparse
-
-import httpx
+from typing import Any
 
+from app.services.domains.arxiv.application import ArxivRateLimitError
+from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
 from app.services.domains.publications.types import PublicationListItem
-from app.services.domains.scholar.publication_pdf import (
-    ScholarPublicationLinkCandidate,
-    ScholarPublicationLinkCandidates,
-    fetch_link_candidates_from_scholar_publication_page,
-)
-from app.services.domains.unpaywall import pdf_discovery as pdf_discovery_service
 from app.services.domains.unpaywall.application import OaResolutionOutcome, resolve_publication_oa_outcomes
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
 
-PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE = "scholar_publication_page"
-PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE_UNLABELED = "scholar_publication_page_unlabeled_fallback"
-PDF_PATH_TOKEN = "/pdf/"
-HTTP_TIMEOUT_FLOOR_SECONDS = 0.5
-
 
 @dataclass(frozen=True)
 class PipelineOutcome:
     outcome: OaResolutionOutcome | None
-    scholar_candidates: ScholarPublicationLinkCandidates | None
+    scholar_candidates: Any | None  # Kept for backward compatibility with calling signatures
 
 
 async def resolve_publication_pdf_outcome_for_row(
     *,
     row: PublicationListItem,
     request_email: str | None,
+    openalex_api_key: str | None = None,
 ) -> PipelineOutcome:
-    candidates = await _safe_scholar_candidates(row.pub_url)
-    labeled = _labeled_candidate(candidates)
-    if labeled is not None:
-        return PipelineOutcome(_scholar_outcome(row=row, candidate=labeled), candidates)
+    # 1. OpenAlex OA — raises OpenAlexBudgetExhaustedError if budget is gone
+    openalex_outcome = await _openalex_outcome(row, request_email=request_email, openalex_api_key=openalex_api_key)
+    if openalex_outcome and openalex_outcome.pdf_url:
+        return PipelineOutcome(openalex_outcome, None)
+
+    # 2. arXiv
+    arxiv_outcome = await _arxiv_outcome(row, request_email=request_email)
+    if arxiv_outcome and arxiv_outcome.pdf_url:
+        return PipelineOutcome(arxiv_outcome, None)
+
+    # 3. Unpaywall (which falls back to Crossref)
     oa_outcome = await _oa_outcome(row=row, request_email=request_email)
-    if _oa_has_pdf(oa_outcome):
-        return PipelineOutcome(oa_outcome, candidates)
-    unlabeled = _unlabeled_candidate(candidates)
-    if unlabeled is None:
-        return PipelineOutcome(oa_outcome, candidates)
-    fallback_outcome = await _unlabeled_fallback_outcome(row=row, candidate=unlabeled)
-    if fallback_outcome is not None:
-        return PipelineOutcome(fallback_outcome, candidates)
-    return PipelineOutcome(oa_outcome, candidates)
+    return PipelineOutcome(oa_outcome, None)
 
 
-async def _safe_scholar_candidates(pub_url: str | None) -> ScholarPublicationLinkCandidates | None:
-    try:
-        return await fetch_link_candidates_from_scholar_publication_page(pub_url)
-    except Exception as exc:  # pragma: no cover - defensive boundary
-        logger.warning(
-            "publications.pdf_resolution.scholar_candidates_failed",
-            extra={"event": "publications.pdf_resolution.scholar_candidates_failed", "error": str(exc)},
-        )
-        return None
-
-
-def _labeled_candidate(
-    candidates: ScholarPublicationLinkCandidates | None,
-) -> ScholarPublicationLinkCandidate | None:
-    if candidates is None:
-        return None
-    return candidates.labeled_candidate
-
-
-def _unlabeled_candidate(
-    candidates: ScholarPublicationLinkCandidates | None,
-) -> ScholarPublicationLinkCandidate | None:
-    if candidates is None:
-        return None
-    return candidates.fallback_candidate
-
-
-def _scholar_outcome(
-    *,
+async def _openalex_outcome(
     row: PublicationListItem,
-    candidate: ScholarPublicationLinkCandidate,
-) -> OaResolutionOutcome:
-    source = (
-        PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE
-        if candidate.label_present
-        else PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE_UNLABELED
-    )
-    return OaResolutionOutcome(
-        publication_id=row.publication_id,
-        doi=row.doi,
-        pdf_url=candidate.url,
-        failure_reason=None,
-        source=source,
-        used_crossref=False,
-    )
+    request_email: str | None,
+    openalex_api_key: str | None = None,
+) -> OaResolutionOutcome | None:
+    from app.services.domains.openalex.client import OpenAlexClient
+    from app.services.domains.openalex.matching import find_best_match
+
+    if not row.title:
+        return None
+
+    import re
+    safe_title = re.sub(r"[^\w\s]", " ", row.title)
+    safe_title = " ".join(safe_title.split())
+    if not safe_title:
+        return None
+
+    api_key = openalex_api_key or settings.openalex_api_key
+    client = OpenAlexClient(api_key=api_key, mailto=request_email or settings.crossref_api_mailto)
+    try:
+        openalex_works = await client.get_works_by_filter({"title.search": safe_title}, limit=5)
+        match = find_best_match(
+            target_title=row.title,
+            target_year=row.year,
+            target_authors=row.scholar_label,
+            candidates=openalex_works,
+        )
+        if match and match.oa_url:
+            return OaResolutionOutcome(
+                publication_id=row.publication_id,
+                doi=match.doi,
+                pdf_url=match.oa_url,
+                failure_reason=None,
+                source="openalex",
+                used_crossref=False,
+            )
+    except OpenAlexBudgetExhaustedError:
+        # Re-raise so the caller's batch loop can stop hitting the API.
+        raise
+    except Exception as exc:
+        logger.warning(
+            "publications.pdf_resolution.openalex_failed",
+            extra={"event": "publications.pdf_resolution.openalex_failed", "error": str(exc)},
+        )
+    return None
+
+
+async def _arxiv_outcome(row: PublicationListItem, request_email: str | None) -> OaResolutionOutcome | None:
+    from app.services.domains.arxiv.application import discover_arxiv_id_for_publication
+
+    try:
+        arxiv_id = await discover_arxiv_id_for_publication(item=row, request_email=request_email)
+        if arxiv_id:
+            pdf_url = f"https://arxiv.org/pdf/{arxiv_id}.pdf"
+            return OaResolutionOutcome(
+                publication_id=row.publication_id,
+                doi=None,
+                pdf_url=pdf_url,
+                failure_reason=None,
+                source="arxiv",
+                used_crossref=False,
+            )
+    except ArxivRateLimitError:
+        raise  # propagate so the batch loop can stop
+    except Exception as exc:
+        logger.warning(
+            "publications.pdf_resolution.arxiv_failed",
+            extra={"event": "publications.pdf_resolution.arxiv_failed", "error": str(exc)},
+        )
+    return None
 
 
 async def _oa_outcome(
@@ -105,46 +119,3 @@ async def _oa_outcome(
 ) -> OaResolutionOutcome | None:
     outcomes = await resolve_publication_oa_outcomes([row], request_email=request_email)
     return outcomes.get(row.publication_id)
-
-
-def _oa_has_pdf(outcome: OaResolutionOutcome | None) -> bool:
-    return bool(outcome and outcome.pdf_url)
-
-
-async def _unlabeled_fallback_outcome(
-    *,
-    row: PublicationListItem,
-    candidate: ScholarPublicationLinkCandidate,
-) -> OaResolutionOutcome | None:
-    pdf_url = await _validated_pdf_url(candidate.url)
-    if pdf_url is None:
-        return None
-    return _scholar_outcome(row=row, candidate=ScholarPublicationLinkCandidate(
-        url=pdf_url,
-        confidence_score=candidate.confidence_score,
-        label_present=False,
-        reason=candidate.reason,
-    ))
-
-
-async def _validated_pdf_url(candidate_url: str) -> str | None:
-    if _looks_direct_pdf(candidate_url):
-        return candidate_url
-    timeout_seconds = _discovery_timeout_seconds()
-    async with httpx.AsyncClient(timeout=timeout_seconds) as client:
-        if await pdf_discovery_service._candidate_is_pdf(client, candidate_url=candidate_url):
-            return candidate_url
-        return await pdf_discovery_service.resolve_pdf_from_landing_page(client, page_url=candidate_url)
-
-
-def _looks_direct_pdf(url: str | None) -> bool:
-    if pdf_discovery_service.looks_like_pdf_url(url):
-        return True
-    if not isinstance(url, str):
-        return False
-    path = (urlparse(url).path or "").lower()
-    return PDF_PATH_TOKEN in path
-
-
-def _discovery_timeout_seconds() -> float:
-    return max(float(settings.unpaywall_timeout_seconds), HTTP_TIMEOUT_FLOOR_SECONDS)
diff --git a/app/services/domains/publications/queries.py b/app/services/domains/publications/queries.py
index 292ec8e..6f57cab 100644
--- a/app/services/domains/publications/queries.py
+++ b/app/services/domains/publications/queries.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from datetime import datetime
+
 from sqlalchemy import Select, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -15,15 +17,24 @@ def _normalized_citation_count(value: object) -> int:
         return 0
 
 
-async def get_latest_completed_run_id_for_user(
+async def get_latest_run_id_for_user(
     db_session: AsyncSession,
     *,
     user_id: int,
 ) -> int | None:
+    # We include RUNNING and RESOLVING statuses so that the "New" tab shows
+    # results in real-time as they are discovered.
     result = await db_session.execute(
         select(func.max(CrawlRun.id)).where(
             CrawlRun.user_id == user_id,
-            CrawlRun.status != RunStatus.RUNNING,
+            CrawlRun.status.in_(
+                [
+                    RunStatus.RUNNING,
+                    RunStatus.RESOLVING,
+                    RunStatus.SUCCESS,
+                    RunStatus.PARTIAL_FAILURE,
+                ]
+            ),
         )
     )
     latest_run_id = result.scalar_one_or_none()
@@ -39,7 +50,19 @@ def publications_query(
     favorite_only: bool,
     limit: int,
     offset: int = 0,
+    search: str | None = None,
+    sort_by: str = "first_seen",
+    sort_dir: str = "desc",
+    snapshot_before: datetime | None = None,
 ) -> Select[tuple]:
+    _SORT_COLUMNS = {
+        "first_seen": ScholarPublication.created_at,
+        "title": Publication.title_raw,
+        "year": Publication.year,
+        "citations": Publication.citation_count,
+        "scholar": ScholarProfile.display_name,
+    }
+
     scholar_label = ScholarProfile.display_name
     stmt = (
         select(
@@ -52,7 +75,6 @@ def publications_query(
             Publication.citation_count,
             Publication.venue_text,
             Publication.pub_url,
-            Publication.doi,
             Publication.pdf_url,
             ScholarPublication.is_read,
             ScholarPublication.is_favorite,
@@ -62,10 +84,15 @@ def publications_query(
         .join(ScholarPublication, ScholarPublication.publication_id == Publication.id)
         .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
         .where(ScholarProfile.user_id == user_id)
-        .order_by(ScholarPublication.created_at.desc(), Publication.id.desc())
-        .offset(max(int(offset), 0))
-        .limit(limit)
     )
+    if search:
+        safe_search = search.replace("%", r"\%").replace("_", r"\_")
+        pat = f"%{safe_search}%"
+        stmt = stmt.where(
+            Publication.title_raw.ilike(pat)
+            | ScholarProfile.display_name.ilike(pat)
+            | Publication.venue_text.ilike(pat)
+        )
     if scholar_profile_id is not None:
         stmt = stmt.where(ScholarProfile.id == scholar_profile_id)
     if favorite_only:
@@ -76,6 +103,16 @@ def publications_query(
         if latest_run_id is None:
             return stmt.where(False)
         stmt = stmt.where(ScholarPublication.first_seen_run_id == latest_run_id)
+    if snapshot_before is not None:
+        stmt = stmt.where(ScholarPublication.created_at <= snapshot_before)
+
+    sort_col = _SORT_COLUMNS.get(sort_by, ScholarPublication.created_at)
+    order = sort_col.desc() if sort_dir == "desc" else sort_col.asc()
+    stmt = stmt.order_by(order, Publication.id.desc())
+
+    if limit is not None:
+        stmt = stmt.offset(max(int(offset), 0)).limit(limit)
+
     return stmt
 
 
@@ -96,7 +133,6 @@ def publication_query_for_user(
             Publication.citation_count,
             Publication.venue_text,
             Publication.pub_url,
-            Publication.doi,
             Publication.pdf_url,
             ScholarPublication.is_read,
             ScholarPublication.is_favorite,
@@ -121,7 +157,7 @@ async def get_publication_item_for_user(
     scholar_profile_id: int,
     publication_id: int,
 ) -> PublicationListItem | None:
-    latest_run_id = await get_latest_completed_run_id_for_user(db_session, user_id=user_id)
+    latest_run_id = await get_latest_run_id_for_user(db_session, user_id=user_id)
     result = await db_session.execute(
         publication_query_for_user(
             user_id=user_id,
@@ -150,7 +186,6 @@ def publication_list_item_from_row(
         citation_count,
         venue_text,
         pub_url,
-        doi,
         pdf_url,
         is_read,
         is_favorite,
@@ -166,7 +201,6 @@ def publication_list_item_from_row(
         citation_count=_normalized_citation_count(citation_count),
         venue_text=venue_text,
         pub_url=pub_url,
-        doi=doi,
         pdf_url=pdf_url,
         is_read=bool(is_read),
         is_favorite=bool(is_favorite),
@@ -188,7 +222,6 @@ def unread_item_from_row(row: tuple) -> UnreadPublicationItem:
         citation_count,
         venue_text,
         pub_url,
-        doi,
         pdf_url,
         _is_read,
         _is_favorite,
@@ -204,6 +237,5 @@ def unread_item_from_row(row: tuple) -> UnreadPublicationItem:
         citation_count=_normalized_citation_count(citation_count),
         venue_text=venue_text,
         pub_url=pub_url,
-        doi=doi,
         pdf_url=pdf_url,
     )
diff --git a/app/services/domains/publications/types.py b/app/services/domains/publications/types.py
index 3bde82d..62d038b 100644
--- a/app/services/domains/publications/types.py
+++ b/app/services/domains/publications/types.py
@@ -16,7 +16,6 @@ class PublicationListItem:
     citation_count: int
     venue_text: str | None
     pub_url: str | None
-    doi: str | None
     pdf_url: str | None
     is_read: bool
     first_seen_at: datetime
@@ -39,5 +38,4 @@ class UnreadPublicationItem:
     citation_count: int
     venue_text: str | None
     pub_url: str | None
-    doi: str | None
     pdf_url: str | None
diff --git a/app/services/domains/runs/events.py b/app/services/domains/runs/events.py
new file mode 100644
index 0000000..ef28069
--- /dev/null
+++ b/app/services/domains/runs/events.py
@@ -0,0 +1,59 @@
+import asyncio
+import json
+import logging
+from typing import Any, AsyncGenerator, Dict, Set
+
+logger = logging.getLogger(__name__)
+
+class RunEventPublisher:
+    def __init__(self) -> None:
+        # Maps run_id to a set of subscriber queues
+        self._subscribers: Dict[int, Set[asyncio.Queue]] = {}
+
+    def subscribe(self, run_id: int) -> asyncio.Queue:
+        if run_id not in self._subscribers:
+            self._subscribers[run_id] = set()
+        queue: asyncio.Queue[Any] = asyncio.Queue()
+        self._subscribers[run_id].add(queue)
+        logger.debug(f"New subscriber for run {run_id}. Total: {len(self._subscribers[run_id])}")
+        return queue
+
+    def unsubscribe(self, run_id: int, queue: asyncio.Queue) -> None:
+        if run_id in self._subscribers:
+            self._subscribers[run_id].discard(queue)
+            if not self._subscribers[run_id]:
+                self._subscribers.pop(run_id, None)
+
+    async def publish(self, run_id: int, event_type: str, data: dict[str, Any]) -> None:
+        if run_id not in self._subscribers:
+            return
+        
+        message = {
+            "type": event_type,
+            "data": data
+        }
+        
+        # Fan-out to all active subscribers for this run
+        for queue in list(self._subscribers[run_id]):
+            try:
+                queue.put_nowait(message)
+            except asyncio.QueueFull:
+                logger.warning(f"Subscriber queue full for run {run_id}, dropping message")
+
+run_events = RunEventPublisher()
+
+async def event_generator(run_id: int) -> AsyncGenerator[str, None]:
+    queue = run_events.subscribe(run_id)
+    try:
+        while True:
+            # Wait for a new event
+            message = await queue.get()
+            # Server-Sent Events format: "event: <type>\ndata: <json>\n\n"
+            event_type = message["type"]
+            data_str = json.dumps(message["data"])
+            yield f"event: {event_type}\ndata: {data_str}\n\n"
+    except asyncio.CancelledError:
+        logger.debug(f"Client disconnected from SSE stream for run {run_id}")
+        raise
+    finally:
+        run_events.unsubscribe(run_id, queue)
diff --git a/app/services/domains/scholar/publication_pdf.py b/app/services/domains/scholar/publication_pdf.py
deleted file mode 100644
index 6f8b6c1..0000000
--- a/app/services/domains/scholar/publication_pdf.py
+++ /dev/null
@@ -1,232 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from html.parser import HTMLParser
-from urllib.parse import parse_qs, urlparse
-
-from app.services.domains.scholar.parser_types import ScholarDomInvariantError
-from app.services.domains.scholar.parser_utils import attr_href, normalize_space
-from app.services.domains.scholar.rate_limit import wait_for_scholar_slot
-from app.services.domains.scholar.source import LiveScholarSource
-from app.services.domains.settings.application import resolve_request_delay_minimum
-from app.settings import settings
-
-CONTAINER_ID = "gsc_oci_title_gg"
-PDF_LABEL_TOKEN = "[pdf]"
-SCHOLAR_PDF_LABELED_CONFIDENCE = 0.98
-SCHOLAR_PDF_UNLABELED_CONFIDENCE = 0.2
-ALLOWED_URL_SCHEMES = frozenset({"http", "https"})
-
-
-@dataclass(frozen=True)
-class ScholarPublicationLinkCandidate:
-    url: str
-    confidence_score: float
-    label_present: bool
-    reason: str
-
-
-@dataclass(frozen=True)
-class ScholarPublicationLinkCandidates:
-    container_seen: bool
-    labeled_candidate: ScholarPublicationLinkCandidate | None
-    fallback_candidate: ScholarPublicationLinkCandidate | None
-    warnings: tuple[str, ...] = ()
-
-
-@dataclass(frozen=True)
-class _ParsedAnchor:
-    href: str | None
-    text: str
-
-
-class _ScholarPublicationPdfParser(HTMLParser):
-    def __init__(self) -> None:
-        super().__init__(convert_charrefs=True)
-        self.container_seen = False
-        self.anchors: list[_ParsedAnchor] = []
-        self._container_depth = 0
-        self._anchor_depth = 0
-        self._anchor_href: str | None = None
-        self._anchor_parts: list[str] = []
-
-    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
-        self._increment_depths()
-        if self._starts_container(tag, attrs):
-            self.container_seen = True
-            self._container_depth = 1
-            return
-        if self._container_depth <= 0 or tag != "a":
-            return
-        if self._anchor_depth > 0:
-            return
-        self._anchor_href = attr_href(attrs)
-        self._anchor_parts = []
-        self._anchor_depth = 1
-
-    def handle_data(self, data: str) -> None:
-        if self._anchor_depth > 0:
-            self._anchor_parts.append(data)
-
-    def handle_endtag(self, tag: str) -> None:
-        if self._anchor_depth > 0:
-            self._anchor_depth -= 1
-            if self._anchor_depth == 0:
-                self._finish_anchor()
-        if self._container_depth > 0:
-            self._container_depth -= 1
-
-    def _increment_depths(self) -> None:
-        if self._container_depth > 0:
-            self._container_depth += 1
-        if self._anchor_depth > 0:
-            self._anchor_depth += 1
-
-    def _starts_container(self, tag: str, attrs: list[tuple[str, str | None]]) -> bool:
-        if tag != "div":
-            return False
-        attrs_map = {name.lower(): (value or "") for name, value in attrs}
-        return attrs_map.get("id") == CONTAINER_ID
-
-    def _finish_anchor(self) -> None:
-        self.anchors.append(
-            _ParsedAnchor(
-                href=self._anchor_href,
-                text=normalize_space("".join(self._anchor_parts)),
-            )
-        )
-        self._anchor_href = None
-        self._anchor_parts = []
-
-
-def is_scholar_publication_detail_url(url: str | None) -> bool:
-    if not isinstance(url, str) or not url.strip():
-        return False
-    parsed = urlparse(url)
-    if parsed.scheme not in ALLOWED_URL_SCHEMES:
-        return False
-    if parsed.netloc.lower() != "scholar.google.com":
-        return False
-    query = parse_qs(parsed.query)
-    return _has_view_citation_params(query)
-
-
-def _has_view_citation_params(query: dict[str, list[str]]) -> bool:
-    view_op = (query.get("view_op") or [""])[0]
-    citation = (query.get("citation_for_view") or [""])[0].strip()
-    return view_op == "view_citation" and bool(citation)
-
-
-def extract_link_candidates_from_publication_detail_html(html: str) -> ScholarPublicationLinkCandidates:
-    parser = _parsed_publication_detail(html)
-    if not parser.container_seen:
-        return ScholarPublicationLinkCandidates(False, None, None)
-    anchors = _validated_container_anchors(parser.anchors)
-    labeled = _select_labeled_candidate(anchors)
-    fallback = _select_fallback_candidate(anchors, labeled=labeled)
-    warnings = _candidate_warnings(labeled=labeled, fallback=fallback)
-    return ScholarPublicationLinkCandidates(True, labeled, fallback, warnings)
-
-
-def _parsed_publication_detail(html: str) -> _ScholarPublicationPdfParser:
-    parser = _ScholarPublicationPdfParser()
-    parser.feed(html)
-    parser.close()
-    return parser
-
-
-def _validated_container_anchors(anchors: list[_ParsedAnchor]) -> list[_ParsedAnchor]:
-    if not anchors:
-        raise ScholarDomInvariantError(
-            code="layout_publication_link_container_missing_anchor",
-            message="Scholar publication link container was present without an anchor.",
-        )
-    validated: list[_ParsedAnchor] = []
-    for anchor in anchors:
-        validated.append(_validated_anchor(anchor))
-    return validated
-
-
-def _validated_anchor(anchor: _ParsedAnchor) -> _ParsedAnchor:
-    href = (anchor.href or "").strip()
-    if not href:
-        raise ScholarDomInvariantError(
-            code="layout_publication_link_missing_href",
-            message="Scholar publication link container anchor was missing href.",
-        )
-    parsed = urlparse(href)
-    if parsed.scheme not in ALLOWED_URL_SCHEMES:
-        raise ScholarDomInvariantError(
-            code="layout_publication_link_invalid_scheme",
-            message="Scholar publication link used a non-http URL.",
-        )
-    return _ParsedAnchor(href=href, text=anchor.text)
-
-
-def _select_labeled_candidate(anchors: list[_ParsedAnchor]) -> ScholarPublicationLinkCandidate | None:
-    for anchor in anchors:
-        if PDF_LABEL_TOKEN in anchor.text.lower():
-            return ScholarPublicationLinkCandidate(
-                url=str(anchor.href),
-                confidence_score=SCHOLAR_PDF_LABELED_CONFIDENCE,
-                label_present=True,
-                reason="scholar_link_labeled_pdf",
-            )
-    return None
-
-
-def _select_fallback_candidate(
-    anchors: list[_ParsedAnchor],
-    *,
-    labeled: ScholarPublicationLinkCandidate | None,
-) -> ScholarPublicationLinkCandidate | None:
-    for anchor in anchors:
-        if labeled and anchor.href == labeled.url:
-            continue
-        return ScholarPublicationLinkCandidate(
-            url=str(anchor.href),
-            confidence_score=SCHOLAR_PDF_UNLABELED_CONFIDENCE,
-            label_present=False,
-            reason="scholar_link_unlabeled_fallback",
-        )
-    if labeled is None and anchors:
-        anchor = anchors[0]
-        return ScholarPublicationLinkCandidate(
-            url=str(anchor.href),
-            confidence_score=SCHOLAR_PDF_UNLABELED_CONFIDENCE,
-            label_present=False,
-            reason="scholar_link_unlabeled_fallback",
-        )
-    return None
-
-
-def _candidate_warnings(
-    *,
-    labeled: ScholarPublicationLinkCandidate | None,
-    fallback: ScholarPublicationLinkCandidate | None,
-) -> tuple[str, ...]:
-    warnings: list[str] = []
-    if labeled is None and fallback is not None:
-        warnings.append("scholar_publication_link_unlabeled_only")
-    return tuple(warnings)
-
-
-def _scholar_request_delay_seconds() -> int:
-    return resolve_request_delay_minimum(settings.ingestion_min_request_delay_seconds)
-
-
-def _fetch_succeeded(fetch_result) -> bool:
-    return int(fetch_result.status_code or 0) == 200 and not fetch_result.error
-
-
-async def fetch_link_candidates_from_scholar_publication_page(
-    publication_url: str | None,
-) -> ScholarPublicationLinkCandidates | None:
-    if not is_scholar_publication_detail_url(publication_url):
-        return None
-    await wait_for_scholar_slot(min_interval_seconds=float(_scholar_request_delay_seconds()))
-    source = LiveScholarSource()
-    fetch_result = await source.fetch_publication_html(str(publication_url))
-    if not _fetch_succeeded(fetch_result):
-        return None
-    return extract_link_candidates_from_publication_detail_html(fetch_result.body)
diff --git a/app/services/domains/settings/application.py b/app/services/domains/settings/application.py
index 3548e44..7f435e8 100644
--- a/app/services/domains/settings/application.py
+++ b/app/services/domains/settings/application.py
@@ -109,6 +109,8 @@ def parse_nav_visible_pages(value: object) -> list[str]:
     return deduped
 
 
+from app.settings import settings as app_settings
+
 async def get_or_create_settings(
     db_session: AsyncSession,
     *,
@@ -121,7 +123,12 @@ async def get_or_create_settings(
     if settings is not None:
         return settings
 
-    settings = UserSetting(user_id=user_id)
+    settings = UserSetting(
+        user_id=user_id,
+        openalex_api_key=app_settings.openalex_api_key,
+        crossref_api_token=app_settings.crossref_api_token,
+        crossref_api_mailto=app_settings.crossref_api_mailto,
+    )
     db_session.add(settings)
     await db_session.commit()
     await db_session.refresh(settings)
@@ -136,11 +143,17 @@ async def update_settings(
     run_interval_minutes: int,
     request_delay_seconds: int,
     nav_visible_pages: list[str],
+    openalex_api_key: str | None,
+    crossref_api_token: str | None,
+    crossref_api_mailto: str | None,
 ) -> UserSetting:
     settings.auto_run_enabled = auto_run_enabled
     settings.run_interval_minutes = run_interval_minutes
     settings.request_delay_seconds = request_delay_seconds
     settings.nav_visible_pages = nav_visible_pages
+    settings.openalex_api_key = openalex_api_key
+    settings.crossref_api_token = crossref_api_token
+    settings.crossref_api_mailto = crossref_api_mailto
     await db_session.commit()
     await db_session.refresh(settings)
     return settings
diff --git a/app/services/domains/unpaywall/application.py b/app/services/domains/unpaywall/application.py
index a658818..13104e9 100644
--- a/app/services/domains/unpaywall/application.py
+++ b/app/services/domains/unpaywall/application.py
@@ -63,7 +63,10 @@ def _extract_explicit_doi(text: str | None) -> str | None:
 
 
 def _publication_doi(item: PublicationListItem | UnreadPublicationItem) -> str | None:
-    stored = normalize_doi(item.doi)
+    stored = None
+    if getattr(item, "display_identifier", None) and item.display_identifier.kind == "doi":
+        stored = normalize_doi(item.display_identifier.value)
+    
     explicit_doi = (
         _extract_explicit_doi(item.pub_url)
         or _extract_explicit_doi(item.venue_text)
@@ -169,9 +172,11 @@ async def _fetch_unpaywall_payload_by_doi(
     email: str,
 ) -> dict | None:
     await wait_for_unpaywall_slot(min_interval_seconds=settings.unpaywall_min_interval_seconds)
+    headers = {"User-Agent": f"scholar-scraper/1.0 (mailto:{email})"}
     response = await client.get(
         UNPAYWALL_URL_TEMPLATE.format(doi=doi),
         params={"email": email},
+        headers=headers,
     )
     if response.status_code != 200:
         return None
@@ -427,7 +432,8 @@ async def resolve_publication_oa_outcomes(
 
     timeout_seconds = max(float(settings.unpaywall_timeout_seconds), 0.5)
     targets = _resolution_targets(items)[: max(int(settings.unpaywall_max_items_per_request), 0)]
-    async with httpx.AsyncClient(timeout=timeout_seconds) as client:
+    headers = {"User-Agent": f"scholar-scraper/1.0 (mailto:{email})"}
+    async with httpx.AsyncClient(timeout=timeout_seconds, follow_redirects=True, headers=headers) as client:
         outcomes = await _resolve_outcomes_with_client(
             client=client,
             targets=targets,
diff --git a/app/settings.py b/app/settings.py
index 43871cf..15b0c19 100644
--- a/app/settings.py
+++ b/app/settings.py
@@ -140,6 +140,11 @@ class Settings:
         "INGESTION_RETRY_BACKOFF_SECONDS",
         1.0,
     )
+    ingestion_rate_limit_retries: int = _env_int("INGESTION_RATE_LIMIT_RETRIES", 3)
+    ingestion_rate_limit_backoff_seconds: float = _env_float(
+        "INGESTION_RATE_LIMIT_BACKOFF_SECONDS",
+        30.0,
+    )
     ingestion_max_pages_per_scholar: int = _env_int(
         "INGESTION_MAX_PAGES_PER_SCHOLAR",
         30,
@@ -182,6 +187,7 @@ class Settings:
         6,
     )
     scheduler_queue_batch_size: int = _env_int("SCHEDULER_QUEUE_BATCH_SIZE", 10)
+    scheduler_pdf_queue_batch_size: int = _env_int("SCHEDULER_PDF_QUEUE_BATCH_SIZE", 15)
     frontend_enabled: bool = _env_bool("FRONTEND_ENABLED", True)
     frontend_dist_dir: str = _env_str("FRONTEND_DIST_DIR", "/app/frontend/dist")
     scholar_image_upload_dir: str = _env_str(
@@ -241,9 +247,9 @@ class Settings:
     )
     pdf_auto_retry_first_interval_seconds: int = _env_int(
         "PDF_AUTO_RETRY_FIRST_INTERVAL_SECONDS",
-        3_600,
+        86_400,
     )
-    pdf_auto_retry_max_attempts: int = _env_int("PDF_AUTO_RETRY_MAX_ATTEMPTS", 3)
+    pdf_auto_retry_max_attempts: int = _env_int("PDF_AUTO_RETRY_MAX_ATTEMPTS", 2)
     unpaywall_pdf_discovery_enabled: bool = _env_bool("UNPAYWALL_PDF_DISCOVERY_ENABLED", True)
     unpaywall_pdf_discovery_max_candidates: int = _env_int("UNPAYWALL_PDF_DISCOVERY_MAX_CANDIDATES", 5)
     unpaywall_pdf_discovery_max_html_bytes: int = _env_int("UNPAYWALL_PDF_DISCOVERY_MAX_HTML_BYTES", 500_000)
@@ -252,6 +258,10 @@ class Settings:
     crossref_timeout_seconds: float = _env_float("CROSSREF_TIMEOUT_SECONDS", 8.0)
     crossref_min_interval_seconds: float = _env_float("CROSSREF_MIN_INTERVAL_SECONDS", 0.6)
     crossref_max_lookups_per_request: int = _env_int("CROSSREF_MAX_LOOKUPS_PER_REQUEST", 8)
+    
+    openalex_api_key: str | None = os.getenv("OPENALEX_API_KEY")
+    crossref_api_token: str | None = os.getenv("CROSSREF_API_TOKEN")
+    crossref_api_mailto: str | None = os.getenv("CROSSREF_API_MAILTO")
 
 
 settings = Settings()
diff --git a/build/lib/app/__init__.py b/build/lib/app/__init__.py
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/build/lib/app/__init__.py
@@ -0,0 +1 @@
+
diff --git a/build/lib/app/api/__init__.py b/build/lib/app/api/__init__.py
new file mode 100644
index 0000000..3ce55a6
--- /dev/null
+++ b/build/lib/app/api/__init__.py
@@ -0,0 +1,2 @@
+from __future__ import annotations
+
diff --git a/build/lib/app/api/deps.py b/build/lib/app/api/deps.py
new file mode 100644
index 0000000..f9c5377
--- /dev/null
+++ b/build/lib/app/api/deps.py
@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from fastapi import Depends, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.errors import ApiException
+from app.auth import runtime as auth_runtime
+from app.db.models import User
+from app.db.session import get_db_session
+
+
+async def get_api_current_user(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+) -> User:
+    current_user = await auth_runtime.get_authenticated_user(request, db_session)
+    if current_user is None:
+        raise ApiException(
+            status_code=401,
+            code="auth_required",
+            message="Authentication required.",
+        )
+    return current_user
+
+
+async def get_api_admin_user(
+    current_user: User = Depends(get_api_current_user),
+) -> User:
+    if not current_user.is_admin:
+        raise ApiException(
+            status_code=403,
+            code="forbidden",
+            message="Admin access required.",
+        )
+    return current_user
diff --git a/build/lib/app/api/errors.py b/build/lib/app/api/errors.py
new file mode 100644
index 0000000..976ccb8
--- /dev/null
+++ b/build/lib/app/api/errors.py
@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.exception_handlers import (
+    http_exception_handler as fastapi_http_exception_handler,
+)
+from fastapi.exception_handlers import (
+    request_validation_exception_handler as fastapi_validation_exception_handler,
+)
+from fastapi.exceptions import RequestValidationError
+
+from app.api.responses import error_response
+
+
+def _is_api_path(path: str) -> bool:
+    return path.startswith("/api/")
+
+
+def _status_code_to_error_code(status_code: int) -> str:
+    mapping = {
+        400: "bad_request",
+        401: "auth_required",
+        403: "forbidden",
+        404: "not_found",
+        409: "conflict",
+        422: "validation_error",
+        429: "rate_limited",
+        500: "internal_error",
+    }
+    return mapping.get(status_code, "error")
+
+
+class ApiException(Exception):
+    def __init__(
+        self,
+        *,
+        status_code: int,
+        code: str,
+        message: str,
+        details: Any | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code
+        self.message = message
+        self.details = details
+
+
+def register_api_exception_handlers(app: FastAPI) -> None:
+    @app.exception_handler(ApiException)
+    async def _handle_api_exception(request: Request, exc: ApiException):
+        return error_response(
+            request,
+            status_code=exc.status_code,
+            code=exc.code,
+            message=exc.message,
+            details=exc.details,
+        )
+
+    @app.exception_handler(HTTPException)
+    async def _handle_http_exception(request: Request, exc: HTTPException):
+        if not _is_api_path(request.url.path):
+            return await fastapi_http_exception_handler(request, exc)
+        return error_response(
+            request,
+            status_code=exc.status_code,
+            code=_status_code_to_error_code(exc.status_code),
+            message=str(exc.detail) if exc.detail is not None else "Request failed.",
+            details=exc.detail if isinstance(exc.detail, (dict, list)) else None,
+        )
+
+    @app.exception_handler(RequestValidationError)
+    async def _handle_validation_exception(request: Request, exc: RequestValidationError):
+        if not _is_api_path(request.url.path):
+            return await fastapi_validation_exception_handler(request, exc)
+        return error_response(
+            request,
+            status_code=422,
+            code="validation_error",
+            message="Request validation failed.",
+            details=exc.errors(),
+        )
+
diff --git a/build/lib/app/api/media.py b/build/lib/app/api/media.py
new file mode 100644
index 0000000..00943bd
--- /dev/null
+++ b/build/lib/app/api/media.py
@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import mimetypes
+
+from fastapi import APIRouter, Depends
+from fastapi.responses import FileResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import get_api_current_user
+from app.api.errors import ApiException
+from app.db.models import User
+from app.db.session import get_db_session
+from app.services.domains.scholars import application as scholar_service
+from app.settings import settings
+
+router = APIRouter(tags=["media"])
+
+
+@router.get("/scholar-images/{scholar_profile_id}/upload")
+async def get_uploaded_scholar_image(
+    scholar_profile_id: int,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    profile = await scholar_service.get_user_scholar_by_id(
+        db_session,
+        user_id=current_user.id,
+        scholar_profile_id=scholar_profile_id,
+    )
+    if profile is None:
+        raise ApiException(
+            status_code=404,
+            code="scholar_not_found",
+            message="Scholar not found.",
+        )
+    if not profile.profile_image_upload_path:
+        raise ApiException(
+            status_code=404,
+            code="scholar_image_not_found",
+            message="Scholar image not found.",
+        )
+
+    try:
+        image_path = scholar_service.resolve_upload_file_path(
+            upload_dir=settings.scholar_image_upload_dir,
+            relative_path=profile.profile_image_upload_path,
+        )
+    except scholar_service.ScholarServiceError as exc:
+        raise ApiException(
+            status_code=404,
+            code="scholar_image_not_found",
+            message="Scholar image not found.",
+        ) from exc
+
+    if not image_path.exists() or not image_path.is_file():
+        raise ApiException(
+            status_code=404,
+            code="scholar_image_not_found",
+            message="Scholar image not found.",
+        )
+
+    media_type = mimetypes.guess_type(str(image_path))[0] or "application/octet-stream"
+    return FileResponse(path=image_path, media_type=media_type)
diff --git a/build/lib/app/api/responses.py b/build/lib/app/api/responses.py
new file mode 100644
index 0000000..9976aba
--- /dev/null
+++ b/build/lib/app/api/responses.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi.encoders import jsonable_encoder
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+
+def _request_id(request: Request) -> str | None:
+    request_state = getattr(request, "state", None)
+    if request_state is None:
+        return None
+    return getattr(request_state, "request_id", None)
+
+
+def success_payload(
+    request: Request,
+    *,
+    data: Any,
+) -> dict[str, Any]:
+    return {
+        "data": data,
+        "meta": {
+            "request_id": _request_id(request),
+        },
+    }
+
+
+def success_response(
+    request: Request,
+    *,
+    data: Any,
+    status_code: int = 200,
+) -> JSONResponse:
+    payload = success_payload(request, data=data)
+    return JSONResponse(
+        status_code=status_code,
+        content=jsonable_encoder(payload),
+    )
+
+
+def error_response(
+    request: Request,
+    *,
+    status_code: int,
+    code: str,
+    message: str,
+    details: Any | None = None,
+) -> JSONResponse:
+    payload = {
+        "error": {
+            "code": code,
+            "message": message,
+            "details": details,
+        },
+        "meta": {
+            "request_id": _request_id(request),
+        },
+    }
+    return JSONResponse(
+        status_code=status_code,
+        content=jsonable_encoder(payload),
+    )
diff --git a/build/lib/app/api/router.py b/build/lib/app/api/router.py
new file mode 100644
index 0000000..a11d98a
--- /dev/null
+++ b/build/lib/app/api/router.py
@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from app.api.routers import admin, admin_dbops, auth, publications, runs, scholars, settings
+
+router = APIRouter(prefix="/api/v1")
+router.include_router(auth.router)
+router.include_router(admin.router)
+router.include_router(admin_dbops.router)
+router.include_router(scholars.router)
+router.include_router(settings.router)
+router.include_router(runs.router)
+router.include_router(publications.router)
diff --git a/build/lib/app/api/routers/__init__.py b/build/lib/app/api/routers/__init__.py
new file mode 100644
index 0000000..3ce55a6
--- /dev/null
+++ b/build/lib/app/api/routers/__init__.py
@@ -0,0 +1,2 @@
+from __future__ import annotations
+
diff --git a/build/lib/app/api/routers/admin.py b/build/lib/app/api/routers/admin.py
new file mode 100644
index 0000000..9844c3e
--- /dev/null
+++ b/build/lib/app/api/routers/admin.py
@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, Depends, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import get_api_admin_user
+from app.api.errors import ApiException
+from app.api.responses import success_payload
+from app.api.schemas import (
+    AdminResetPasswordRequest,
+    AdminUserActiveUpdateRequest,
+    AdminUserCreateRequest,
+    AdminUserEnvelope,
+    AdminUsersListEnvelope,
+    MessageEnvelope,
+)
+from app.auth.deps import get_auth_service
+from app.auth.service import AuthService
+from app.db.models import User
+from app.db.session import get_db_session
+from app.services.domains.users import application as user_service
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/admin/users", tags=["api-admin-users"])
+
+
+def _serialize_user(user: User) -> dict[str, object]:
+    return {
+        "id": int(user.id),
+        "email": user.email,
+        "is_active": bool(user.is_active),
+        "is_admin": bool(user.is_admin),
+        "created_at": user.created_at,
+        "updated_at": user.updated_at,
+    }
+
+
+@router.get(
+    "",
+    response_model=AdminUsersListEnvelope,
+)
+async def list_users(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    users = await user_service.list_users(db_session)
+    logger.info(
+        "api.admin.users_listed",
+        extra={
+            "event": "api.admin.users_listed",
+            "admin_user_id": int(admin_user.id),
+            "user_count": len(users),
+        },
+    )
+    return success_payload(
+        request,
+        data={
+            "users": [_serialize_user(user) for user in users],
+        },
+    )
+
+
+@router.post(
+    "",
+    response_model=AdminUserEnvelope,
+    status_code=201,
+)
+async def create_user(
+    payload: AdminUserCreateRequest,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    auth_service: AuthService = Depends(get_auth_service),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    try:
+        validated_email = user_service.validate_email(payload.email)
+        validated_password = user_service.validate_password(payload.password)
+        created_user = await user_service.create_user(
+            db_session,
+            email=validated_email,
+            password_hash=auth_service.hash_password(validated_password),
+            is_admin=bool(payload.is_admin),
+        )
+    except user_service.UserServiceError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_user_input",
+            message=str(exc),
+        ) from exc
+
+    logger.info(
+        "api.admin.user_created",
+        extra={
+            "event": "api.admin.user_created",
+            "admin_user_id": int(admin_user.id),
+            "target_user_id": int(created_user.id),
+            "target_is_admin": bool(created_user.is_admin),
+        },
+    )
+    return success_payload(
+        request,
+        data=_serialize_user(created_user),
+    )
+
+
+@router.patch(
+    "/{user_id}/active",
+    response_model=AdminUserEnvelope,
+)
+async def set_user_active(
+    user_id: int,
+    payload: AdminUserActiveUpdateRequest,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    target_user = await user_service.get_user_by_id(db_session, user_id)
+    if target_user is None:
+        raise ApiException(
+            status_code=404,
+            code="user_not_found",
+            message="User not found.",
+        )
+    if (
+        int(target_user.id) == int(admin_user.id)
+        and bool(target_user.is_active)
+        and not bool(payload.is_active)
+    ):
+        raise ApiException(
+            status_code=400,
+            code="cannot_deactivate_self",
+            message="You cannot deactivate your own account.",
+        )
+    updated_user = await user_service.set_user_active(
+        db_session,
+        user=target_user,
+        is_active=bool(payload.is_active),
+    )
+    logger.info(
+        "api.admin.user_active_updated",
+        extra={
+            "event": "api.admin.user_active_updated",
+            "admin_user_id": int(admin_user.id),
+            "target_user_id": int(updated_user.id),
+            "is_active": bool(updated_user.is_active),
+        },
+    )
+    return success_payload(
+        request,
+        data=_serialize_user(updated_user),
+    )
+
+
+@router.post(
+    "/{user_id}/reset-password",
+    response_model=MessageEnvelope,
+)
+async def reset_user_password(
+    user_id: int,
+    payload: AdminResetPasswordRequest,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    auth_service: AuthService = Depends(get_auth_service),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    target_user = await user_service.get_user_by_id(db_session, user_id)
+    if target_user is None:
+        raise ApiException(
+            status_code=404,
+            code="user_not_found",
+            message="User not found.",
+        )
+    try:
+        validated_password = user_service.validate_password(payload.new_password)
+    except user_service.UserServiceError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_password",
+            message=str(exc),
+        ) from exc
+
+    await user_service.set_user_password_hash(
+        db_session,
+        user=target_user,
+        password_hash=auth_service.hash_password(validated_password),
+    )
+    logger.info(
+        "api.admin.user_password_reset",
+        extra={
+            "event": "api.admin.user_password_reset",
+            "admin_user_id": int(admin_user.id),
+            "target_user_id": int(target_user.id),
+        },
+    )
+    return success_payload(
+        request,
+        data={"message": f"Password reset: {target_user.email}"},
+    )
diff --git a/build/lib/app/api/routers/admin_dbops.py b/build/lib/app/api/routers/admin_dbops.py
new file mode 100644
index 0000000..87fc3b8
--- /dev/null
+++ b/build/lib/app/api/routers/admin_dbops.py
@@ -0,0 +1,349 @@
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, Depends, Path, Query, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import get_api_admin_user
+from app.api.errors import ApiException
+from app.api.responses import success_payload
+from app.api.schemas import (
+    AdminDbIntegrityEnvelope,
+    AdminPdfQueueBulkEnqueueEnvelope,
+    AdminPdfQueueRequeueEnvelope,
+    AdminPdfQueueEnvelope,
+    AdminDbRepairJobsEnvelope,
+    AdminRepairPublicationLinksEnvelope,
+    AdminRepairPublicationLinksRequest,
+)
+from app.db.models import DataRepairJob, User
+from app.db.session import get_db_session
+from app.services.domains.dbops import (
+    collect_integrity_report,
+    list_repair_jobs,
+    run_publication_link_repair,
+)
+from app.services.domains.publications import application as publication_service
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/admin/db", tags=["api-admin-dbops"])
+
+
+def _serialize_repair_job(job: DataRepairJob) -> dict[str, object]:
+    return {
+        "id": int(job.id),
+        "job_name": job.job_name,
+        "requested_by": job.requested_by,
+        "dry_run": bool(job.dry_run),
+        "status": job.status,
+        "scope": dict(job.scope or {}),
+        "summary": dict(job.summary or {}),
+        "error_text": job.error_text,
+        "started_at": job.started_at,
+        "finished_at": job.finished_at,
+        "created_at": job.created_at,
+        "updated_at": job.updated_at,
+    }
+
+
+def _requested_by_value(*, payload: AdminRepairPublicationLinksRequest, admin_user: User) -> str:
+    from_payload = (payload.requested_by or "").strip()
+    return from_payload or admin_user.email
+
+
+def _serialize_pdf_queue_item(item) -> dict[str, object]:
+    return {
+        "publication_id": item.publication_id,
+        "title": item.title,
+        "display_identifier": _serialize_display_identifier(item.display_identifier),
+        "pdf_url": item.pdf_url,
+        "status": item.status,
+        "attempt_count": item.attempt_count,
+        "last_failure_reason": item.last_failure_reason,
+        "last_failure_detail": item.last_failure_detail,
+        "last_source": item.last_source,
+        "requested_by_user_id": item.requested_by_user_id,
+        "requested_by_email": item.requested_by_email,
+        "queued_at": item.queued_at,
+        "last_attempt_at": item.last_attempt_at,
+        "resolved_at": item.resolved_at,
+        "updated_at": item.updated_at,
+    }
+
+
+def _serialize_display_identifier(value) -> dict[str, object] | None:
+    if value is None:
+        return None
+    return {
+        "kind": value.kind,
+        "value": value.value,
+        "label": value.label,
+        "url": value.url,
+        "confidence_score": float(value.confidence_score),
+    }
+
+
+def _requeue_response_state(*, queued: bool) -> tuple[str, str]:
+    if queued:
+        return "queued", "PDF lookup queued."
+    return "blocked", "PDF lookup is already queued or currently running."
+
+
+def _bulk_enqueue_message(*, queued_count: int, requested_count: int) -> str:
+    if requested_count == 0:
+        return "No missing-PDF publications were found."
+    if queued_count == 0:
+        return "No publications were queued; all candidates were already in-flight."
+    return f"Queued {queued_count} publication(s) for PDF lookup."
+
+
+def _resolve_pdf_queue_paging(
+    *,
+    page: int,
+    page_size: int,
+    limit: int | None,
+    offset: int | None,
+) -> tuple[int, int, int]:
+    resolved_limit = int(limit) if limit is not None else int(page_size)
+    resolved_offset = int(offset) if offset is not None else max((int(page) - 1) * resolved_limit, 0)
+    resolved_page = max((resolved_offset // max(resolved_limit, 1)) + 1, 1)
+    return resolved_page, max(resolved_limit, 1), max(resolved_offset, 0)
+
+
+def _pdf_queue_page_data(*, total_count: int, page: int, page_size: int, offset: int) -> dict[str, object]:
+    return {
+        "total_count": int(total_count),
+        "page": int(page),
+        "page_size": int(page_size),
+        "has_prev": int(offset) > 0,
+        "has_next": int(offset) + int(page_size) < int(total_count),
+    }
+
+
+@router.get(
+    "/integrity",
+    response_model=AdminDbIntegrityEnvelope,
+)
+async def get_integrity_report(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    report = await collect_integrity_report(db_session)
+    logger.info(
+        "api.admin.db.integrity_checked",
+        extra={
+            "event": "api.admin.db.integrity_checked",
+            "admin_user_id": int(admin_user.id),
+            "status": report.get("status"),
+            "failure_count": len(report.get("failures", [])),
+            "warning_count": len(report.get("warnings", [])),
+        },
+    )
+    return success_payload(request, data=report)
+
+
+@router.get(
+    "/repair-jobs",
+    response_model=AdminDbRepairJobsEnvelope,
+)
+async def get_repair_jobs(
+    request: Request,
+    limit: int = Query(default=50, ge=1, le=200),
+    db_session: AsyncSession = Depends(get_db_session),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    jobs = await list_repair_jobs(db_session, limit=limit)
+    logger.info(
+        "api.admin.db.repair_jobs_listed",
+        extra={
+            "event": "api.admin.db.repair_jobs_listed",
+            "admin_user_id": int(admin_user.id),
+            "limit": int(limit),
+            "job_count": len(jobs),
+        },
+    )
+    return success_payload(
+        request,
+        data={"jobs": [_serialize_repair_job(job) for job in jobs]},
+    )
+
+
+@router.get(
+    "/pdf-queue",
+    response_model=AdminPdfQueueEnvelope,
+)
+async def get_pdf_queue(
+    request: Request,
+    page: int = Query(default=1, ge=1),
+    page_size: int = Query(default=100, ge=1, le=500),
+    limit: int | None = Query(default=None, ge=1, le=500),
+    offset: int | None = Query(default=None, ge=0),
+    status: str | None = Query(default=None),
+    db_session: AsyncSession = Depends(get_db_session),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    normalized_status = (status or "").strip().lower() or None
+    resolved_page, resolved_limit, resolved_offset = _resolve_pdf_queue_paging(
+        page=page,
+        page_size=page_size,
+        limit=limit,
+        offset=offset,
+    )
+    queue_page = await publication_service.list_pdf_queue_page(
+        db_session,
+        limit=resolved_limit,
+        offset=resolved_offset,
+        status=normalized_status,
+    )
+    logger.info(
+        "api.admin.db.pdf_queue_listed",
+        extra={
+            "event": "api.admin.db.pdf_queue_listed",
+            "admin_user_id": int(admin_user.id),
+            "page": int(resolved_page),
+            "page_size": int(resolved_limit),
+            "offset": int(resolved_offset),
+            "status": normalized_status,
+            "item_count": len(queue_page.items),
+            "total_count": int(queue_page.total_count),
+        },
+    )
+    return success_payload(
+        request,
+        data={
+            "items": [_serialize_pdf_queue_item(item) for item in queue_page.items],
+            **_pdf_queue_page_data(
+                total_count=queue_page.total_count,
+                page=resolved_page,
+                page_size=resolved_limit,
+                offset=resolved_offset,
+            ),
+        },
+    )
+
+
+@router.post(
+    "/pdf-queue/{publication_id}/requeue",
+    response_model=AdminPdfQueueRequeueEnvelope,
+)
+async def requeue_pdf_lookup(
+    request: Request,
+    publication_id: int = Path(ge=1),
+    db_session: AsyncSession = Depends(get_db_session),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    result = await publication_service.enqueue_retry_pdf_job_for_publication_id(
+        db_session,
+        user_id=int(admin_user.id),
+        request_email=admin_user.email,
+        publication_id=publication_id,
+    )
+    if not result.publication_exists:
+        raise ApiException(
+            status_code=404,
+            code="publication_not_found",
+            message="Publication not found.",
+        )
+    status, message = _requeue_response_state(queued=result.queued)
+    logger.info(
+        "api.admin.db.pdf_queue_requeue_requested",
+        extra={
+            "event": "api.admin.db.pdf_queue_requeue_requested",
+            "admin_user_id": int(admin_user.id),
+            "publication_id": int(publication_id),
+            "queued": bool(result.queued),
+        },
+    )
+    return success_payload(
+        request,
+        data={
+            "publication_id": int(publication_id),
+            "queued": bool(result.queued),
+            "status": status,
+            "message": message,
+        },
+    )
+
+
+@router.post(
+    "/pdf-queue/requeue-all",
+    response_model=AdminPdfQueueBulkEnqueueEnvelope,
+)
+async def requeue_all_missing_pdfs(
+    request: Request,
+    limit: int = Query(default=1000, ge=1, le=5000),
+    db_session: AsyncSession = Depends(get_db_session),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    result = await publication_service.enqueue_all_missing_pdf_jobs(
+        db_session,
+        user_id=int(admin_user.id),
+        request_email=admin_user.email,
+        limit=limit,
+    )
+    logger.info(
+        "api.admin.db.pdf_queue_requeue_all",
+        extra={
+            "event": "api.admin.db.pdf_queue_requeue_all",
+            "admin_user_id": int(admin_user.id),
+            "limit": int(limit),
+            "requested_count": int(result.requested_count),
+            "queued_count": int(result.queued_count),
+        },
+    )
+    return success_payload(
+        request,
+        data={
+            "requested_count": int(result.requested_count),
+            "queued_count": int(result.queued_count),
+            "message": _bulk_enqueue_message(
+                queued_count=int(result.queued_count),
+                requested_count=int(result.requested_count),
+            ),
+        },
+    )
+
+
+@router.post(
+    "/repairs/publication-links",
+    response_model=AdminRepairPublicationLinksEnvelope,
+)
+async def trigger_publication_link_repair(
+    payload: AdminRepairPublicationLinksRequest,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    try:
+        result = await run_publication_link_repair(
+            db_session,
+            scope_mode=payload.scope_mode,
+            user_id=payload.user_id,
+            scholar_profile_ids=payload.scholar_profile_ids,
+            dry_run=bool(payload.dry_run),
+            gc_orphan_publications=bool(payload.gc_orphan_publications),
+            requested_by=_requested_by_value(payload=payload, admin_user=admin_user),
+        )
+    except ValueError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_repair_scope",
+            message=str(exc),
+        ) from exc
+    logger.info(
+        "api.admin.db.publication_link_repair_triggered",
+        extra={
+            "event": "api.admin.db.publication_link_repair_triggered",
+            "admin_user_id": int(admin_user.id),
+            "scope_mode": payload.scope_mode,
+            "target_user_id": int(payload.user_id) if payload.user_id is not None else None,
+            "dry_run": bool(payload.dry_run),
+            "gc_orphan_publications": bool(payload.gc_orphan_publications),
+            "job_id": int(result["job_id"]),
+            "status": result["status"],
+        },
+    )
+    return success_payload(request, data=result)
diff --git a/build/lib/app/api/routers/auth.py b/build/lib/app/api/routers/auth.py
new file mode 100644
index 0000000..8f8da17
--- /dev/null
+++ b/build/lib/app/api/routers/auth.py
@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, Depends, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.errors import ApiException
+from app.api.deps import get_api_current_user
+from app.api.responses import success_payload
+from app.api.schemas import (
+    AuthMeEnvelope,
+    ChangePasswordRequest,
+    CsrfBootstrapEnvelope,
+    LoginEnvelope,
+    LoginRequest,
+    MessageEnvelope,
+)
+from app.auth.deps import get_auth_service, get_login_rate_limiter
+from app.auth.rate_limit import SlidingWindowRateLimiter
+from app.auth import runtime as auth_runtime
+from app.auth.service import AuthService
+from app.auth.session import set_session_user
+from app.db.models import User
+from app.db.session import get_db_session
+from app.security.csrf import ensure_csrf_token
+from app.services.domains.users import application as user_service
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/auth", tags=["api-auth"])
+
+
+def _login_limiter_key_and_email(request: Request, payload: LoginRequest) -> tuple[str, str]:
+    return auth_runtime.login_rate_limit_key(request, payload.email), payload.email.strip().lower()
+
+
+def _raise_rate_limited(normalized_email: str, retry_after_seconds: int) -> None:
+    logger.warning(
+        "api.auth.login_rate_limited",
+        extra={
+            "event": "api.auth.login_rate_limited",
+            "email": normalized_email,
+            "retry_after_seconds": retry_after_seconds,
+        },
+    )
+    raise ApiException(
+        status_code=429,
+        code="rate_limited",
+        message="Too many login attempts. Please try again later.",
+        details={"retry_after_seconds": retry_after_seconds},
+    )
+
+
+def _serialize_user_payload(user: User) -> dict[str, object]:
+    return {
+        "id": int(user.id),
+        "email": user.email,
+        "is_admin": bool(user.is_admin),
+        "is_active": bool(user.is_active),
+    }
+
+
+def _raise_invalid_credentials(*, normalized_email: str) -> None:
+    logger.info(
+        "api.auth.login_failed",
+        extra={"event": "api.auth.login_failed", "email": normalized_email},
+    )
+    raise ApiException(
+        status_code=401,
+        code="invalid_credentials",
+        message="Invalid email or password.",
+    )
+
+
+@router.post(
+    "/login",
+    response_model=LoginEnvelope,
+)
+async def login(
+    payload: LoginRequest,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    auth_service: AuthService = Depends(get_auth_service),
+    rate_limiter: SlidingWindowRateLimiter = Depends(get_login_rate_limiter),
+):
+    limiter_key, normalized_email = _login_limiter_key_and_email(request, payload)
+    decision = rate_limiter.check(limiter_key)
+    if not decision.allowed:
+        _raise_rate_limited(normalized_email, int(decision.retry_after_seconds))
+
+    user = await auth_service.authenticate_user(
+        db_session,
+        email=payload.email,
+        password=payload.password,
+    )
+    if user is None:
+        rate_limiter.record_failure(limiter_key)
+        _raise_invalid_credentials(normalized_email=normalized_email)
+
+    rate_limiter.reset(limiter_key)
+    set_session_user(
+        request,
+        user_id=user.id,
+        email=user.email,
+        is_admin=user.is_admin,
+    )
+    logger.info(
+        "api.auth.login_succeeded",
+        extra={
+            "event": "api.auth.login_succeeded",
+            "user_id": user.id,
+            "is_admin": user.is_admin,
+        },
+    )
+    return success_payload(
+        request,
+        data={
+            "authenticated": True,
+            "csrf_token": ensure_csrf_token(request),
+            "user": _serialize_user_payload(user),
+        },
+    )
+
+
+@router.get(
+    "/me",
+    response_model=AuthMeEnvelope,
+)
+async def get_current_session(
+    request: Request,
+    current_user: User = Depends(get_api_current_user),
+):
+    return success_payload(
+        request,
+        data={
+            "authenticated": True,
+            "csrf_token": ensure_csrf_token(request),
+            "user": _serialize_user_payload(current_user),
+        },
+    )
+
+
+@router.get(
+    "/csrf",
+    response_model=CsrfBootstrapEnvelope,
+)
+async def get_csrf_bootstrap(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+):
+    current_user = await auth_runtime.get_authenticated_user(request, db_session)
+    return success_payload(
+        request,
+        data={
+            "csrf_token": ensure_csrf_token(request),
+            "authenticated": current_user is not None,
+        },
+    )
+
+
+@router.post(
+    "/change-password",
+    response_model=MessageEnvelope,
+)
+async def change_password(
+    payload: ChangePasswordRequest,
+    request: Request,
+    current_user: User = Depends(get_api_current_user),
+    db_session: AsyncSession = Depends(get_db_session),
+    auth_service: AuthService = Depends(get_auth_service),
+):
+    if not auth_service.verify_password(
+        password_hash=current_user.password_hash,
+        password=payload.current_password,
+    ):
+        raise ApiException(
+            status_code=400,
+            code="invalid_current_password",
+            message="Current password is incorrect.",
+        )
+    if payload.new_password != payload.confirm_password:
+        raise ApiException(
+            status_code=400,
+            code="password_confirmation_mismatch",
+            message="New password and confirmation do not match.",
+        )
+    try:
+        validated_password = user_service.validate_password(payload.new_password)
+    except user_service.UserServiceError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_password",
+            message=str(exc),
+        ) from exc
+
+    await user_service.set_user_password_hash(
+        db_session,
+        user=current_user,
+        password_hash=auth_service.hash_password(validated_password),
+    )
+    logger.info(
+        "api.auth.password_changed",
+        extra={
+            "event": "api.auth.password_changed",
+            "user_id": int(current_user.id),
+        },
+    )
+    return success_payload(
+        request,
+        data={"message": "Password updated successfully."},
+    )
+
+
+@router.post(
+    "/logout",
+    response_model=MessageEnvelope,
+)
+async def logout(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+):
+    current_user = await auth_runtime.get_authenticated_user(request, db_session)
+    auth_runtime.invalidate_session(request)
+    logger.info(
+        "api.auth.logout",
+        extra={
+            "event": "api.auth.logout",
+            "user_id": int(current_user.id) if current_user is not None else None,
+        },
+    )
+    return success_payload(
+        request,
+        data={
+            "message": "Logged out.",
+        },
+    )
diff --git a/build/lib/app/api/routers/publications.py b/build/lib/app/api/routers/publications.py
new file mode 100644
index 0000000..2a96b8b
--- /dev/null
+++ b/build/lib/app/api/routers/publications.py
@@ -0,0 +1,528 @@
+from __future__ import annotations
+
+import logging
+from typing import Literal
+
+from fastapi import APIRouter, Depends, Path, Query, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import get_api_current_user
+from app.api.errors import ApiException
+from app.api.responses import success_payload
+from app.api.schemas import (
+    MarkAllReadEnvelope,
+    MarkSelectedReadEnvelope,
+    MarkSelectedReadRequest,
+    PublicationsListEnvelope,
+    RetryPublicationPdfEnvelope,
+    RetryPublicationPdfRequest,
+    TogglePublicationFavoriteEnvelope,
+    TogglePublicationFavoriteRequest,
+)
+from app.db.models import User
+from app.db.session import get_db_session
+from app.services.domains.publication_identifiers import application as identifier_service
+from app.services.domains.publications import application as publication_service
+from app.services.domains.scholars import application as scholar_service
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/publications", tags=["api-publications"])
+
+
+async def _require_selected_profile(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    selected_scholar_id: int | None,
+) -> None:
+    if selected_scholar_id is None:
+        return
+    selected_profile = await scholar_service.get_user_scholar_by_id(
+        db_session,
+        user_id=user_id,
+        scholar_profile_id=selected_scholar_id,
+    )
+    if selected_profile is None:
+        raise ApiException(
+            status_code=404,
+            code="scholar_not_found",
+            message="Scholar filter not found.",
+        )
+
+
+def _serialize_publication_item(item) -> dict[str, object]:
+    return {
+        "publication_id": item.publication_id,
+        "scholar_profile_id": item.scholar_profile_id,
+        "scholar_label": item.scholar_label,
+        "title": item.title,
+        "year": item.year,
+        "citation_count": item.citation_count,
+        "venue_text": item.venue_text,
+        "pub_url": item.pub_url,
+        "display_identifier": _serialize_display_identifier(item.display_identifier),
+        "pdf_url": item.pdf_url,
+        "pdf_status": item.pdf_status,
+        "pdf_attempt_count": item.pdf_attempt_count,
+        "pdf_failure_reason": item.pdf_failure_reason,
+        "pdf_failure_detail": item.pdf_failure_detail,
+        "is_read": item.is_read,
+        "is_favorite": item.is_favorite,
+        "first_seen_at": item.first_seen_at,
+        "is_new_in_latest_run": item.is_new_in_latest_run,
+    }
+
+
+def _serialize_display_identifier(value) -> dict[str, object] | None:
+    if value is None:
+        return None
+    return {
+        "kind": value.kind,
+        "value": value.value,
+        "label": value.label,
+        "url": value.url,
+        "confidence_score": float(value.confidence_score),
+    }
+
+
+async def _publication_counts(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    selected_scholar_id: int | None,
+    favorite_only: bool,
+) -> tuple[int, int, int, int]:
+    unread_count = await publication_service.count_unread_for_user(
+        db_session,
+        user_id=user_id,
+        scholar_profile_id=selected_scholar_id,
+        favorite_only=favorite_only,
+    )
+    favorites_count = await publication_service.count_favorite_for_user(
+        db_session,
+        user_id=user_id,
+        scholar_profile_id=selected_scholar_id,
+    )
+    latest_count = await publication_service.count_latest_for_user(
+        db_session,
+        user_id=user_id,
+        scholar_profile_id=selected_scholar_id,
+        favorite_only=favorite_only,
+    )
+    total_count = await publication_service.count_for_user(
+        db_session,
+        user_id=user_id,
+        mode=publication_service.MODE_ALL,
+        scholar_profile_id=selected_scholar_id,
+        favorite_only=favorite_only,
+    )
+    return unread_count, favorites_count, latest_count, total_count
+
+
+async def _list_publications_for_request(
+    db_session: AsyncSession,
+    *,
+    current_user: User,
+    mode: Literal["all", "unread", "latest", "new"] | None,
+    favorite_only: bool,
+    scholar_profile_id: int | None,
+    limit: int,
+    offset: int,
+) -> tuple[str, int | None, list]:
+    resolved_mode = publication_service.resolve_publication_view_mode(mode)
+    selected_scholar_id = scholar_profile_id
+    await _require_selected_profile(
+        db_session,
+        user_id=current_user.id,
+        selected_scholar_id=selected_scholar_id,
+    )
+    publications = await publication_service.list_for_user(
+        db_session,
+        user_id=current_user.id,
+        mode=resolved_mode,
+        scholar_profile_id=selected_scholar_id,
+        favorite_only=favorite_only,
+        limit=limit,
+        offset=offset,
+    )
+    await publication_service.schedule_missing_pdf_enrichment_for_user(
+        db_session,
+        user_id=current_user.id,
+        request_email=current_user.email,
+        items=publications,
+        max_items=settings.unpaywall_max_items_per_request,
+    )
+    hydrated = await publication_service.hydrate_pdf_enrichment_state(
+        db_session,
+        items=publications,
+    )
+    return resolved_mode, selected_scholar_id, hydrated
+
+
+def _resolve_publications_paging(
+    *,
+    page: int,
+    page_size: int,
+    limit: int | None,
+    offset: int | None,
+) -> tuple[int, int, int]:
+    resolved_limit = int(limit) if limit is not None else int(page_size)
+    resolved_offset = int(offset) if offset is not None else max((int(page) - 1) * resolved_limit, 0)
+    resolved_page = max((resolved_offset // max(resolved_limit, 1)) + 1, 1)
+    return resolved_page, max(resolved_limit, 1), max(resolved_offset, 0)
+
+
+def _publications_list_data(
+    *,
+    mode: str,
+    favorite_only: bool,
+    selected_scholar_id: int | None,
+    unread_count: int,
+    favorites_count: int,
+    latest_count: int,
+    total_count: int,
+    publications: list,
+    page: int,
+    page_size: int,
+    offset: int,
+) -> dict[str, object]:
+    return {
+        "mode": mode,
+        "favorite_only": favorite_only,
+        "selected_scholar_profile_id": selected_scholar_id,
+        "unread_count": unread_count,
+        "favorites_count": favorites_count,
+        "latest_count": latest_count,
+        "new_count": latest_count,
+        "total_count": total_count,
+        "page": int(page),
+        "page_size": int(page_size),
+        "has_prev": int(offset) > 0,
+        "has_next": int(offset) + int(page_size) < int(total_count),
+        "publications": [_serialize_publication_item(item) for item in publications],
+    }
+
+
+def _retry_pdf_message(*, queued: bool, resolved_pdf: bool, pdf_status: str) -> str:
+    if resolved_pdf:
+        return "Open-access PDF link already resolved."
+    if queued:
+        return "PDF lookup queued."
+    if pdf_status in {"queued", "running"}:
+        return "PDF lookup is already queued."
+    return "No open-access PDF link found."
+
+
+def _favorite_message(*, is_favorite: bool) -> str:
+    if is_favorite:
+        return "Publication marked as favorite."
+    return "Publication removed from favorites."
+
+
+async def _retry_publication_state(
+    db_session: AsyncSession,
+    *,
+    current_user: User,
+    scholar_profile_id: int,
+    publication_id: int,
+):
+    publication = await publication_service.retry_pdf_for_user(
+        db_session,
+        user_id=current_user.id,
+        scholar_profile_id=scholar_profile_id,
+        publication_id=publication_id,
+    )
+    if publication is None:
+        raise ApiException(
+            status_code=404,
+            code="publication_not_found",
+            message="Publication not found.",
+        )
+    queued = False
+    if not publication.pdf_url:
+        queued = await publication_service.schedule_retry_pdf_enrichment_for_row(
+            db_session,
+            user_id=current_user.id,
+            request_email=current_user.email,
+            item=publication,
+        )
+    hydrated = await publication_service.hydrate_pdf_enrichment_state(
+        db_session,
+        items=[publication],
+    )
+    current = hydrated[0] if hydrated else publication
+    return current, queued
+
+
+async def _favorite_publication_state(
+    db_session: AsyncSession,
+    *,
+    current_user: User,
+    scholar_profile_id: int,
+    publication_id: int,
+    is_favorite: bool,
+):
+    updated_count = await publication_service.set_publication_favorite_for_user(
+        db_session,
+        user_id=current_user.id,
+        scholar_profile_id=scholar_profile_id,
+        publication_id=publication_id,
+        is_favorite=is_favorite,
+    )
+    if updated_count <= 0:
+        raise ApiException(
+            status_code=404,
+            code="publication_not_found",
+            message="Publication not found.",
+        )
+    publication = await publication_service.get_publication_item_for_user(
+        db_session,
+        user_id=current_user.id,
+        scholar_profile_id=scholar_profile_id,
+        publication_id=publication_id,
+    )
+    if publication is None:
+        raise ApiException(
+            status_code=404,
+            code="publication_not_found",
+            message="Publication not found.",
+        )
+    hydrated = await publication_service.hydrate_pdf_enrichment_state(
+        db_session,
+        items=[publication],
+    )
+    current = hydrated[0] if hydrated else publication
+    identifiers = await identifier_service.overlay_publication_items_with_display_identifiers(
+        db_session,
+        items=[current],
+    )
+    return identifiers[0] if identifiers else current
+
+
+def _log_retry_pdf_result(
+    *,
+    current_user: User,
+    scholar_profile_id: int,
+    publication_id: int,
+    queued: bool,
+    resolved_pdf: bool,
+    pdf_status: str,
+    doi: str | None,
+) -> None:
+    logger.info(
+        "api.publications.retry_pdf",
+        extra={
+            "event": "api.publications.retry_pdf",
+            "user_id": current_user.id,
+            "scholar_profile_id": scholar_profile_id,
+            "publication_id": publication_id,
+            "queued": queued,
+            "resolved_pdf": resolved_pdf,
+            "pdf_status": pdf_status,
+        },
+    )
+
+
+@router.get(
+    "",
+    response_model=PublicationsListEnvelope,
+)
+async def list_publications(
+    request: Request,
+    mode: Literal["all", "unread", "latest", "new"] | None = Query(default=None),
+    favorite_only: bool = Query(default=False),
+    scholar_profile_id: int | None = Query(default=None, ge=1),
+    page: int = Query(default=1, ge=1),
+    page_size: int = Query(default=100, ge=1, le=500),
+    limit: int | None = Query(default=None, ge=1, le=1000),
+    offset: int | None = Query(default=None, ge=0),
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    resolved_page, resolved_limit, resolved_offset = _resolve_publications_paging(
+        page=page,
+        page_size=page_size,
+        limit=limit,
+        offset=offset,
+    )
+    resolved_mode, selected_scholar_id, publications = await _list_publications_for_request(
+        db_session,
+        current_user=current_user,
+        mode=mode,
+        favorite_only=favorite_only,
+        scholar_profile_id=scholar_profile_id,
+        limit=resolved_limit,
+        offset=resolved_offset,
+    )
+    unread_count, favorites_count, latest_count, total_count = await _publication_counts(
+        db_session,
+        user_id=current_user.id,
+        selected_scholar_id=selected_scholar_id,
+        favorite_only=favorite_only,
+    )
+    data = _publications_list_data(
+        mode=resolved_mode,
+        favorite_only=favorite_only,
+        selected_scholar_id=selected_scholar_id,
+        unread_count=unread_count,
+        favorites_count=favorites_count,
+        latest_count=latest_count,
+        total_count=total_count,
+        publications=publications,
+        page=resolved_page,
+        page_size=resolved_limit,
+        offset=resolved_offset,
+    )
+    return success_payload(request, data=data)
+
+
+@router.post(
+    "/mark-all-read",
+    response_model=MarkAllReadEnvelope,
+)
+async def mark_all_publications_read(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    updated_count = await publication_service.mark_all_unread_as_read_for_user(
+        db_session,
+        user_id=current_user.id,
+    )
+    logger.info(
+        "api.publications.mark_all_read",
+        extra={
+            "event": "api.publications.mark_all_read",
+            "user_id": current_user.id,
+            "updated_count": updated_count,
+        },
+    )
+    return success_payload(
+        request,
+        data={
+            "message": "Marked all unread publications as read.",
+            "updated_count": updated_count,
+        },
+    )
+
+
+@router.post(
+    "/mark-read",
+    response_model=MarkSelectedReadEnvelope,
+)
+async def mark_selected_publications_read(
+    payload: MarkSelectedReadRequest,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    selection_pairs = sorted(
+        {
+            (int(item.scholar_profile_id), int(item.publication_id))
+            for item in payload.selections
+        }
+    )
+    updated_count = await publication_service.mark_selected_as_read_for_user(
+        db_session,
+        user_id=current_user.id,
+        selections=selection_pairs,
+    )
+    logger.info(
+        "api.publications.mark_selected_read",
+        extra={
+            "event": "api.publications.mark_selected_read",
+            "user_id": current_user.id,
+            "requested_count": len(selection_pairs),
+            "updated_count": updated_count,
+        },
+    )
+    return success_payload(
+        request,
+        data={
+            "message": "Marked selected publications as read.",
+            "requested_count": len(selection_pairs),
+            "updated_count": updated_count,
+        },
+    )
+
+
+@router.post(
+    "/{publication_id}/retry-pdf",
+    response_model=RetryPublicationPdfEnvelope,
+)
+async def retry_publication_pdf(
+    payload: RetryPublicationPdfRequest,
+    request: Request,
+    publication_id: int = Path(ge=1),
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    current, queued = await _retry_publication_state(
+        db_session,
+        current_user=current_user,
+        scholar_profile_id=payload.scholar_profile_id,
+        publication_id=publication_id,
+    )
+    resolved_pdf = bool(current.pdf_url)
+    message = _retry_pdf_message(
+        queued=queued,
+        resolved_pdf=resolved_pdf,
+        pdf_status=current.pdf_status,
+    )
+    _log_retry_pdf_result(
+        current_user=current_user,
+        scholar_profile_id=payload.scholar_profile_id,
+        publication_id=publication_id,
+        queued=queued,
+        resolved_pdf=resolved_pdf,
+        pdf_status=current.pdf_status,
+        doi=None,
+    )
+    return success_payload(
+        request,
+        data={
+            "message": message,
+            "queued": queued,
+            "resolved_pdf": resolved_pdf,
+            "publication": _serialize_publication_item(current),
+        },
+    )
+
+
+@router.post(
+    "/{publication_id}/favorite",
+    response_model=TogglePublicationFavoriteEnvelope,
+)
+async def toggle_publication_favorite(
+    payload: TogglePublicationFavoriteRequest,
+    request: Request,
+    publication_id: int = Path(ge=1),
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    current = await _favorite_publication_state(
+        db_session,
+        current_user=current_user,
+        scholar_profile_id=payload.scholar_profile_id,
+        publication_id=publication_id,
+        is_favorite=payload.is_favorite,
+    )
+    logger.info(
+        "api.publications.favorite",
+        extra={
+            "event": "api.publications.favorite",
+            "user_id": current_user.id,
+            "scholar_profile_id": payload.scholar_profile_id,
+            "publication_id": publication_id,
+            "is_favorite": bool(payload.is_favorite),
+        },
+    )
+    return success_payload(
+        request,
+        data={
+            "message": _favorite_message(is_favorite=bool(payload.is_favorite)),
+            "publication": _serialize_publication_item(current),
+        },
+    )
diff --git a/build/lib/app/api/routers/runs.py b/build/lib/app/api/routers/runs.py
new file mode 100644
index 0000000..4e85af4
--- /dev/null
+++ b/build/lib/app/api/routers/runs.py
@@ -0,0 +1,845 @@
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+from fastapi import APIRouter, Depends, Query, Request
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import get_api_current_user
+from app.api.errors import ApiException
+from app.api.responses import success_payload
+from fastapi.responses import StreamingResponse
+from app.api.schemas import (
+    ManualRunEnvelope,
+    QueueClearEnvelope,
+    QueueItemEnvelope,
+    QueueListEnvelope,
+    RunDetailEnvelope,
+    RunsListEnvelope,
+)
+from app.db.models import RunStatus, RunTriggerType, User
+from app.db.session import get_db_session
+from app.services.domains.ingestion import application as ingestion_service
+from app.services.domains.ingestion import safety as run_safety_service
+from app.services.domains.runs import application as run_service
+from app.services.domains.runs.events import event_generator
+from app.services.domains.settings import application as user_settings_service
+from app.settings import settings
+from app.api.runtime_deps import get_ingestion_service
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/runs", tags=["api-runs"])
+
+IDEMPOTENCY_HEADER = "Idempotency-Key"
+IDEMPOTENCY_MAX_LENGTH = 128
+IDEMPOTENCY_PATTERN = re.compile(r"^[A-Za-z0-9._:-]{8,128}$")
+
+
+def _int_value(value: Any, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _str_value(value: Any) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    return text if text else None
+
+
+def _bool_value(value: Any, default: bool = False) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        lowered = value.strip().lower()
+        if lowered in {"1", "true", "yes", "on"}:
+            return True
+        if lowered in {"0", "false", "no", "off"}:
+            return False
+    return default
+
+
+def _normalize_idempotency_key(raw_value: str | None) -> str | None:
+    if raw_value is None:
+        return None
+    candidate = raw_value.strip()
+    if not candidate:
+        return None
+    if len(candidate) > IDEMPOTENCY_MAX_LENGTH or not IDEMPOTENCY_PATTERN.match(candidate):
+        raise ApiException(
+            status_code=400,
+            code="invalid_idempotency_key",
+            message=(
+                "Invalid Idempotency-Key. Use 8-128 characters from: "
+                "A-Z a-z 0-9 . _ : -"
+            ),
+        )
+    return candidate
+
+
+def _serialize_run(run) -> dict[str, Any]:
+    summary = run_service.extract_run_summary(run.error_log)
+    return {
+        "id": int(run.id),
+        "trigger_type": run.trigger_type.value,
+        "status": run.status.value,
+        "start_dt": run.start_dt,
+        "end_dt": run.end_dt,
+        "scholar_count": int(run.scholar_count or 0),
+        "new_publication_count": int(run.new_pub_count or 0),
+        "failed_count": int(summary["failed_count"]),
+        "partial_count": int(summary["partial_count"]),
+    }
+
+
+def _serialize_queue_item(item) -> dict[str, Any]:
+    return {
+        "id": int(item.id),
+        "scholar_profile_id": int(item.scholar_profile_id),
+        "scholar_label": item.scholar_label,
+        "status": item.status,
+        "reason": item.reason,
+        "dropped_reason": item.dropped_reason,
+        "attempt_count": int(item.attempt_count),
+        "resume_cstart": int(item.resume_cstart),
+        "next_attempt_dt": item.next_attempt_dt,
+        "updated_at": item.updated_at,
+        "last_error": item.last_error,
+        "last_run_id": item.last_run_id,
+    }
+
+
+def _normalize_attempt_log(value: Any) -> list[dict[str, Any]]:
+    if not isinstance(value, list):
+        return []
+    normalized: list[dict[str, Any]] = []
+    for item in value:
+        if not isinstance(item, dict):
+            continue
+        normalized.append(
+            {
+                "attempt": _int_value(item.get("attempt"), 0),
+                "cstart": _int_value(item.get("cstart"), 0),
+                "state": _str_value(item.get("state")),
+                "state_reason": _str_value(item.get("state_reason")),
+                "status_code": (
+                    _int_value(item.get("status_code"))
+                    if item.get("status_code") is not None
+                    else None
+                ),
+                "fetch_error": _str_value(item.get("fetch_error")),
+            }
+        )
+    return normalized
+
+
+def _normalize_page_logs(value: Any) -> list[dict[str, Any]]:
+    if not isinstance(value, list):
+        return []
+    normalized: list[dict[str, Any]] = []
+    for item in value:
+        if not isinstance(item, dict):
+            continue
+        warning_codes = item.get("warning_codes")
+        normalized.append(
+            {
+                "page": _int_value(item.get("page"), 0),
+                "cstart": _int_value(item.get("cstart"), 0),
+                "state": _str_value(item.get("state")) or "unknown",
+                "state_reason": _str_value(item.get("state_reason")),
+                "status_code": (
+                    _int_value(item.get("status_code"))
+                    if item.get("status_code") is not None
+                    else None
+                ),
+                "publication_count": _int_value(item.get("publication_count"), 0),
+                "attempt_count": _int_value(item.get("attempt_count"), 0),
+                "has_show_more_button": _bool_value(item.get("has_show_more_button"), False),
+                "articles_range": _str_value(item.get("articles_range")),
+                "warning_codes": [
+                    str(code)
+                    for code in (warning_codes if isinstance(warning_codes, list) else [])
+                ],
+            }
+        )
+    return normalized
+
+
+def _normalize_debug(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    marker_counts = value.get("marker_counts_nonzero")
+    warning_codes = value.get("warning_codes")
+    return {
+        "status_code": (
+            _int_value(value.get("status_code"))
+            if value.get("status_code") is not None
+            else None
+        ),
+        "final_url": _str_value(value.get("final_url")),
+        "fetch_error": _str_value(value.get("fetch_error")),
+        "body_sha256": _str_value(value.get("body_sha256")),
+        "body_length": (
+            _int_value(value.get("body_length"))
+            if value.get("body_length") is not None
+            else None
+        ),
+        "has_show_more_button": (
+            _bool_value(value.get("has_show_more_button"), False)
+            if value.get("has_show_more_button") is not None
+            else None
+        ),
+        "articles_range": _str_value(value.get("articles_range")),
+        "state_reason": _str_value(value.get("state_reason")),
+        "warning_codes": [
+            str(code)
+            for code in (warning_codes if isinstance(warning_codes, list) else [])
+        ],
+        "marker_counts_nonzero": {
+            str(key): _int_value(count, 0)
+            for key, count in (marker_counts.items() if isinstance(marker_counts, dict) else [])
+        },
+        "page_logs": _normalize_page_logs(value.get("page_logs")),
+        "attempt_log": _normalize_attempt_log(value.get("attempt_log")),
+    }
+
+
+def _normalize_scholar_result(value: Any) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        return {
+            "scholar_profile_id": 0,
+            "scholar_id": "unknown",
+            "state": "unknown",
+            "state_reason": None,
+            "outcome": "failed",
+            "attempt_count": 0,
+            "publication_count": 0,
+            "start_cstart": 0,
+            "continuation_cstart": None,
+            "continuation_enqueued": False,
+            "continuation_cleared": False,
+            "warnings": [],
+            "error": None,
+            "debug": None,
+        }
+    warnings = value.get("warnings")
+    return {
+        "scholar_profile_id": _int_value(value.get("scholar_profile_id"), 0),
+        "scholar_id": _str_value(value.get("scholar_id")) or "unknown",
+        "state": _str_value(value.get("state")) or "unknown",
+        "state_reason": _str_value(value.get("state_reason")),
+        "outcome": _str_value(value.get("outcome")) or "failed",
+        "attempt_count": _int_value(value.get("attempt_count"), 0),
+        "publication_count": _int_value(value.get("publication_count"), 0),
+        "start_cstart": _int_value(value.get("start_cstart"), 0),
+        "continuation_cstart": (
+            _int_value(value.get("continuation_cstart"))
+            if value.get("continuation_cstart") is not None
+            else None
+        ),
+        "continuation_enqueued": _bool_value(value.get("continuation_enqueued"), False),
+        "continuation_cleared": _bool_value(value.get("continuation_cleared"), False),
+        "warnings": [str(item) for item in (warnings if isinstance(warnings, list) else [])],
+        "error": _str_value(value.get("error")),
+        "debug": _normalize_debug(value.get("debug")),
+    }
+
+
+def _manual_run_payload_from_run(
+    run,
+    *,
+    idempotency_key: str | None,
+    reused_existing_run: bool,
+    safety_state: dict[str, Any],
+) -> dict[str, Any]:
+    summary = run_service.extract_run_summary(run.error_log)
+    return {
+        "run_id": int(run.id),
+        "status": run.status.value,
+        "scholar_count": int(run.scholar_count or 0),
+        "succeeded_count": int(summary["succeeded_count"]),
+        "failed_count": int(summary["failed_count"]),
+        "partial_count": int(summary["partial_count"]),
+        "new_publication_count": int(run.new_pub_count or 0),
+        "reused_existing_run": reused_existing_run,
+        "idempotency_key": idempotency_key,
+        "safety_state": safety_state,
+    }
+
+
+async def _load_safety_state(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+) -> dict[str, Any]:
+    user_settings = await user_settings_service.get_or_create_settings(
+        db_session,
+        user_id=user_id,
+    )
+    previous_safety_state = run_safety_service.get_safety_event_context(user_settings)
+    if run_safety_service.clear_expired_cooldown(user_settings):
+        await db_session.commit()
+        await db_session.refresh(user_settings)
+        logger.info(
+            "api.runs.safety_cooldown_cleared",
+            extra={
+                "event": "api.runs.safety_cooldown_cleared",
+                "user_id": user_id,
+                "reason": previous_safety_state.get("cooldown_reason"),
+                "cooldown_until": previous_safety_state.get("cooldown_until"),
+                "metric_name": "api_runs_safety_cooldown_cleared_total",
+                "metric_value": 1,
+            },
+    )
+    return run_safety_service.get_safety_state_payload(user_settings)
+
+
+def _raise_manual_runs_disabled(*, user_id: int, safety_state: dict[str, Any]) -> None:
+    logger.warning(
+        "api.runs.manual_blocked_policy",
+        extra={
+            "event": "api.runs.manual_blocked_policy",
+            "user_id": user_id,
+            "policy": {"manual_run_allowed": False},
+            "safety_state": safety_state,
+            "metric_name": "api_runs_manual_blocked_policy_total",
+            "metric_value": 1,
+        },
+    )
+    raise ApiException(
+        status_code=403,
+        code="manual_runs_disabled",
+        message="Manual checks are disabled by server policy.",
+        details={
+            "policy": {"manual_run_allowed": False},
+            "safety_state": safety_state,
+        },
+    )
+
+
+async def _reused_manual_run_payload(
+    db_session: AsyncSession,
+    *,
+    request: Request,
+    user_id: int,
+    idempotency_key: str | None,
+    safety_state: dict[str, Any],
+) -> dict[str, Any] | None:
+    if idempotency_key is None:
+        return None
+    previous_run = await run_service.get_manual_run_by_idempotency_key(
+        db_session,
+        user_id=user_id,
+        idempotency_key=idempotency_key,
+    )
+    if previous_run is None:
+        return None
+    if previous_run.status == RunStatus.RUNNING:
+        raise ApiException(
+            status_code=409,
+            code="run_in_progress",
+            message="A run with this idempotency key is still in progress.",
+            details={"run_id": int(previous_run.id), "idempotency_key": idempotency_key},
+        )
+    return success_payload(
+        request,
+        data=_manual_run_payload_from_run(
+            previous_run,
+            idempotency_key=idempotency_key,
+            reused_existing_run=True,
+            safety_state=safety_state,
+        ),
+    )
+
+
+async def _run_ingestion_for_manual(
+    db_session: AsyncSession,
+    *,
+    ingest_service: ingestion_service.ScholarIngestionService,
+    user_id: int,
+    idempotency_key: str | None,
+):
+    user_settings = await user_settings_service.get_or_create_settings(
+        db_session,
+        user_id=user_id,
+    )
+    return await ingest_service.run_for_user(
+        db_session,
+        user_id=user_id,
+        trigger_type=RunTriggerType.MANUAL,
+        request_delay_seconds=user_settings.request_delay_seconds,
+        network_error_retries=settings.ingestion_network_error_retries,
+        retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
+        max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
+        page_size=settings.ingestion_page_size,
+        auto_queue_continuations=settings.ingestion_continuation_queue_enabled,
+        queue_delay_seconds=settings.ingestion_continuation_base_delay_seconds,
+        idempotency_key=idempotency_key,
+        alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
+        alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
+        alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
+    )
+
+
+async def _recover_integrity_error(
+    db_session: AsyncSession,
+    *,
+    request: Request,
+    user_id: int,
+    idempotency_key: str | None,
+    original_exc: IntegrityError,
+) -> dict[str, Any]:
+    if idempotency_key is None:
+        logger.exception(
+            "api.runs.manual_integrity_error",
+            extra={"event": "api.runs.manual_integrity_error", "user_id": user_id},
+        )
+        raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
+    existing_run = await run_service.get_manual_run_by_idempotency_key(
+        db_session,
+        user_id=user_id,
+        idempotency_key=idempotency_key,
+    )
+    if existing_run is None:
+        logger.exception(
+            "api.runs.manual_integrity_error",
+            extra={"event": "api.runs.manual_integrity_error", "user_id": user_id},
+        )
+        raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
+    if existing_run.status == RunStatus.RUNNING:
+        raise ApiException(
+            status_code=409,
+            code="run_in_progress",
+            message="A run with this idempotency key is still in progress.",
+            details={"run_id": int(existing_run.id), "idempotency_key": idempotency_key},
+        ) from original_exc
+    return success_payload(
+        request,
+        data=_manual_run_payload_from_run(
+            existing_run,
+            idempotency_key=idempotency_key,
+            reused_existing_run=True,
+            safety_state=await _load_safety_state(db_session, user_id=user_id),
+        ),
+    )
+
+
+async def _execute_manual_run(
+    db_session: AsyncSession,
+    *,
+    request: Request,
+    ingest_service: ingestion_service.ScholarIngestionService,
+    user_id: int,
+    idempotency_key: str | None,
+):
+    try:
+        return await _run_ingestion_for_manual(
+            db_session,
+            ingest_service=ingest_service,
+            user_id=user_id,
+            idempotency_key=idempotency_key,
+        )
+    except ingestion_service.RunAlreadyInProgressError as exc:
+        await db_session.rollback()
+        raise ApiException(
+            status_code=409,
+            code="run_in_progress",
+            message="A run is already in progress for this account.",
+        ) from exc
+    except ingestion_service.RunBlockedBySafetyPolicyError as exc:
+        await db_session.rollback()
+        _raise_manual_blocked_safety(exc=exc, user_id=user_id)
+    except IntegrityError as exc:
+        await db_session.rollback()
+        return await _recover_integrity_error(
+            db_session,
+            request=request,
+            user_id=user_id,
+            idempotency_key=idempotency_key,
+            original_exc=exc,
+        )
+    except Exception as exc:
+        await db_session.rollback()
+        _raise_manual_failed(exc=exc, user_id=user_id)
+
+
+def _raise_manual_blocked_safety(*, exc, user_id: int) -> None:
+    logger.info(
+        "api.runs.manual_blocked_safety",
+        extra={
+            "event": "api.runs.manual_blocked_safety",
+            "user_id": user_id,
+            "reason": exc.safety_state.get("cooldown_reason"),
+            "cooldown_until": exc.safety_state.get("cooldown_until"),
+            "cooldown_remaining_seconds": exc.safety_state.get("cooldown_remaining_seconds"),
+            "metric_name": "api_runs_manual_blocked_safety_total",
+            "metric_value": 1,
+        },
+    )
+    raise ApiException(
+        status_code=429,
+        code=exc.code,
+        message=exc.message,
+        details={"safety_state": exc.safety_state},
+    ) from exc
+
+
+def _raise_manual_failed(*, exc: Exception, user_id: int) -> None:
+    logger.exception(
+        "api.runs.manual_failed",
+        extra={"event": "api.runs.manual_failed", "user_id": user_id},
+    )
+    raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from exc
+
+
+def _manual_run_success_payload(
+    *,
+    run_summary,
+    idempotency_key: str | None,
+    safety_state: dict[str, Any],
+) -> dict[str, Any]:
+    return {
+        "run_id": run_summary.crawl_run_id,
+        "status": run_summary.status.value,
+        "scholar_count": run_summary.scholar_count,
+        "succeeded_count": run_summary.succeeded_count,
+        "failed_count": run_summary.failed_count,
+        "partial_count": run_summary.partial_count,
+        "new_publication_count": run_summary.new_publication_count,
+        "reused_existing_run": False,
+        "idempotency_key": idempotency_key,
+        "safety_state": safety_state,
+    }
+
+
+@router.get(
+    "",
+    response_model=RunsListEnvelope,
+)
+async def list_runs(
+    request: Request,
+    failed_only: bool = Query(default=False),
+    limit: int = Query(default=100, ge=1, le=500),
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    runs = await run_service.list_runs_for_user(
+        db_session,
+        user_id=current_user.id,
+        limit=limit,
+        failed_only=failed_only,
+    )
+    safety_state = await _load_safety_state(
+        db_session,
+        user_id=current_user.id,
+    )
+    return success_payload(
+        request,
+        data={
+            "runs": [_serialize_run(run) for run in runs],
+            "safety_state": safety_state,
+        },
+    )
+
+
+@router.get(
+    "/{run_id}",
+    response_model=RunDetailEnvelope,
+)
+async def get_run(
+    run_id: int,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    run = await run_service.get_run_for_user(
+        db_session,
+        user_id=current_user.id,
+        run_id=run_id,
+    )
+    if run is None:
+        raise ApiException(
+            status_code=404,
+            code="run_not_found",
+            message="Run not found.",
+        )
+    error_log = run.error_log if isinstance(run.error_log, dict) else {}
+    scholar_results = error_log.get("scholar_results")
+    if not isinstance(scholar_results, list):
+        scholar_results = []
+    safety_state = await _load_safety_state(
+        db_session,
+        user_id=current_user.id,
+    )
+    return success_payload(
+        request,
+        data={
+            "run": _serialize_run(run),
+            "summary": run_service.extract_run_summary(error_log),
+            "scholar_results": [_normalize_scholar_result(item) for item in scholar_results],
+            "safety_state": safety_state,
+        },
+    )
+
+
+@router.post(
+    "/{run_id}/cancel",
+    response_model=RunDetailEnvelope,
+)
+async def cancel_run(
+    run_id: int,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    run = await run_service.get_run_for_user(
+        db_session,
+        user_id=current_user.id,
+        run_id=run_id,
+    )
+    if run is None:
+        raise ApiException(
+            status_code=404,
+            code="run_not_found",
+            message="Run not found.",
+        )
+        
+    if run.status == RunStatus.RUNNING:
+        run.status = RunStatus.CANCELED
+        await db_session.commit()
+        await db_session.refresh(run)
+
+    error_log = run.error_log if isinstance(run.error_log, dict) else {}
+    scholar_results = error_log.get("scholar_results")
+    if not isinstance(scholar_results, list):
+        scholar_results = []
+        
+    safety_state = await _load_safety_state(
+        db_session,
+        user_id=current_user.id,
+    )
+    
+    return success_payload(
+        request,
+        data={
+            "run": _serialize_run(run),
+            "summary": run_service.extract_run_summary(error_log),
+            "scholar_results": [_normalize_scholar_result(item) for item in scholar_results],
+            "safety_state": safety_state,
+        },
+    )
+
+
+@router.post(
+    "/manual",
+    response_model=ManualRunEnvelope,
+)
+async def run_manual(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+    ingest_service: ingestion_service.ScholarIngestionService = Depends(get_ingestion_service),
+):
+    safety_state = await _load_safety_state(
+        db_session,
+        user_id=current_user.id,
+    )
+    if not settings.ingestion_manual_run_allowed:
+        _raise_manual_runs_disabled(user_id=current_user.id, safety_state=safety_state)
+
+    idempotency_key = _normalize_idempotency_key(request.headers.get(IDEMPOTENCY_HEADER))
+    reused_payload = await _reused_manual_run_payload(
+        db_session,
+        request=request,
+        user_id=current_user.id,
+        idempotency_key=idempotency_key,
+        safety_state=safety_state,
+    )
+    if reused_payload is not None:
+        return reused_payload
+
+    run_summary = await _execute_manual_run(
+        db_session,
+        request=request,
+        ingest_service=ingest_service,
+        user_id=current_user.id,
+        idempotency_key=idempotency_key,
+    )
+    if isinstance(run_summary, dict):
+        return run_summary
+
+    current_safety_state = await _load_safety_state(
+        db_session,
+        user_id=current_user.id,
+    )
+    return success_payload(
+        request,
+        data=_manual_run_success_payload(
+            run_summary=run_summary,
+            idempotency_key=idempotency_key,
+            safety_state=current_safety_state,
+        ),
+    )
+
+
+
+@router.get(
+    "/queue/items",
+    response_model=QueueListEnvelope,
+)
+async def list_queue_items(
+    request: Request,
+    limit: int = Query(default=200, ge=1, le=500),
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    items = await run_service.list_queue_items_for_user(
+        db_session,
+        user_id=current_user.id,
+        limit=limit,
+    )
+    return success_payload(
+        request,
+        data={
+            "queue_items": [_serialize_queue_item(item) for item in items],
+        },
+    )
+
+
+@router.post(
+    "/queue/{queue_item_id}/retry",
+    response_model=QueueItemEnvelope,
+)
+async def retry_queue_item(
+    queue_item_id: int,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    try:
+        queue_item = await run_service.retry_queue_item_for_user(
+            db_session,
+            user_id=current_user.id,
+            queue_item_id=queue_item_id,
+        )
+    except run_service.QueueTransitionError as exc:
+        raise ApiException(
+            status_code=409,
+            code=exc.code,
+            message=exc.message,
+            details={"current_status": exc.current_status},
+        ) from exc
+    if queue_item is None:
+        raise ApiException(
+            status_code=404,
+            code="queue_item_not_found",
+            message="Queue item not found.",
+        )
+    return success_payload(
+        request,
+        data=_serialize_queue_item(queue_item),
+    )
+
+
+@router.post(
+    "/queue/{queue_item_id}/drop",
+    response_model=QueueItemEnvelope,
+)
+async def drop_queue_item(
+    queue_item_id: int,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    try:
+        dropped = await run_service.drop_queue_item_for_user(
+            db_session,
+            user_id=current_user.id,
+            queue_item_id=queue_item_id,
+        )
+    except run_service.QueueTransitionError as exc:
+        raise ApiException(
+            status_code=409,
+            code=exc.code,
+            message=exc.message,
+            details={"current_status": exc.current_status},
+        ) from exc
+    if dropped is None:
+        raise ApiException(
+            status_code=404,
+            code="queue_item_not_found",
+            message="Queue item not found.",
+        )
+    return success_payload(
+        request,
+        data=_serialize_queue_item(dropped),
+    )
+
+
+@router.delete(
+    "/queue/{queue_item_id}",
+    response_model=QueueClearEnvelope,
+)
+async def clear_queue_item(
+    queue_item_id: int,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    try:
+        deleted = await run_service.clear_queue_item_for_user(
+            db_session,
+            user_id=current_user.id,
+            queue_item_id=queue_item_id,
+        )
+    except run_service.QueueTransitionError as exc:
+        raise ApiException(
+            status_code=409,
+            code=exc.code,
+            message=exc.message,
+            details={"current_status": exc.current_status},
+        ) from exc
+    if deleted is None:
+        raise ApiException(
+            status_code=404,
+            code="queue_item_not_found",
+            message="Queue item not found.",
+        )
+    return success_payload(
+        request,
+        data={
+            "queue_item_id": deleted.queue_item_id,
+            "previous_status": deleted.previous_status,
+            "status": "cleared",
+            "message": "Queue item cleared.",
+        },
+    )
+
+
+@router.get("/{run_id}/stream")
+async def stream_run_events(
+    run_id: int,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    run = await run_service.get_run_for_user(
+        db_session,
+        user_id=current_user.id,
+        run_id=run_id,
+    )
+    if run is None:
+        raise ApiException(
+            status_code=404,
+            code="run_not_found",
+            message="Run not found.",
+        )
+    return StreamingResponse(
+        event_generator(run_id),
+        media_type="text/event-stream"
+    )
diff --git a/build/lib/app/api/routers/scholars.py b/build/lib/app/api/routers/scholars.py
new file mode 100644
index 0000000..f4be187
--- /dev/null
+++ b/build/lib/app/api/routers/scholars.py
@@ -0,0 +1,557 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+
+from fastapi import APIRouter, Depends, File, Query, Request, UploadFile
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import get_api_current_user
+from app.api.errors import ApiException
+from app.api.responses import success_payload
+from app.api.runtime_deps import get_scholar_source
+from app.api.schemas import (
+    DataExportEnvelope,
+    DataImportEnvelope,
+    DataImportRequest,
+    MessageEnvelope,
+    ScholarCreateRequest,
+    ScholarEnvelope,
+    ScholarImageUrlUpdateRequest,
+    ScholarSearchEnvelope,
+    ScholarsListEnvelope,
+)
+from app.db.models import User
+from app.db.session import get_db_session
+from app.services.domains.portability import application as import_export_service
+from app.services.domains.scholars import application as scholar_service
+from app.services.domains.scholar.source import ScholarSource
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/scholars", tags=["api-scholars"])
+
+
+def _uploaded_image_media_path(scholar_profile_id: int) -> str:
+    return f"/scholar-images/{scholar_profile_id}/upload"
+
+
+def _serialize_scholar(profile) -> dict[str, object]:
+    uploaded_image_url = None
+    if profile.profile_image_upload_path:
+        uploaded_image_url = _uploaded_image_media_path(int(profile.id))
+
+    profile_image_url, profile_image_source = scholar_service.resolve_profile_image(
+        profile,
+        uploaded_image_url=uploaded_image_url,
+    )
+
+    return {
+        "id": int(profile.id),
+        "scholar_id": profile.scholar_id,
+        "display_name": profile.display_name,
+        "profile_image_url": profile_image_url,
+        "profile_image_source": profile_image_source,
+        "is_enabled": bool(profile.is_enabled),
+        "baseline_completed": bool(profile.baseline_completed),
+        "last_run_dt": profile.last_run_dt,
+        "last_run_status": (
+            profile.last_run_status.value if profile.last_run_status is not None else None
+        ),
+    }
+
+
+async def _hydrate_scholar_metadata_if_needed(
+    db_session: AsyncSession,
+    *,
+    profile,
+    source: ScholarSource,
+    user_id: int,
+):
+    try:
+        if not profile.profile_image_url or not (profile.display_name or "").strip():
+            return await asyncio.wait_for(
+                scholar_service.hydrate_profile_metadata(
+                    db_session,
+                    profile=profile,
+                    source=source,
+                ),
+                timeout=5.0,
+            )
+    except Exception:
+        logger.warning(
+            "api.scholars.create_metadata_hydration_failed",
+            extra={
+                "event": "api.scholars.create_metadata_hydration_failed",
+                "user_id": user_id,
+                "scholar_profile_id": profile.id,
+            },
+        )
+    return profile
+
+
+def _search_kwargs() -> dict[str, object]:
+    return {
+        "network_error_retries": settings.ingestion_network_error_retries,
+        "retry_backoff_seconds": settings.ingestion_retry_backoff_seconds,
+        "search_enabled": settings.scholar_name_search_enabled,
+        "cache_ttl_seconds": settings.scholar_name_search_cache_ttl_seconds,
+        "blocked_cache_ttl_seconds": settings.scholar_name_search_blocked_cache_ttl_seconds,
+        "cache_max_entries": settings.scholar_name_search_cache_max_entries,
+        "min_interval_seconds": settings.scholar_name_search_min_interval_seconds,
+        "interval_jitter_seconds": settings.scholar_name_search_interval_jitter_seconds,
+        "cooldown_block_threshold": settings.scholar_name_search_cooldown_block_threshold,
+        "cooldown_seconds": settings.scholar_name_search_cooldown_seconds,
+        "retry_alert_threshold": settings.scholar_name_search_alert_retry_count_threshold,
+        "cooldown_rejection_alert_threshold": (
+            settings.scholar_name_search_alert_cooldown_rejections_threshold
+        ),
+    }
+
+
+def _search_response_data(query: str, parsed) -> dict[str, object]:
+    return {
+        "query": query.strip(),
+        "state": parsed.state.value,
+        "state_reason": parsed.state_reason,
+        "action_hint": scholar_service.scrape_state_hint(
+            state=parsed.state,
+            state_reason=parsed.state_reason,
+        ),
+        "candidates": [
+            {
+                "scholar_id": item.scholar_id,
+                "display_name": item.display_name,
+                "affiliation": item.affiliation,
+                "email_domain": item.email_domain,
+                "cited_by_count": item.cited_by_count,
+                "interests": item.interests,
+                "profile_url": item.profile_url,
+                "profile_image_url": item.profile_image_url,
+            }
+            for item in parsed.candidates
+        ],
+        "warnings": parsed.warnings,
+    }
+
+
+async def _read_uploaded_image(image: UploadFile) -> bytes:
+    try:
+        return await image.read()
+    finally:
+        await image.close()
+
+
+async def _require_user_profile(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int,
+):
+    profile = await scholar_service.get_user_scholar_by_id(
+        db_session,
+        user_id=user_id,
+        scholar_profile_id=scholar_profile_id,
+    )
+    if profile is None:
+        raise ApiException(
+            status_code=404,
+            code="scholar_not_found",
+            message="Scholar not found.",
+        )
+    return profile
+
+
+@router.get(
+    "",
+    response_model=ScholarsListEnvelope,
+)
+async def list_scholars(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    scholars = await scholar_service.list_scholars_for_user(
+        db_session,
+        user_id=current_user.id,
+    )
+    return success_payload(
+        request,
+        data={
+            "scholars": [_serialize_scholar(profile) for profile in scholars],
+        },
+    )
+
+
+@router.get(
+    "/export",
+    response_model=DataExportEnvelope,
+)
+async def export_scholars_and_publications(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    data = await import_export_service.export_user_data(
+        db_session,
+        user_id=current_user.id,
+    )
+    return success_payload(request, data=data)
+
+
+@router.post(
+    "/import",
+    response_model=DataImportEnvelope,
+)
+async def import_scholars_and_publications(
+    payload: DataImportRequest,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    if (
+        payload.schema_version is not None
+        and int(payload.schema_version) != import_export_service.EXPORT_SCHEMA_VERSION
+    ):
+        raise ApiException(
+            status_code=400,
+            code="invalid_import_schema_version",
+            message=(
+                "Import schema version is not supported. "
+                f"Expected {import_export_service.EXPORT_SCHEMA_VERSION}."
+            ),
+        )
+    try:
+        result = await import_export_service.import_user_data(
+            db_session,
+            user_id=current_user.id,
+            scholars=[item.model_dump() for item in payload.scholars],
+            publications=[item.model_dump() for item in payload.publications],
+        )
+    except import_export_service.ImportExportError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_import_payload",
+            message=str(exc),
+        ) from exc
+    logger.info(
+        "api.scholars.imported",
+        extra={
+            "event": "api.scholars.imported",
+            "user_id": current_user.id,
+            **result,
+        },
+    )
+    return success_payload(request, data=result)
+
+
+@router.post(
+    "",
+    response_model=ScholarEnvelope,
+    status_code=201,
+)
+async def create_scholar(
+    payload: ScholarCreateRequest,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    source: ScholarSource = Depends(get_scholar_source),
+    current_user: User = Depends(get_api_current_user),
+):
+    try:
+        created = await scholar_service.create_scholar_for_user(
+            db_session,
+            user_id=current_user.id,
+            scholar_id=payload.scholar_id,
+            display_name="",
+            profile_image_url=payload.profile_image_url,
+        )
+    except scholar_service.ScholarServiceError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_scholar",
+            message=str(exc),
+        ) from exc
+    logger.info(
+        "api.scholars.created",
+        extra={
+            "event": "api.scholars.created",
+            "user_id": current_user.id,
+            "scholar_profile_id": created.id,
+        },
+    )
+    created = await _hydrate_scholar_metadata_if_needed(
+        db_session,
+        profile=created,
+        source=source,
+        user_id=current_user.id,
+    )
+
+    return success_payload(
+        request,
+        data=_serialize_scholar(created),
+    )
+
+
+@router.get(
+    "/search",
+    response_model=ScholarSearchEnvelope,
+)
+async def search_scholars(
+    request: Request,
+    query: str = Query(..., min_length=2, max_length=120),
+    limit: int = Query(10, ge=1, le=25),
+    db_session: AsyncSession = Depends(get_db_session),
+    source: ScholarSource = Depends(get_scholar_source),
+    current_user: User = Depends(get_api_current_user),
+):
+    try:
+        parsed = await scholar_service.search_author_candidates(
+            source=source,
+            db_session=db_session,
+            query=query,
+            limit=limit,
+            **_search_kwargs(),
+        )
+    except scholar_service.ScholarServiceError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_scholar_search",
+            message=str(exc),
+        ) from exc
+
+    logger.info(
+        "api.scholars.search.completed",
+        extra={
+            "event": "api.scholars.search.completed",
+            "user_id": current_user.id,
+            "query": query.strip(),
+            "candidate_count": len(parsed.candidates),
+            "state": parsed.state.value,
+        },
+    )
+    return success_payload(
+        request,
+        data=_search_response_data(query, parsed),
+    )
+
+
+@router.patch(
+    "/{scholar_profile_id}/toggle",
+    response_model=ScholarEnvelope,
+)
+async def toggle_scholar(
+    scholar_profile_id: int,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    profile = await scholar_service.get_user_scholar_by_id(
+        db_session,
+        user_id=current_user.id,
+        scholar_profile_id=scholar_profile_id,
+    )
+    if profile is None:
+        raise ApiException(
+            status_code=404,
+            code="scholar_not_found",
+            message="Scholar not found.",
+        )
+    updated = await scholar_service.toggle_scholar_enabled(db_session, profile=profile)
+    logger.info(
+        "api.scholars.toggled",
+        extra={
+            "event": "api.scholars.toggled",
+            "user_id": current_user.id,
+            "scholar_profile_id": updated.id,
+            "is_enabled": updated.is_enabled,
+        },
+    )
+    return success_payload(
+        request,
+        data=_serialize_scholar(updated),
+    )
+
+
+@router.delete(
+    "/{scholar_profile_id}",
+    response_model=MessageEnvelope,
+)
+async def delete_scholar(
+    scholar_profile_id: int,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    profile = await scholar_service.get_user_scholar_by_id(
+        db_session,
+        user_id=current_user.id,
+        scholar_profile_id=scholar_profile_id,
+    )
+    if profile is None:
+        raise ApiException(
+            status_code=404,
+            code="scholar_not_found",
+            message="Scholar not found.",
+        )
+    await scholar_service.delete_scholar(
+        db_session,
+        profile=profile,
+        upload_dir=settings.scholar_image_upload_dir,
+    )
+    logger.info(
+        "api.scholars.deleted",
+        extra={
+            "event": "api.scholars.deleted",
+            "user_id": current_user.id,
+            "scholar_profile_id": scholar_profile_id,
+        },
+    )
+    return success_payload(
+        request,
+        data={"message": "Scholar deleted."},
+    )
+
+
+@router.put(
+    "/{scholar_profile_id}/image/url",
+    response_model=ScholarEnvelope,
+)
+async def update_scholar_image_url(
+    scholar_profile_id: int,
+    payload: ScholarImageUrlUpdateRequest,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    profile = await scholar_service.get_user_scholar_by_id(
+        db_session,
+        user_id=current_user.id,
+        scholar_profile_id=scholar_profile_id,
+    )
+    if profile is None:
+        raise ApiException(
+            status_code=404,
+            code="scholar_not_found",
+            message="Scholar not found.",
+        )
+
+    try:
+        updated = await scholar_service.set_profile_image_override_url(
+            db_session,
+            profile=profile,
+            image_url=payload.image_url,
+            upload_dir=settings.scholar_image_upload_dir,
+        )
+    except scholar_service.ScholarServiceError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_scholar_image",
+            message=str(exc),
+        ) from exc
+
+    logger.info(
+        "api.scholars.image_url_updated",
+        extra={
+            "event": "api.scholars.image_url_updated",
+            "user_id": current_user.id,
+            "scholar_profile_id": updated.id,
+        },
+    )
+    return success_payload(
+        request,
+        data=_serialize_scholar(updated),
+    )
+
+
+@router.post(
+    "/{scholar_profile_id}/image/upload",
+    response_model=ScholarEnvelope,
+)
+async def upload_scholar_image(
+    scholar_profile_id: int,
+    request: Request,
+    image: UploadFile = File(...),
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    profile = await _require_user_profile(
+        db_session,
+        user_id=current_user.id,
+        scholar_profile_id=scholar_profile_id,
+    )
+
+    image_bytes = await _read_uploaded_image(image)
+    try:
+        updated = await scholar_service.set_profile_image_upload(
+            db_session,
+            profile=profile,
+            content_type=image.content_type,
+            image_bytes=image_bytes,
+            upload_dir=settings.scholar_image_upload_dir,
+            max_upload_bytes=settings.scholar_image_upload_max_bytes,
+        )
+    except scholar_service.ScholarServiceError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_scholar_image",
+            message=str(exc),
+        ) from exc
+
+    image_size = len(image_bytes)
+    logger.info(
+        "api.scholars.image_uploaded",
+        extra={
+            "event": "api.scholars.image_uploaded",
+            "user_id": current_user.id,
+            "scholar_profile_id": updated.id,
+            "content_type": image.content_type,
+            "size_bytes": image_size,
+        },
+    )
+    return success_payload(
+        request,
+        data=_serialize_scholar(updated),
+    )
+
+
+@router.delete(
+    "/{scholar_profile_id}/image",
+    response_model=ScholarEnvelope,
+)
+async def clear_scholar_image_customization(
+    scholar_profile_id: int,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    profile = await scholar_service.get_user_scholar_by_id(
+        db_session,
+        user_id=current_user.id,
+        scholar_profile_id=scholar_profile_id,
+    )
+    if profile is None:
+        raise ApiException(
+            status_code=404,
+            code="scholar_not_found",
+            message="Scholar not found.",
+        )
+
+    updated = await scholar_service.clear_profile_image_customization(
+        db_session,
+        profile=profile,
+        upload_dir=settings.scholar_image_upload_dir,
+    )
+    logger.info(
+        "api.scholars.image_customization_cleared",
+        extra={
+            "event": "api.scholars.image_customization_cleared",
+            "user_id": current_user.id,
+            "scholar_profile_id": updated.id,
+        },
+    )
+    return success_payload(
+        request,
+        data=_serialize_scholar(updated),
+    )
+
diff --git a/build/lib/app/api/routers/settings.py b/build/lib/app/api/routers/settings.py
new file mode 100644
index 0000000..5a2ef91
--- /dev/null
+++ b/build/lib/app/api/routers/settings.py
@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, Depends, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import get_api_current_user
+from app.api.errors import ApiException
+from app.api.responses import success_payload
+from app.api.schemas import SettingsEnvelope, SettingsUpdateRequest
+from app.db.models import User
+from app.db.session import get_db_session
+from app.services.domains.ingestion import safety as run_safety_service
+from app.services.domains.settings import application as user_settings_service
+from app.settings import settings as settings_module
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/settings", tags=["api-settings"])
+
+
+def _serialize_settings(user_settings) -> dict[str, object]:
+    min_run_interval_minutes, min_request_delay_seconds = _minimum_policy()
+    return {
+        "auto_run_enabled": bool(user_settings.auto_run_enabled) and settings_module.ingestion_automation_allowed,
+        "run_interval_minutes": int(user_settings.run_interval_minutes),
+        "request_delay_seconds": int(user_settings.request_delay_seconds),
+        "nav_visible_pages": list(user_settings.nav_visible_pages or []),
+        "policy": {
+            "min_run_interval_minutes": min_run_interval_minutes,
+            "min_request_delay_seconds": min_request_delay_seconds,
+            "automation_allowed": bool(settings_module.ingestion_automation_allowed),
+            "manual_run_allowed": bool(settings_module.ingestion_manual_run_allowed),
+            "blocked_failure_threshold": max(1, int(settings_module.ingestion_alert_blocked_failure_threshold)),
+            "network_failure_threshold": max(1, int(settings_module.ingestion_alert_network_failure_threshold)),
+            "cooldown_blocked_seconds": max(60, int(settings_module.ingestion_safety_cooldown_blocked_seconds)),
+            "cooldown_network_seconds": max(60, int(settings_module.ingestion_safety_cooldown_network_seconds)),
+        },
+        "safety_state": run_safety_service.get_safety_state_payload(user_settings),
+        "openalex_api_key": user_settings.openalex_api_key,
+        "crossref_api_token": user_settings.crossref_api_token,
+        "crossref_api_mailto": user_settings.crossref_api_mailto,
+    }
+
+
+def _minimum_policy() -> tuple[int, int]:
+    min_run_interval_minutes = user_settings_service.resolve_run_interval_minimum(
+        settings_module.ingestion_min_run_interval_minutes
+    )
+    min_request_delay_seconds = user_settings_service.resolve_request_delay_minimum(
+        settings_module.ingestion_min_request_delay_seconds
+    )
+    return min_run_interval_minutes, min_request_delay_seconds
+
+
+def _parse_settings_payload(payload: SettingsUpdateRequest, user_settings) -> tuple[int, int, list[str]]:
+    min_run_interval_minutes, min_request_delay_seconds = _minimum_policy()
+    parsed_interval = user_settings_service.parse_run_interval_minutes(
+        str(payload.run_interval_minutes),
+        minimum=min_run_interval_minutes,
+    )
+    parsed_delay = user_settings_service.parse_request_delay_seconds(
+        str(payload.request_delay_seconds),
+        minimum=min_request_delay_seconds,
+    )
+    parsed_nav_visible_pages = user_settings_service.parse_nav_visible_pages(
+        payload.nav_visible_pages
+        if payload.nav_visible_pages is not None
+        else list(user_settings.nav_visible_pages or user_settings_service.DEFAULT_NAV_VISIBLE_PAGES)
+    )
+    return parsed_interval, parsed_delay, parsed_nav_visible_pages
+
+
+async def _clear_expired_cooldown_with_log(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    user_settings,
+) -> None:
+    previous_safety_state = run_safety_service.get_safety_event_context(user_settings)
+    if not run_safety_service.clear_expired_cooldown(user_settings):
+        return
+    await db_session.commit()
+    await db_session.refresh(user_settings)
+    logger.info(
+        "api.settings.safety_cooldown_cleared",
+        extra={
+            "event": "api.settings.safety_cooldown_cleared",
+            "user_id": user_id,
+            "reason": previous_safety_state.get("cooldown_reason"),
+            "cooldown_until": previous_safety_state.get("cooldown_until"),
+            "metric_name": "api_settings_safety_cooldown_cleared_total",
+            "metric_value": 1,
+        },
+    )
+
+
+def _effective_auto_run_enabled(payload: SettingsUpdateRequest) -> bool:
+    return bool(payload.auto_run_enabled) and settings_module.ingestion_automation_allowed
+
+
+def _log_settings_update(*, user_id: int, updated) -> None:
+    logger.info(
+        "api.settings.updated",
+        extra={
+            "event": "api.settings.updated",
+            "user_id": user_id,
+            "auto_run_enabled": updated.auto_run_enabled,
+            "run_interval_minutes": updated.run_interval_minutes,
+            "request_delay_seconds": updated.request_delay_seconds,
+            "nav_visible_pages": updated.nav_visible_pages,
+            "openalex_api_key": "SET" if updated.openalex_api_key else "UNSET",
+        },
+    )
+
+
+@router.get(
+    "",
+    response_model=SettingsEnvelope,
+)
+async def get_settings(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    user_settings = await user_settings_service.get_or_create_settings(
+        db_session,
+        user_id=current_user.id,
+    )
+    await _clear_expired_cooldown_with_log(
+        db_session,
+        user_id=current_user.id,
+        user_settings=user_settings,
+    )
+    return success_payload(
+        request,
+        data=_serialize_settings(user_settings),
+    )
+
+
+@router.put(
+    "",
+    response_model=SettingsEnvelope,
+)
+async def update_settings(
+    payload: SettingsUpdateRequest,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_api_current_user),
+):
+    user_settings = await user_settings_service.get_or_create_settings(
+        db_session,
+        user_id=current_user.id,
+    )
+
+    try:
+        parsed_interval, parsed_delay, parsed_nav_visible_pages = _parse_settings_payload(
+            payload,
+            user_settings,
+        )
+    except user_settings_service.UserSettingsServiceError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_settings",
+            message=str(exc),
+        ) from exc
+
+    updated = await user_settings_service.update_settings(
+        db_session,
+        settings=user_settings,
+        auto_run_enabled=_effective_auto_run_enabled(payload),
+        run_interval_minutes=parsed_interval,
+        request_delay_seconds=parsed_delay,
+        nav_visible_pages=parsed_nav_visible_pages,
+        openalex_api_key=payload.openalex_api_key,
+        crossref_api_token=payload.crossref_api_token,
+        crossref_api_mailto=payload.crossref_api_mailto,
+    )
+    await _clear_expired_cooldown_with_log(
+        db_session,
+        user_id=current_user.id,
+        user_settings=updated,
+    )
+    _log_settings_update(user_id=current_user.id, updated=updated)
+    return success_payload(
+        request,
+        data=_serialize_settings(updated),
+    )
diff --git a/build/lib/app/api/runtime_deps.py b/build/lib/app/api/runtime_deps.py
new file mode 100644
index 0000000..3a692a3
--- /dev/null
+++ b/build/lib/app/api/runtime_deps.py
@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from fastapi import Depends
+
+from app.services.domains.ingestion import application as ingestion_service
+from app.services.domains.scholar import source as scholar_source_service
+
+
+def get_scholar_source() -> scholar_source_service.ScholarSource:
+    return scholar_source_service.LiveScholarSource()
+
+
+def get_ingestion_service(
+    source: scholar_source_service.ScholarSource = Depends(get_scholar_source),
+) -> ingestion_service.ScholarIngestionService:
+    return ingestion_service.ScholarIngestionService(source=source)
diff --git a/build/lib/app/api/schemas.py b/build/lib/app/api/schemas.py
new file mode 100644
index 0000000..bac3bb9
--- /dev/null
+++ b/build/lib/app/api/schemas.py
@@ -0,0 +1,884 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class ApiMeta(BaseModel):
+    request_id: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ApiErrorData(BaseModel):
+    code: str
+    message: str
+    details: Any | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ApiErrorEnvelope(BaseModel):
+    error: ApiErrorData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessageData(BaseModel):
+    message: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessageEnvelope(BaseModel):
+    data: MessageData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SessionUserData(BaseModel):
+    id: int
+    email: str
+    is_admin: bool
+    is_active: bool
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AuthMeData(BaseModel):
+    authenticated: bool
+    csrf_token: str
+    user: SessionUserData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AuthMeEnvelope(BaseModel):
+    data: AuthMeData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class CsrfBootstrapData(BaseModel):
+    csrf_token: str
+    authenticated: bool
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class CsrfBootstrapEnvelope(BaseModel):
+    data: CsrfBootstrapData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class LoginRequest(BaseModel):
+    email: str
+    password: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class LoginData(BaseModel):
+    authenticated: bool
+    csrf_token: str
+    user: SessionUserData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class LoginEnvelope(BaseModel):
+    data: LoginData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ChangePasswordRequest(BaseModel):
+    current_password: str
+    new_password: str
+    confirm_password: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarItemData(BaseModel):
+    id: int
+    scholar_id: str
+    display_name: str | None
+    profile_image_url: str | None
+    profile_image_source: str
+    is_enabled: bool
+    baseline_completed: bool
+    last_run_dt: datetime | None
+    last_run_status: str | None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarsListData(BaseModel):
+    scholars: list[ScholarItemData]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarsListEnvelope(BaseModel):
+    data: ScholarsListData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarCreateRequest(BaseModel):
+    scholar_id: str
+    profile_image_url: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarEnvelope(BaseModel):
+    data: ScholarItemData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarSearchCandidateData(BaseModel):
+    scholar_id: str
+    display_name: str
+    affiliation: str | None
+    email_domain: str | None
+    cited_by_count: int | None
+    interests: list[str] = Field(default_factory=list)
+    profile_url: str
+    profile_image_url: str | None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarSearchData(BaseModel):
+    query: str
+    state: str
+    state_reason: str
+    action_hint: str | None = None
+    candidates: list[ScholarSearchCandidateData]
+    warnings: list[str] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarSearchEnvelope(BaseModel):
+    data: ScholarSearchData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarImageUrlUpdateRequest(BaseModel):
+    image_url: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarExportItemData(BaseModel):
+    scholar_id: str
+    display_name: str | None = None
+    is_enabled: bool = True
+    profile_image_override_url: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PublicationExportItemData(BaseModel):
+    scholar_id: str
+    cluster_id: str | None = None
+    fingerprint_sha256: str | None = None
+    title: str
+    year: int | None = None
+    citation_count: int = 0
+    author_text: str | None = None
+    venue_text: str | None = None
+    pub_url: str | None = None
+    pdf_url: str | None = None
+    is_read: bool = False
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DataExportData(BaseModel):
+    schema_version: int
+    exported_at: str
+    scholars: list[ScholarExportItemData]
+    publications: list[PublicationExportItemData]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DataExportEnvelope(BaseModel):
+    data: DataExportData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DataImportRequest(BaseModel):
+    schema_version: int | None = None
+    scholars: list[ScholarExportItemData] = Field(default_factory=list)
+    publications: list[PublicationExportItemData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DataImportResultData(BaseModel):
+    scholars_created: int
+    scholars_updated: int
+    publications_created: int
+    publications_updated: int
+    links_created: int
+    links_updated: int
+    skipped_records: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DataImportEnvelope(BaseModel):
+    data: DataImportResultData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunListItemData(BaseModel):
+    id: int
+    trigger_type: str
+    status: str
+    start_dt: datetime
+    end_dt: datetime | None
+    scholar_count: int
+    new_publication_count: int
+    failed_count: int
+    partial_count: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunsListData(BaseModel):
+    runs: list[RunListItemData]
+    safety_state: ScrapeSafetyStateData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunsListEnvelope(BaseModel):
+    data: RunsListData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunSummaryData(BaseModel):
+    succeeded_count: int
+    failed_count: int
+    partial_count: int
+    failed_state_counts: dict[str, int] = Field(default_factory=dict)
+    failed_reason_counts: dict[str, int] = Field(default_factory=dict)
+    scrape_failure_counts: dict[str, int] = Field(default_factory=dict)
+    retry_counts: dict[str, int] = Field(default_factory=dict)
+    alert_thresholds: dict[str, int] = Field(default_factory=dict)
+    alert_flags: dict[str, bool] = Field(default_factory=dict)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScrapeSafetyCountersData(BaseModel):
+    consecutive_blocked_runs: int = 0
+    consecutive_network_runs: int = 0
+    cooldown_entry_count: int = 0
+    blocked_start_count: int = 0
+    last_blocked_failure_count: int = 0
+    last_network_failure_count: int = 0
+    last_evaluated_run_id: int | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScrapeSafetyStateData(BaseModel):
+    cooldown_active: bool
+    cooldown_reason: str | None = None
+    cooldown_reason_label: str | None = None
+    cooldown_until: datetime | None = None
+    cooldown_remaining_seconds: int = 0
+    recommended_action: str | None = None
+    counters: ScrapeSafetyCountersData = Field(default_factory=ScrapeSafetyCountersData)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunAttemptLogData(BaseModel):
+    attempt: int
+    cstart: int
+    state: str | None = None
+    state_reason: str | None = None
+    status_code: int | None = None
+    fetch_error: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunPageLogData(BaseModel):
+    page: int
+    cstart: int
+    state: str
+    state_reason: str | None = None
+    status_code: int | None = None
+    publication_count: int = 0
+    attempt_count: int = 0
+    has_show_more_button: bool = False
+    articles_range: str | None = None
+    warning_codes: list[str] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunDebugData(BaseModel):
+    status_code: int | None = None
+    final_url: str | None = None
+    fetch_error: str | None = None
+    body_sha256: str | None = None
+    body_length: int | None = None
+    has_show_more_button: bool | None = None
+    articles_range: str | None = None
+    state_reason: str | None = None
+    warning_codes: list[str] = Field(default_factory=list)
+    marker_counts_nonzero: dict[str, int] = Field(default_factory=dict)
+    page_logs: list[RunPageLogData] = Field(default_factory=list)
+    attempt_log: list[RunAttemptLogData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunScholarResultData(BaseModel):
+    scholar_profile_id: int
+    scholar_id: str
+    state: str
+    state_reason: str | None = None
+    outcome: str
+    attempt_count: int = 0
+    publication_count: int = 0
+    start_cstart: int = 0
+    continuation_cstart: int | None = None
+    continuation_enqueued: bool = False
+    continuation_cleared: bool = False
+    warnings: list[str] = Field(default_factory=list)
+    error: str | None = None
+    debug: RunDebugData | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunDetailData(BaseModel):
+    run: RunListItemData
+    summary: RunSummaryData
+    scholar_results: list[RunScholarResultData]
+    safety_state: ScrapeSafetyStateData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunDetailEnvelope(BaseModel):
+    data: RunDetailData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ManualRunData(BaseModel):
+    run_id: int
+    status: str
+    scholar_count: int
+    succeeded_count: int
+    failed_count: int
+    partial_count: int
+    new_publication_count: int
+    reused_existing_run: bool
+    idempotency_key: str | None = None
+    safety_state: ScrapeSafetyStateData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ManualRunEnvelope(BaseModel):
+    data: ManualRunData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueItemData(BaseModel):
+    id: int
+    scholar_profile_id: int
+    scholar_label: str
+    status: str
+    reason: str
+    dropped_reason: str | None
+    attempt_count: int
+    resume_cstart: int
+    next_attempt_dt: datetime | None
+    updated_at: datetime
+    last_error: str | None
+    last_run_id: int | None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueListData(BaseModel):
+    queue_items: list[QueueItemData]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueListEnvelope(BaseModel):
+    data: QueueListData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueItemEnvelope(BaseModel):
+    data: QueueItemData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueClearData(BaseModel):
+    queue_item_id: int
+    previous_status: str
+    status: str
+    message: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueClearEnvelope(BaseModel):
+    data: QueueClearData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminUserData(BaseModel):
+    id: int
+    email: str
+    is_active: bool
+    is_admin: bool
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminUsersListData(BaseModel):
+    users: list[AdminUserData]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminUsersListEnvelope(BaseModel):
+    data: AdminUsersListData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminUserCreateRequest(BaseModel):
+    email: str
+    password: str
+    is_admin: bool = False
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminUserActiveUpdateRequest(BaseModel):
+    is_active: bool
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminUserEnvelope(BaseModel):
+    data: AdminUserData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminResetPasswordRequest(BaseModel):
+    new_password: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbIntegrityCheckData(BaseModel):
+    name: str
+    count: int
+    severity: str
+    message: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbIntegrityData(BaseModel):
+    status: str
+    checked_at: datetime
+    failures: list[str] = Field(default_factory=list)
+    warnings: list[str] = Field(default_factory=list)
+    checks: list[AdminDbIntegrityCheckData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbIntegrityEnvelope(BaseModel):
+    data: AdminDbIntegrityData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbRepairJobData(BaseModel):
+    id: int
+    job_name: str
+    requested_by: str | None
+    dry_run: bool
+    status: str
+    scope: dict[str, Any] = Field(default_factory=dict)
+    summary: dict[str, Any] = Field(default_factory=dict)
+    error_text: str | None
+    started_at: datetime | None
+    finished_at: datetime | None
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbRepairJobsData(BaseModel):
+    jobs: list[AdminDbRepairJobData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbRepairJobsEnvelope(BaseModel):
+    data: AdminDbRepairJobsData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DisplayIdentifierData(BaseModel):
+    kind: str
+    value: str
+    label: str
+    url: str | None
+    confidence_score: float = Field(ge=0.0, le=1.0)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueItemData(BaseModel):
+    publication_id: int
+    title: str
+    display_identifier: DisplayIdentifierData | None = None
+    pdf_url: str | None
+    status: str
+    attempt_count: int
+    last_failure_reason: str | None
+    last_failure_detail: str | None
+    last_source: str | None
+    requested_by_user_id: int | None
+    requested_by_email: str | None
+    queued_at: datetime | None
+    last_attempt_at: datetime | None
+    resolved_at: datetime | None
+    updated_at: datetime
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueData(BaseModel):
+    items: list[AdminPdfQueueItemData] = Field(default_factory=list)
+    total_count: int = 0
+    page: int = 1
+    page_size: int = 100
+    has_next: bool = False
+    has_prev: bool = False
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueEnvelope(BaseModel):
+    data: AdminPdfQueueData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueRequeueData(BaseModel):
+    publication_id: int
+    queued: bool
+    status: str
+    message: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueRequeueEnvelope(BaseModel):
+    data: AdminPdfQueueRequeueData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueBulkEnqueueData(BaseModel):
+    requested_count: int
+    queued_count: int
+    message: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueBulkEnqueueEnvelope(BaseModel):
+    data: AdminPdfQueueBulkEnqueueData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminRepairPublicationLinksRequest(BaseModel):
+    scope_mode: Literal["single_user", "all_users"] = "single_user"
+    user_id: int | None = Field(default=None, ge=1)
+    scholar_profile_ids: list[int] = Field(default_factory=list, max_length=200)
+    dry_run: bool = True
+    gc_orphan_publications: bool = False
+    requested_by: str | None = None
+    confirmation_text: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+    @model_validator(mode="after")
+    def validate_scope(self) -> "AdminRepairPublicationLinksRequest":
+        if self.scope_mode == "single_user" and self.user_id is None:
+            raise ValueError("user_id is required when scope_mode=single_user.")
+        if self.scope_mode == "all_users" and self.user_id is not None:
+            raise ValueError("user_id must be omitted when scope_mode=all_users.")
+        if not self.dry_run and self.scope_mode == "all_users":
+            expected = "REPAIR ALL USERS"
+            provided = (self.confirmation_text or "").strip()
+            if provided != expected:
+                raise ValueError(
+                    "confirmation_text must equal 'REPAIR ALL USERS' "
+                    "when applying a repair to all users."
+                )
+        return self
+
+
+class AdminRepairPublicationLinksResultData(BaseModel):
+    job_id: int
+    status: str
+    scope: dict[str, Any] = Field(default_factory=dict)
+    summary: dict[str, Any] = Field(default_factory=dict)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminRepairPublicationLinksEnvelope(BaseModel):
+    data: AdminRepairPublicationLinksResultData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SettingsPolicyData(BaseModel):
+    min_run_interval_minutes: int
+    min_request_delay_seconds: int
+    automation_allowed: bool
+    manual_run_allowed: bool
+    blocked_failure_threshold: int
+    network_failure_threshold: int
+    cooldown_blocked_seconds: int
+    cooldown_network_seconds: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SettingsData(BaseModel):
+    auto_run_enabled: bool
+    run_interval_minutes: int
+    request_delay_seconds: int
+    nav_visible_pages: list[str]
+    policy: SettingsPolicyData
+    safety_state: ScrapeSafetyStateData
+    
+    openalex_api_key: str | None = None
+    crossref_api_token: str | None = None
+    crossref_api_mailto: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SettingsEnvelope(BaseModel):
+    data: SettingsData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SettingsUpdateRequest(BaseModel):
+    auto_run_enabled: bool
+    run_interval_minutes: int
+    request_delay_seconds: int
+    nav_visible_pages: list[str] | None = None
+
+    openalex_api_key: str | None = None
+    crossref_api_token: str | None = None
+    crossref_api_mailto: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PublicationItemData(BaseModel):
+    publication_id: int
+    scholar_profile_id: int
+    scholar_label: str
+    title: str
+    year: int | None
+    citation_count: int
+    venue_text: str | None
+    pub_url: str | None
+    display_identifier: DisplayIdentifierData | None = None
+    pdf_url: str | None
+    pdf_status: str = "untracked"
+    pdf_attempt_count: int = 0
+    pdf_failure_reason: str | None = None
+    pdf_failure_detail: str | None = None
+    is_read: bool
+    is_favorite: bool = False
+    first_seen_at: datetime
+    is_new_in_latest_run: bool
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PublicationsListData(BaseModel):
+    mode: str
+    favorite_only: bool = False
+    selected_scholar_profile_id: int | None
+    unread_count: int
+    favorites_count: int
+    latest_count: int
+    new_count: int
+    total_count: int
+    page: int
+    page_size: int
+    has_next: bool = False
+    has_prev: bool = False
+    publications: list[PublicationItemData]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PublicationsListEnvelope(BaseModel):
+    data: PublicationsListData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MarkAllReadData(BaseModel):
+    message: str
+    updated_count: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MarkAllReadEnvelope(BaseModel):
+    data: MarkAllReadData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PublicationSelectionItem(BaseModel):
+    scholar_profile_id: int
+    publication_id: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MarkSelectedReadRequest(BaseModel):
+    selections: list[PublicationSelectionItem] = Field(min_length=1, max_length=500)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MarkSelectedReadData(BaseModel):
+    message: str
+    requested_count: int
+    updated_count: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MarkSelectedReadEnvelope(BaseModel):
+    data: MarkSelectedReadData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RetryPublicationPdfRequest(BaseModel):
+    scholar_profile_id: int = Field(ge=1)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RetryPublicationPdfData(BaseModel):
+    message: str
+    queued: bool
+    resolved_pdf: bool
+    publication: PublicationItemData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RetryPublicationPdfEnvelope(BaseModel):
+    data: RetryPublicationPdfData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class TogglePublicationFavoriteRequest(BaseModel):
+    scholar_profile_id: int = Field(ge=1)
+    is_favorite: bool
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class TogglePublicationFavoriteData(BaseModel):
+    message: str
+    publication: PublicationItemData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class TogglePublicationFavoriteEnvelope(BaseModel):
+    data: TogglePublicationFavoriteData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
diff --git a/build/lib/app/auth/__init__.py b/build/lib/app/auth/__init__.py
new file mode 100644
index 0000000..79644a4
--- /dev/null
+++ b/build/lib/app/auth/__init__.py
@@ -0,0 +1,2 @@
+"""Authentication package for scholarr."""
+
diff --git a/build/lib/app/auth/deps.py b/build/lib/app/auth/deps.py
new file mode 100644
index 0000000..50424ae
--- /dev/null
+++ b/build/lib/app/auth/deps.py
@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from functools import lru_cache
+
+from app.auth.rate_limit import SlidingWindowRateLimiter
+from app.auth.security import PasswordService
+from app.auth.service import AuthService
+from app.settings import settings
+
+
+@lru_cache
+def get_password_service() -> PasswordService:
+    return PasswordService()
+
+
+@lru_cache
+def get_auth_service() -> AuthService:
+    return AuthService(password_service=get_password_service())
+
+
+@lru_cache
+def get_login_rate_limiter() -> SlidingWindowRateLimiter:
+    return SlidingWindowRateLimiter(
+        max_attempts=settings.login_rate_limit_attempts,
+        window_seconds=settings.login_rate_limit_window_seconds,
+    )
+
diff --git a/build/lib/app/auth/rate_limit.py b/build/lib/app/auth/rate_limit.py
new file mode 100644
index 0000000..c3f5e8a
--- /dev/null
+++ b/build/lib/app/auth/rate_limit.py
@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Callable
+from dataclasses import dataclass
+from math import ceil
+from threading import Lock
+from time import monotonic
+
+
+@dataclass(frozen=True)
+class RateLimitDecision:
+    allowed: bool
+    retry_after_seconds: int = 0
+
+
+class SlidingWindowRateLimiter:
+    def __init__(
+        self,
+        *,
+        max_attempts: int,
+        window_seconds: int,
+        now: Callable[[], float] = monotonic,
+    ) -> None:
+        self._max_attempts = max_attempts
+        self._window_seconds = window_seconds
+        self._now = now
+        self._attempts: dict[str, deque[float]] = {}
+        self._lock = Lock()
+
+    def check(self, key: str) -> RateLimitDecision:
+        with self._lock:
+            now_value = self._now()
+            attempts = self._attempts.get(key)
+            if attempts is None:
+                return RateLimitDecision(allowed=True)
+            self._trim_expired(attempts, now_value)
+            if not attempts:
+                self._attempts.pop(key, None)
+                return RateLimitDecision(allowed=True)
+            if len(attempts) >= self._max_attempts:
+                retry_after = self._window_seconds - (now_value - attempts[0])
+                return RateLimitDecision(
+                    allowed=False,
+                    retry_after_seconds=max(1, ceil(retry_after)),
+                )
+            return RateLimitDecision(allowed=True)
+
+    def record_failure(self, key: str) -> None:
+        with self._lock:
+            now_value = self._now()
+            attempts = self._attempts.get(key)
+            if attempts is None:
+                attempts = deque()
+                self._attempts[key] = attempts
+            self._trim_expired(attempts, now_value)
+            attempts.append(now_value)
+
+    def reset(self, key: str) -> None:
+        with self._lock:
+            self._attempts.pop(key, None)
+
+    def clear_all(self) -> None:
+        with self._lock:
+            self._attempts.clear()
+
+    def _trim_expired(self, attempts: deque[float], now_value: float) -> None:
+        while attempts and now_value - attempts[0] >= self._window_seconds:
+            attempts.popleft()
diff --git a/build/lib/app/auth/runtime.py b/build/lib/app/auth/runtime.py
new file mode 100644
index 0000000..777e799
--- /dev/null
+++ b/build/lib/app/auth/runtime.py
@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import logging
+
+from fastapi import Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.auth.session import clear_session_user, get_session_user, set_session_user
+from app.db.models import User
+from app.security.csrf import CSRF_SESSION_KEY
+from app.services.domains.users import application as user_service
+
+logger = logging.getLogger(__name__)
+
+
+def invalidate_session(request: Request) -> None:
+    clear_session_user(request)
+    request.session.pop(CSRF_SESSION_KEY, None)
+
+
+async def get_authenticated_user(
+    request: Request,
+    db_session: AsyncSession,
+) -> User | None:
+    session_user = get_session_user(request)
+    if session_user is None:
+        return None
+
+    user = await user_service.get_user_by_id(db_session, session_user.id)
+    if user is None or not user.is_active:
+        logger.info(
+            "auth.session_invalidated",
+            extra={
+                "event": "auth.session_invalidated",
+                "session_user_id": session_user.id,
+            },
+        )
+        invalidate_session(request)
+        return None
+
+    if user.email != session_user.email or user.is_admin != session_user.is_admin:
+        set_session_user(
+            request,
+            user_id=user.id,
+            email=user.email,
+            is_admin=user.is_admin,
+        )
+
+    return user
+
+
+def login_rate_limit_key(request: Request, email: str) -> str:
+    client_host = request.client.host if request.client is not None else "unknown"
+    normalized_email = email.strip().lower()
+    return f"{client_host}:{normalized_email or '<empty>'}"
diff --git a/build/lib/app/auth/security.py b/build/lib/app/auth/security.py
new file mode 100644
index 0000000..f89b122
--- /dev/null
+++ b/build/lib/app/auth/security.py
@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from argon2 import PasswordHasher
+from argon2.exceptions import InvalidHashError, VerificationError
+
+
+class PasswordService:
+    def __init__(self, hasher: PasswordHasher | None = None) -> None:
+        self._hasher = hasher or PasswordHasher()
+
+    def hash_password(self, password: str) -> str:
+        return self._hasher.hash(password)
+
+    def verify_password(self, password_hash: str, password: str) -> bool:
+        try:
+            return bool(self._hasher.verify(password_hash, password))
+        except (InvalidHashError, VerificationError):
+            return False
+
diff --git a/build/lib/app/auth/service.py b/build/lib/app/auth/service.py
new file mode 100644
index 0000000..9772358
--- /dev/null
+++ b/build/lib/app/auth/service.py
@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.auth.security import PasswordService
+from app.db.models import User
+
+
+class AuthService:
+    def __init__(self, password_service: PasswordService) -> None:
+        self._password_service = password_service
+
+    async def authenticate_user(
+        self,
+        db_session: AsyncSession,
+        *,
+        email: str,
+        password: str,
+    ) -> User | None:
+        normalized_email = email.strip().lower()
+        if not normalized_email or not password:
+            return None
+        result = await db_session.execute(
+            select(User).where(User.email == normalized_email)
+        )
+        user = result.scalar_one_or_none()
+        if user is None or not user.is_active:
+            return None
+        if not self._password_service.verify_password(user.password_hash, password):
+            return None
+        return user
+
+    def hash_password(self, password: str) -> str:
+        return self._password_service.hash_password(password)
+
+    def verify_password(self, *, password_hash: str, password: str) -> bool:
+        return self._password_service.verify_password(password_hash, password)
diff --git a/build/lib/app/auth/session.py b/build/lib/app/auth/session.py
new file mode 100644
index 0000000..8c83197
--- /dev/null
+++ b/build/lib/app/auth/session.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from starlette.requests import Request
+
+
+SESSION_USER_ID_KEY = "auth_user_id"
+SESSION_USER_EMAIL_KEY = "auth_user_email"
+SESSION_USER_IS_ADMIN_KEY = "auth_user_is_admin"
+
+
+@dataclass(frozen=True)
+class SessionUser:
+    id: int
+    email: str
+    is_admin: bool
+
+
+def get_session_user(request: Request) -> SessionUser | None:
+    user_id = request.session.get(SESSION_USER_ID_KEY)
+    email = request.session.get(SESSION_USER_EMAIL_KEY)
+    is_admin = request.session.get(SESSION_USER_IS_ADMIN_KEY)
+    if user_id is None or email is None or is_admin is None:
+        return None
+    try:
+        parsed_user_id = int(user_id)
+    except (TypeError, ValueError):
+        return None
+    if not isinstance(email, str):
+        return None
+    return SessionUser(id=parsed_user_id, email=email, is_admin=bool(is_admin))
+
+
+def set_session_user(
+    request: Request,
+    *,
+    user_id: int,
+    email: str,
+    is_admin: bool,
+) -> None:
+    request.session[SESSION_USER_ID_KEY] = int(user_id)
+    request.session[SESSION_USER_EMAIL_KEY] = email
+    request.session[SESSION_USER_IS_ADMIN_KEY] = bool(is_admin)
+
+
+def clear_session_user(request: Request) -> None:
+    request.session.pop(SESSION_USER_ID_KEY, None)
+    request.session.pop(SESSION_USER_EMAIL_KEY, None)
+    request.session.pop(SESSION_USER_IS_ADMIN_KEY, None)
diff --git a/build/lib/app/db/__init__.py b/build/lib/app/db/__init__.py
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/build/lib/app/db/__init__.py
@@ -0,0 +1 @@
+
diff --git a/build/lib/app/db/base.py b/build/lib/app/db/base.py
new file mode 100644
index 0000000..6fa2049
--- /dev/null
+++ b/build/lib/app/db/base.py
@@ -0,0 +1,27 @@
+from datetime import datetime, timezone
+
+from sqlalchemy import MetaData, event
+from sqlalchemy.orm import DeclarativeBase
+
+
+NAMING_CONVENTION = {
+    "ix": "ix_%(column_0_label)s",
+    "uq": "uq_%(table_name)s_%(column_0_name)s",
+    "ck": "ck_%(table_name)s_%(constraint_name)s",
+    "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
+    "pk": "pk_%(table_name)s",
+}
+
+
+class Base(DeclarativeBase):
+    metadata = MetaData(naming_convention=NAMING_CONVENTION)
+
+
+@event.listens_for(Base, "before_update", propagate=True)
+def _set_updated_at_before_update(_mapper, _connection, target) -> None:
+    # Keep audit timestamps current for ORM-managed updates.
+    if hasattr(target, "updated_at"):
+        target.updated_at = datetime.now(timezone.utc)
+
+
+metadata = Base.metadata
diff --git a/build/lib/app/db/models.py b/build/lib/app/db/models.py
new file mode 100644
index 0000000..1a8ad8a
--- /dev/null
+++ b/build/lib/app/db/models.py
@@ -0,0 +1,546 @@
+from __future__ import annotations
+
+from datetime import datetime
+from enum import StrEnum
+
+from sqlalchemy import (
+    Boolean,
+    CheckConstraint,
+    DateTime,
+    Enum,
+    Float,
+    ForeignKey,
+    Index,
+    Integer,
+    String,
+    Text,
+    UniqueConstraint,
+    func,
+    text,
+)
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.db.base import Base
+
+
+class RunTriggerType(StrEnum):
+    MANUAL = "manual"
+    SCHEDULED = "scheduled"
+
+
+class RunStatus(StrEnum):
+    RUNNING = "running"
+    SUCCESS = "success"
+    PARTIAL_FAILURE = "partial_failure"
+    FAILED = "failed"
+    CANCELED = "canceled"
+
+
+class QueueItemStatus(StrEnum):
+    QUEUED = "queued"
+    RETRYING = "retrying"
+    DROPPED = "dropped"
+
+
+RUN_STATUS_DB_ENUM = Enum(
+    RunStatus,
+    name="run_status",
+    values_callable=lambda members: [member.value for member in members],
+)
+RUN_TRIGGER_TYPE_DB_ENUM = Enum(
+    RunTriggerType,
+    name="run_trigger_type",
+    values_callable=lambda members: [member.value for member in members],
+)
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    email: Mapped[str] = mapped_column(String(255), nullable=False, unique=True)
+    password_hash: Mapped[str] = mapped_column(String(255), nullable=False)
+    is_active: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, server_default=text("true")
+    )
+    is_admin: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, server_default=text("false")
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class UserSetting(Base):
+    __tablename__ = "user_settings"
+    __table_args__ = (
+        CheckConstraint(
+            "run_interval_minutes >= 15",
+            name="run_interval_minutes_min_15",
+        ),
+        CheckConstraint(
+            "request_delay_seconds >= 2",
+            name="request_delay_seconds_min_2",
+        ),
+    )
+
+    user_id: Mapped[int] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"), primary_key=True
+    )
+    auto_run_enabled: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, server_default=text("false")
+    )
+    run_interval_minutes: Mapped[int] = mapped_column(
+        Integer, nullable=False, server_default=text("1440")
+    )
+    request_delay_seconds: Mapped[int] = mapped_column(
+        Integer, nullable=False, server_default=text("10")
+    )
+    nav_visible_pages: Mapped[list[str]] = mapped_column(
+        JSONB,
+        nullable=False,
+        server_default=text(
+            '\'["dashboard","scholars","publications","settings","style-guide","runs","users"]\'::jsonb'
+        ),
+    )
+    scrape_safety_state: Mapped[dict] = mapped_column(
+        JSONB,
+        nullable=False,
+        server_default=text("'{}'::jsonb"),
+    )
+    scrape_cooldown_until: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    scrape_cooldown_reason: Mapped[str | None] = mapped_column(String(64))
+    
+    openalex_api_key: Mapped[str | None] = mapped_column(String(255))
+    crossref_api_token: Mapped[str | None] = mapped_column(String(255))
+    crossref_api_mailto: Mapped[str | None] = mapped_column(String(255))
+
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class ScholarProfile(Base):
+    __tablename__ = "scholar_profiles"
+    __table_args__ = (
+        UniqueConstraint("user_id", "scholar_id", name="uq_scholar_profiles_user_scholar"),
+        Index("ix_scholar_profiles_user_enabled", "user_id", "is_enabled"),
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user_id: Mapped[int] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"), nullable=False
+    )
+    scholar_id: Mapped[str] = mapped_column(String(64), nullable=False)
+    display_name: Mapped[str | None] = mapped_column(String(255))
+    profile_image_url: Mapped[str | None] = mapped_column(Text)
+    profile_image_override_url: Mapped[str | None] = mapped_column(Text)
+    profile_image_upload_path: Mapped[str | None] = mapped_column(Text)
+    last_initial_page_fingerprint_sha256: Mapped[str | None] = mapped_column(String(64))
+    last_initial_page_checked_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    is_enabled: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, server_default=text("true")
+    )
+    baseline_completed: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, server_default=text("false")
+    )
+    last_run_dt: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    last_run_status: Mapped[RunStatus | None] = mapped_column(
+        RUN_STATUS_DB_ENUM,
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class CrawlRun(Base):
+    __tablename__ = "crawl_runs"
+    __table_args__ = (
+        Index("ix_crawl_runs_user_start", "user_id", "start_dt"),
+        Index(
+            "uq_crawl_runs_user_manual_idempotency_key",
+            "user_id",
+            "idempotency_key",
+            unique=True,
+            postgresql_where=text(
+                "idempotency_key IS NOT NULL AND trigger_type = 'manual'::run_trigger_type"
+            ),
+        ),
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user_id: Mapped[int] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"), nullable=False
+    )
+    trigger_type: Mapped[RunTriggerType] = mapped_column(
+        RUN_TRIGGER_TYPE_DB_ENUM, nullable=False
+    )
+    status: Mapped[RunStatus] = mapped_column(
+        RUN_STATUS_DB_ENUM, nullable=False
+    )
+    start_dt: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    end_dt: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    scholar_count: Mapped[int] = mapped_column(
+        Integer, nullable=False, server_default=text("0")
+    )
+    new_pub_count: Mapped[int] = mapped_column(
+        Integer, nullable=False, server_default=text("0")
+    )
+    idempotency_key: Mapped[str | None] = mapped_column(String(128))
+    error_log: Mapped[dict] = mapped_column(
+        JSONB, nullable=False, server_default=text("'{}'::jsonb")
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class Publication(Base):
+    __tablename__ = "publications"
+    __table_args__ = (
+        UniqueConstraint("fingerprint_sha256", name="uq_publications_fingerprint"),
+        Index(
+            "uq_publications_cluster_id_not_null",
+            "cluster_id",
+            unique=True,
+            postgresql_where=text("cluster_id IS NOT NULL"),
+        ),
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    cluster_id: Mapped[str | None] = mapped_column(String(64))
+    fingerprint_sha256: Mapped[str] = mapped_column(String(64), nullable=False)
+    title_raw: Mapped[str] = mapped_column(Text, nullable=False)
+    title_normalized: Mapped[str] = mapped_column(Text, nullable=False)
+    year: Mapped[int | None] = mapped_column(Integer)
+    citation_count: Mapped[int] = mapped_column(
+        Integer, nullable=False, server_default=text("0")
+    )
+    author_text: Mapped[str | None] = mapped_column(Text)
+    venue_text: Mapped[str | None] = mapped_column(Text)
+    pub_url: Mapped[str | None] = mapped_column(Text)
+    pdf_url: Mapped[str | None] = mapped_column(Text)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class PublicationIdentifier(Base):
+    __tablename__ = "publication_identifiers"
+    __table_args__ = (
+        UniqueConstraint(
+            "publication_id",
+            "kind",
+            "value_normalized",
+            name="uq_publication_identifiers_publication_kind_value",
+        ),
+        CheckConstraint(
+            "confidence_score >= 0 AND confidence_score <= 1",
+            name="publication_identifiers_confidence_score_range",
+        ),
+        Index(
+            "ix_publication_identifiers_kind_value",
+            "kind",
+            "value_normalized",
+        ),
+        Index(
+            "ix_publication_identifiers_publication_id",
+            "publication_id",
+        ),
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    publication_id: Mapped[int] = mapped_column(
+        ForeignKey("publications.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    kind: Mapped[str] = mapped_column(String(32), nullable=False)
+    value_raw: Mapped[str] = mapped_column(Text, nullable=False)
+    value_normalized: Mapped[str] = mapped_column(String(255), nullable=False)
+    source: Mapped[str] = mapped_column(String(64), nullable=False)
+    confidence_score: Mapped[float] = mapped_column(
+        Float,
+        nullable=False,
+        server_default=text("0"),
+    )
+    evidence_url: Mapped[str | None] = mapped_column(Text)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class PublicationPdfJob(Base):
+    __tablename__ = "publication_pdf_jobs"
+    __table_args__ = (
+        CheckConstraint(
+            "status IN ('queued', 'running', 'resolved', 'failed')",
+            name="publication_pdf_jobs_status_valid",
+        ),
+        Index("ix_publication_pdf_jobs_status", "status"),
+        Index("ix_publication_pdf_jobs_updated_at", "updated_at"),
+        Index("ix_publication_pdf_jobs_queued_at", "queued_at"),
+    )
+
+    publication_id: Mapped[int] = mapped_column(
+        ForeignKey("publications.id", ondelete="CASCADE"),
+        primary_key=True,
+    )
+    status: Mapped[str] = mapped_column(
+        String(16),
+        nullable=False,
+        server_default=text("'queued'"),
+    )
+    attempt_count: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+        server_default=text("0"),
+    )
+    queued_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    last_attempt_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    resolved_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    last_failure_reason: Mapped[str | None] = mapped_column(String(64))
+    last_failure_detail: Mapped[str | None] = mapped_column(Text)
+    last_source: Mapped[str | None] = mapped_column(String(32))
+    last_requested_by_user_id: Mapped[int | None] = mapped_column(
+        ForeignKey("users.id", ondelete="SET NULL"),
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class PublicationPdfJobEvent(Base):
+    __tablename__ = "publication_pdf_job_events"
+    __table_args__ = (
+        Index("ix_publication_pdf_job_events_publication_created", "publication_id", "created_at"),
+        Index("ix_publication_pdf_job_events_created_at", "created_at"),
+        Index("ix_publication_pdf_job_events_event_type", "event_type"),
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    publication_id: Mapped[int] = mapped_column(
+        ForeignKey("publications.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    user_id: Mapped[int | None] = mapped_column(
+        ForeignKey("users.id", ondelete="SET NULL"),
+    )
+    event_type: Mapped[str] = mapped_column(String(32), nullable=False)
+    status: Mapped[str | None] = mapped_column(String(16))
+    source: Mapped[str | None] = mapped_column(String(32))
+    failure_reason: Mapped[str | None] = mapped_column(String(64))
+    message: Mapped[str | None] = mapped_column(Text)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class ScholarPublication(Base):
+    __tablename__ = "scholar_publications"
+    __table_args__ = (
+        Index("ix_scholar_publications_is_read", "is_read"),
+        Index("ix_scholar_publications_is_favorite", "is_favorite"),
+    )
+
+    scholar_profile_id: Mapped[int] = mapped_column(
+        ForeignKey("scholar_profiles.id", ondelete="CASCADE"),
+        primary_key=True,
+    )
+    publication_id: Mapped[int] = mapped_column(
+        ForeignKey("publications.id", ondelete="CASCADE"),
+        primary_key=True,
+    )
+    is_read: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, server_default=text("false")
+    )
+    is_favorite: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, server_default=text("false")
+    )
+    first_seen_run_id: Mapped[int | None] = mapped_column(
+        ForeignKey("crawl_runs.id", ondelete="SET NULL")
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class IngestionQueueItem(Base):
+    __tablename__ = "ingestion_queue_items"
+    __table_args__ = (
+        UniqueConstraint(
+            "user_id",
+            "scholar_profile_id",
+            name="uq_ingestion_queue_user_scholar",
+        ),
+        CheckConstraint(
+            "status IN ('queued', 'retrying', 'dropped')",
+            name="ingestion_queue_status_valid",
+        ),
+        Index("ix_ingestion_queue_next_attempt", "next_attempt_dt"),
+        Index("ix_ingestion_queue_status_next_attempt", "status", "next_attempt_dt"),
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user_id: Mapped[int] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    scholar_profile_id: Mapped[int] = mapped_column(
+        ForeignKey("scholar_profiles.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    resume_cstart: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+        server_default=text("0"),
+    )
+    reason: Mapped[str] = mapped_column(String(64), nullable=False)
+    status: Mapped[str] = mapped_column(
+        String(16),
+        nullable=False,
+        server_default=text("'queued'"),
+    )
+    attempt_count: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+        server_default=text("0"),
+    )
+    next_attempt_dt: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        nullable=False,
+        server_default=func.now(),
+    )
+    last_run_id: Mapped[int | None] = mapped_column(
+        ForeignKey("crawl_runs.id", ondelete="SET NULL"),
+    )
+    last_error: Mapped[str | None] = mapped_column(Text)
+    dropped_reason: Mapped[str | None] = mapped_column(String(128))
+    dropped_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class DataRepairJob(Base):
+    __tablename__ = "data_repair_jobs"
+    __table_args__ = (
+        CheckConstraint(
+            "status IN ('planned', 'running', 'completed', 'failed')",
+            name="data_repair_jobs_status_valid",
+        ),
+        Index("ix_data_repair_jobs_created_at", "created_at"),
+        Index("ix_data_repair_jobs_job_name_created_at", "job_name", "created_at"),
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    job_name: Mapped[str] = mapped_column(String(64), nullable=False)
+    requested_by: Mapped[str | None] = mapped_column(String(255))
+    scope: Mapped[dict] = mapped_column(
+        JSONB,
+        nullable=False,
+        server_default=text("'{}'::jsonb"),
+    )
+    dry_run: Mapped[bool] = mapped_column(
+        Boolean,
+        nullable=False,
+        server_default=text("true"),
+    )
+    status: Mapped[str] = mapped_column(
+        String(16),
+        nullable=False,
+        server_default=text("'planned'"),
+    )
+    summary: Mapped[dict] = mapped_column(
+        JSONB,
+        nullable=False,
+        server_default=text("'{}'::jsonb"),
+    )
+    error_text: Mapped[str | None] = mapped_column(Text)
+    started_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    finished_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class AuthorSearchRuntimeState(Base):
+    __tablename__ = "author_search_runtime_state"
+
+    state_key: Mapped[str] = mapped_column(String(64), primary_key=True)
+    last_live_request_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    cooldown_until: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    consecutive_blocked_count: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+        server_default=text("0"),
+    )
+    cooldown_rejection_count: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+        server_default=text("0"),
+    )
+    cooldown_alert_emitted: Mapped[bool] = mapped_column(
+        Boolean,
+        nullable=False,
+        server_default=text("false"),
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class AuthorSearchCacheEntry(Base):
+    __tablename__ = "author_search_cache_entries"
+    __table_args__ = (
+        Index("ix_author_search_cache_expires_at", "expires_at"),
+        Index("ix_author_search_cache_cached_at", "cached_at"),
+    )
+
+    query_key: Mapped[str] = mapped_column(String(256), primary_key=True)
+    payload: Mapped[dict] = mapped_column(
+        JSONB,
+        nullable=False,
+    )
+    expires_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        nullable=False,
+    )
+    cached_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
diff --git a/build/lib/app/db/session.py b/build/lib/app/db/session.py
new file mode 100644
index 0000000..c05266e
--- /dev/null
+++ b/build/lib/app/db/session.py
@@ -0,0 +1,99 @@
+from collections.abc import AsyncIterator
+import logging
+import os
+
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+from sqlalchemy.pool import NullPool
+
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+_engine: AsyncEngine | None = None
+_session_factory: async_sessionmaker[AsyncSession] | None = None
+
+
+def _normalized_pool_mode(raw_mode: str) -> str:
+    mode = (raw_mode or "").strip().lower()
+    if mode == "auto":
+        if os.getenv("PYTEST_CURRENT_TEST"):
+            return "null"
+        app_env = (os.getenv("APP_ENV") or "").strip().lower()
+        if app_env in {"test", "development", "dev", "local"}:
+            return "null"
+        return "queue"
+    if mode in {"null", "queue"}:
+        return mode
+    logger.warning(
+        "db.invalid_pool_mode_fallback",
+        extra={
+            "event": "db.invalid_pool_mode_fallback",
+            "database_pool_mode": raw_mode,
+            "fallback_mode": "queue",
+        },
+    )
+    return "queue"
+
+
+def get_engine() -> AsyncEngine:
+    global _engine
+    if _engine is None:
+        pool_mode = _normalized_pool_mode(settings.database_pool_mode)
+        engine_kwargs: dict[str, object] = {
+            "pool_pre_ping": True,
+        }
+        if pool_mode == "null":
+            engine_kwargs["poolclass"] = NullPool
+        else:
+            engine_kwargs["pool_size"] = max(1, int(settings.database_pool_size))
+            engine_kwargs["max_overflow"] = max(0, int(settings.database_pool_max_overflow))
+            engine_kwargs["pool_timeout"] = max(1, int(settings.database_pool_timeout_seconds))
+
+        _engine = create_async_engine(settings.database_url, **engine_kwargs)
+        logger.info(
+            "db.engine_initialized",
+            extra={
+                "event": "db.engine_initialized",
+                "pool_mode": pool_mode,
+            },
+        )
+    return _engine
+
+
+def get_session_factory() -> async_sessionmaker[AsyncSession]:
+    global _session_factory
+    if _session_factory is None:
+        _session_factory = async_sessionmaker(get_engine(), expire_on_commit=False)
+    return _session_factory
+
+
+async def get_db_session() -> AsyncIterator[AsyncSession]:
+    session_factory = get_session_factory()
+    async with session_factory() as session:
+        yield session
+
+
+async def check_database() -> bool:
+    engine = get_engine()
+    try:
+        async with engine.connect() as conn:
+            result = await conn.execute(text("SELECT 1"))
+            return result.scalar_one() == 1
+    except Exception:
+        logger.exception("db.healthcheck_failed", extra={"event": "db.healthcheck_failed"})
+        return False
+
+
+async def close_engine() -> None:
+    global _engine, _session_factory
+    if _engine is not None:
+        await _engine.dispose()
+        logger.info("db.engine_disposed", extra={"event": "db.engine_disposed"})
+        _engine = None
+        _session_factory = None
diff --git a/build/lib/app/http/__init__.py b/build/lib/app/http/__init__.py
new file mode 100644
index 0000000..9d48db4
--- /dev/null
+++ b/build/lib/app/http/__init__.py
@@ -0,0 +1 @@
+from __future__ import annotations
diff --git a/build/lib/app/http/middleware.py b/build/lib/app/http/middleware.py
new file mode 100644
index 0000000..ebe72f8
--- /dev/null
+++ b/build/lib/app/http/middleware.py
@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+from secrets import token_urlsafe
+import logging
+import time
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
+from app.logging_context import set_request_id
+
+REQUEST_ID_HEADER = "X-Request-ID"
+DEFAULT_PERMISSIONS_POLICY = (
+    "accelerometer=(), autoplay=(), camera=(), display-capture=(), "
+    "geolocation=(), gyroscope=(), microphone=(), payment=(), usb=()"
+)
+DEFAULT_CSP_POLICY = (
+    "default-src 'self'; "
+    "base-uri 'self'; "
+    "form-action 'self'; "
+    "frame-ancestors 'none'; "
+    "img-src 'self' data: https:; "
+    "script-src 'self'; "
+    "style-src 'self' 'unsafe-inline'; "
+    "font-src 'self' data:; "
+    "connect-src 'self'; "
+    "object-src 'none'"
+)
+DEFAULT_CSP_DOCS_POLICY = (
+    "default-src 'self'; "
+    "img-src 'self' data: https:; "
+    "script-src 'self' 'unsafe-inline'; "
+    "style-src 'self' 'unsafe-inline'; "
+    "font-src 'self' data:; "
+    "connect-src 'self' https:; "
+    "object-src 'none'; "
+    "frame-ancestors 'none'"
+)
+
+logger = logging.getLogger(__name__)
+
+
+class RequestLoggingMiddleware(BaseHTTPMiddleware):
+    def __init__(
+        self,
+        app,
+        *,
+        log_requests: bool = True,
+        skip_paths: tuple[str, ...] = (),
+    ) -> None:
+        super().__init__(app)
+        self._log_requests = log_requests
+        self._skip_paths = tuple(path for path in skip_paths if path)
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        request_id = request.headers.get(REQUEST_ID_HEADER) or token_urlsafe(12)
+        request.state.request_id = request_id
+        set_request_id(request_id)
+
+        start = time.perf_counter()
+        should_log = self._log_requests and not self._is_skipped_path(request.url.path)
+        if should_log:
+            logger.debug(
+                "request.started",
+                extra={
+                    "event": "request.started",
+                    "method": request.method,
+                    "path": request.url.path,
+                },
+            )
+
+        try:
+            response = await call_next(request)
+        except Exception:
+            duration_ms = int((time.perf_counter() - start) * 1000)
+            logger.exception(
+                "request.failed",
+                extra={
+                    "event": "request.failed",
+                    "method": request.method,
+                    "path": request.url.path,
+                    "duration_ms": duration_ms,
+                },
+            )
+            raise
+        else:
+            duration_ms = int((time.perf_counter() - start) * 1000)
+            response.headers[REQUEST_ID_HEADER] = request_id
+            if should_log:
+                logger.debug(
+                    "request.completed",
+                    extra={
+                        "event": "request.completed",
+                        "method": request.method,
+                        "path": request.url.path,
+                        "status_code": response.status_code,
+                        "duration_ms": duration_ms,
+                    },
+                )
+            return response
+        finally:
+            set_request_id(None)
+
+    def _is_skipped_path(self, path: str) -> bool:
+        return any(path.startswith(prefix) for prefix in self._skip_paths)
+
+
+class SecurityHeadersMiddleware(BaseHTTPMiddleware):
+    def __init__(
+        self,
+        app,
+        *,
+        enabled: bool = True,
+        x_content_type_options: str = "nosniff",
+        x_frame_options: str = "DENY",
+        referrer_policy: str = "strict-origin-when-cross-origin",
+        permissions_policy: str = DEFAULT_PERMISSIONS_POLICY,
+        cross_origin_opener_policy: str = "same-origin",
+        cross_origin_resource_policy: str = "same-origin",
+        content_security_policy_enabled: bool = True,
+        content_security_policy: str = DEFAULT_CSP_POLICY,
+        content_security_policy_docs: str = DEFAULT_CSP_DOCS_POLICY,
+        content_security_policy_report_only: bool = False,
+        strict_transport_security_enabled: bool = False,
+        strict_transport_security_max_age: int = 31_536_000,
+        strict_transport_security_include_subdomains: bool = True,
+        strict_transport_security_preload: bool = False,
+    ) -> None:
+        super().__init__(app)
+        self._enabled = enabled
+        self._x_content_type_options = x_content_type_options.strip()
+        self._x_frame_options = x_frame_options.strip()
+        self._referrer_policy = referrer_policy.strip()
+        self._permissions_policy = permissions_policy.strip()
+        self._cross_origin_opener_policy = cross_origin_opener_policy.strip()
+        self._cross_origin_resource_policy = cross_origin_resource_policy.strip()
+        self._csp_enabled = content_security_policy_enabled
+        self._csp_policy = content_security_policy.strip()
+        self._csp_docs_policy = content_security_policy_docs.strip()
+        self._csp_report_only = content_security_policy_report_only
+        self._hsts_enabled = strict_transport_security_enabled
+        self._hsts_max_age = max(0, strict_transport_security_max_age)
+        self._hsts_include_subdomains = strict_transport_security_include_subdomains
+        self._hsts_preload = strict_transport_security_preload
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        response = await call_next(request)
+        if not self._enabled:
+            return response
+
+        if self._x_content_type_options:
+            response.headers.setdefault("X-Content-Type-Options", self._x_content_type_options)
+        if self._x_frame_options:
+            response.headers.setdefault("X-Frame-Options", self._x_frame_options)
+        if self._referrer_policy:
+            response.headers.setdefault("Referrer-Policy", self._referrer_policy)
+        if self._permissions_policy:
+            response.headers.setdefault("Permissions-Policy", self._permissions_policy)
+        if self._cross_origin_opener_policy:
+            response.headers.setdefault(
+                "Cross-Origin-Opener-Policy",
+                self._cross_origin_opener_policy,
+            )
+        if self._cross_origin_resource_policy:
+            response.headers.setdefault(
+                "Cross-Origin-Resource-Policy",
+                self._cross_origin_resource_policy,
+            )
+
+        csp_policy = self._csp_policy_for_path(request.url.path)
+        if self._csp_enabled and csp_policy:
+            csp_header = (
+                "Content-Security-Policy-Report-Only"
+                if self._csp_report_only
+                else "Content-Security-Policy"
+            )
+            response.headers.setdefault(csp_header, csp_policy)
+
+        hsts = self._strict_transport_security_value()
+        if hsts:
+            response.headers.setdefault("Strict-Transport-Security", hsts)
+
+        return response
+
+    def _csp_policy_for_path(self, path: str) -> str:
+        if path.startswith("/docs") or path.startswith("/redoc"):
+            return self._csp_docs_policy or self._csp_policy
+        return self._csp_policy
+
+    def _strict_transport_security_value(self) -> str:
+        if not self._hsts_enabled:
+            return ""
+
+        directives = [f"max-age={self._hsts_max_age}"]
+        if self._hsts_include_subdomains:
+            directives.append("includeSubDomains")
+        if self._hsts_preload:
+            directives.append("preload")
+        return "; ".join(directives)
+
+
+def parse_skip_paths(raw_value: str) -> tuple[str, ...]:
+    parts = [part.strip() for part in raw_value.split(",")]
+    return tuple(part for part in parts if part)
diff --git a/build/lib/app/logging_config.py b/build/lib/app/logging_config.py
new file mode 100644
index 0000000..22907be
--- /dev/null
+++ b/build/lib/app/logging_config.py
@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import json
+import logging
+import sys
+from typing import Any
+
+from app.logging_context import get_request_id
+
+DEFAULT_REDACT_FIELDS = {
+    "authorization",
+    "cookie",
+    "csrf_token",
+    "new_password",
+    "password",
+    "password_hash",
+    "session",
+    "session_secret_key",
+}
+
+_BASE_RECORD = logging.makeLogRecord({})
+_STANDARD_RECORD_FIELDS = set(_BASE_RECORD.__dict__.keys()) | {"message", "asctime"}
+_NOISY_RECORD_FIELDS = {"color_message"}
+
+
+def parse_redact_fields(raw: str | None) -> set[str]:
+    fields = {field.strip().lower() for field in (raw or "").split(",") if field.strip()}
+    return DEFAULT_REDACT_FIELDS | fields
+
+
+def configure_logging(
+    *,
+    level: str,
+    log_format: str,
+    redact_fields: set[str],
+    include_uvicorn_access: bool,
+) -> None:
+    normalized_level = _normalize_level(level)
+    root_logger = logging.getLogger()
+    root_logger.handlers.clear()
+    root_logger.setLevel(normalized_level)
+
+    handler = logging.StreamHandler(stream=sys.stdout)
+    handler.setLevel(normalized_level)
+    handler.addFilter(RequestContextFilter())
+
+    normalized_format = log_format.strip().lower()
+    if normalized_format == "json":
+        handler.setFormatter(JsonLogFormatter(redact_fields=redact_fields))
+    else:
+        handler.setFormatter(ConsoleLogFormatter(redact_fields=redact_fields))
+
+    root_logger.addHandler(handler)
+
+    # Route server/framework logs through our single root handler.
+    for logger_name in ("uvicorn", "uvicorn.error"):
+        framework_logger = logging.getLogger(logger_name)
+        framework_logger.handlers.clear()
+        framework_logger.propagate = True
+        framework_logger.setLevel(normalized_level)
+
+    access_logger = logging.getLogger("uvicorn.access")
+    access_logger.handlers.clear()
+    access_logger.propagate = True
+    access_logger.setLevel(normalized_level if include_uvicorn_access else logging.WARNING)
+
+
+class RequestContextFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        if not getattr(record, "request_id", None):
+            request_id = get_request_id()
+            if request_id:
+                record.request_id = request_id
+        return True
+
+
+class JsonLogFormatter(logging.Formatter):
+    def __init__(self, *, redact_fields: set[str]) -> None:
+        super().__init__()
+        self._redact_fields = {field.lower() for field in redact_fields}
+
+    def format(self, record: logging.LogRecord) -> str:
+        payload: dict[str, Any] = {
+            "timestamp": _format_timestamp(record.created),
+            "level": record.levelname.lower(),
+            "logger": record.name,
+            "event": getattr(record, "event", record.getMessage()),
+        }
+        request_id = getattr(record, "request_id", None)
+        if request_id:
+            payload["request_id"] = request_id
+        payload.update(self._redact_mapping(_extra_fields(record)))
+        if record.exc_info:
+            payload["exception"] = self.formatException(record.exc_info)
+        return json.dumps(payload, ensure_ascii=True, default=str)
+
+    def _redact_mapping(self, value: dict[str, Any]) -> dict[str, Any]:
+        return {key: self._redact_value(key, item) for key, item in value.items()}
+
+    def _redact_value(self, key: str, value: Any) -> Any:
+        if key.lower() in self._redact_fields:
+            return "[REDACTED]"
+        if isinstance(value, dict):
+            return {nested_key: self._redact_value(nested_key, nested_value) for nested_key, nested_value in value.items()}
+        if isinstance(value, (list, tuple)):
+            return [self._redact_value(key, item) for item in value]
+        return value
+
+
+class ConsoleLogFormatter(logging.Formatter):
+    def __init__(self, *, redact_fields: set[str]) -> None:
+        super().__init__()
+        self._json_formatter = JsonLogFormatter(redact_fields=redact_fields)
+
+    def format(self, record: logging.LogRecord) -> str:
+        payload = json.loads(self._json_formatter.format(record))
+        timestamp = payload.get("timestamp", "")
+        level = _short_level(payload.get("level", "info"))
+        logger_name = str(payload.get("logger", "app"))
+        event = str(payload.get("event", ""))
+
+        parts = [timestamp, level, logger_name, event]
+
+        request_id = payload.pop("request_id", None)
+        method = payload.pop("method", None)
+        path = payload.pop("path", None)
+        status_code = payload.pop("status_code", None)
+        duration_ms = payload.pop("duration_ms", None)
+
+        if request_id:
+            parts.append(f"rid={request_id}")
+        if method and path:
+            parts.append(f"{method} {path}")
+        if status_code is not None:
+            parts.append(str(status_code))
+        if duration_ms is not None:
+            parts.append(f"{duration_ms}ms")
+
+        for key in sorted(payload.keys()):
+            if key in {"timestamp", "level", "logger", "event", "exception"}:
+                continue
+            parts.append(f"{key}={payload[key]}")
+
+        if "exception" in payload:
+            parts.append(f"exception={payload['exception']}")
+
+        return " | ".join(str(part) for part in parts if part)
+
+
+def _extra_fields(record: logging.LogRecord) -> dict[str, Any]:
+    extras: dict[str, Any] = {}
+    for key, value in record.__dict__.items():
+        if key in _STANDARD_RECORD_FIELDS or key.startswith("_"):
+            continue
+        if key in _NOISY_RECORD_FIELDS:
+            continue
+        extras[key] = value
+    return extras
+
+
+def _normalize_level(level: str) -> int:
+    normalized = level.strip().upper()
+    mapping = logging.getLevelNamesMapping()
+    if normalized not in mapping:
+        return logging.INFO
+    return mapping[normalized]
+
+
+def _format_timestamp(created_ts: float) -> str:
+    dt = datetime.fromtimestamp(created_ts, tz=timezone.utc)
+    return dt.strftime("%Y-%m-%d %H:%M:%SZ")
+
+
+def _short_level(level: str) -> str:
+    mapping = {
+        "debug": "DBG",
+        "info": "INF",
+        "warning": "WRN",
+        "error": "ERR",
+        "critical": "CRT",
+    }
+    return mapping.get(level.lower(), level[:3].upper())
diff --git a/build/lib/app/logging_context.py b/build/lib/app/logging_context.py
new file mode 100644
index 0000000..ee578fb
--- /dev/null
+++ b/build/lib/app/logging_context.py
@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from contextvars import ContextVar
+
+
+_request_id_ctx: ContextVar[str | None] = ContextVar("request_id", default=None)
+
+
+def get_request_id() -> str | None:
+    return _request_id_ctx.get()
+
+
+def set_request_id(value: str | None) -> None:
+    _request_id_ctx.set(value)
+
diff --git a/build/lib/app/main.py b/build/lib/app/main.py
new file mode 100644
index 0000000..e628bd9
--- /dev/null
+++ b/build/lib/app/main.py
@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+import logging
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from starlette.middleware.sessions import SessionMiddleware
+
+from app.api.errors import register_api_exception_handlers
+from app.api.media import router as media_router
+from app.api.router import router as api_router
+from app.api.runtime_deps import get_ingestion_service, get_scholar_source
+from app.db.session import check_database
+from app.db.session import close_engine
+from app.http.middleware import (
+    RequestLoggingMiddleware,
+    SecurityHeadersMiddleware,
+    parse_skip_paths,
+)
+from app.logging_config import configure_logging, parse_redact_fields
+from app.security.csrf import CSRFMiddleware
+from app.services.domains.ingestion.scheduler import SchedulerService
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+BUILD_MARKER = "2026-02-19.phase2.direct-pdf-import-export-dashboard-sync"
+
+configure_logging(
+    level=settings.log_level,
+    log_format=settings.log_format,
+    redact_fields=parse_redact_fields(settings.log_redact_fields),
+    include_uvicorn_access=settings.log_uvicorn_access,
+)
+
+scheduler_service = SchedulerService(
+    enabled=settings.scheduler_enabled,
+    tick_seconds=settings.scheduler_tick_seconds,
+    network_error_retries=settings.ingestion_network_error_retries,
+    retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
+    max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
+    page_size=settings.ingestion_page_size,
+    continuation_queue_enabled=settings.ingestion_continuation_queue_enabled,
+    continuation_base_delay_seconds=settings.ingestion_continuation_base_delay_seconds,
+    continuation_max_delay_seconds=settings.ingestion_continuation_max_delay_seconds,
+    continuation_max_attempts=settings.ingestion_continuation_max_attempts,
+    queue_batch_size=settings.scheduler_queue_batch_size,
+)
+
+
+def _log_startup_build_marker() -> None:
+    logger.info(
+        "app.startup_build_marker",
+        extra={
+            "event": "app.startup_build_marker",
+            "build_marker": BUILD_MARKER,
+            "frontend_enabled": settings.frontend_enabled,
+            "scheduler_enabled": settings.scheduler_enabled,
+            "log_format": settings.log_format,
+        },
+    )
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    _log_startup_build_marker()
+    
+    from app.db.session import get_session_factory
+    from sqlalchemy import text
+    try:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            await session.execute(text("UPDATE crawl_runs SET status = 'failed' WHERE status = 'running'"))
+            await session.commit()
+            logger.info("app.startup_orphaned_runs_cleaned", extra={"event": "app.startup_orphaned_runs_cleaned"})
+    except Exception as e:
+        logger.error(f"Failed to clean orphaned runs at startup: {e}")
+
+    await scheduler_service.start()
+    yield
+    await scheduler_service.stop()
+    await close_engine()
+
+
+app = FastAPI(title=settings.app_name, lifespan=lifespan)
+register_api_exception_handlers(app)
+app.add_middleware(CSRFMiddleware)
+app.add_middleware(
+    SessionMiddleware,
+    secret_key=settings.session_secret_key,
+    same_site="lax",
+    https_only=settings.session_cookie_secure,
+)
+app.add_middleware(
+    RequestLoggingMiddleware,
+    log_requests=settings.log_requests,
+    skip_paths=parse_skip_paths(settings.log_request_skip_paths),
+)
+app.add_middleware(
+    SecurityHeadersMiddleware,
+    enabled=settings.security_headers_enabled,
+    x_content_type_options=settings.security_x_content_type_options,
+    x_frame_options=settings.security_x_frame_options,
+    referrer_policy=settings.security_referrer_policy,
+    permissions_policy=settings.security_permissions_policy,
+    cross_origin_opener_policy=settings.security_cross_origin_opener_policy,
+    cross_origin_resource_policy=settings.security_cross_origin_resource_policy,
+    content_security_policy_enabled=settings.security_csp_enabled,
+    content_security_policy=settings.security_csp_policy,
+    content_security_policy_docs=settings.security_csp_docs_policy,
+    content_security_policy_report_only=settings.security_csp_report_only,
+    strict_transport_security_enabled=settings.security_strict_transport_security_enabled,
+    strict_transport_security_max_age=settings.security_strict_transport_security_max_age,
+    strict_transport_security_include_subdomains=(
+        settings.security_strict_transport_security_include_subdomains
+    ),
+    strict_transport_security_preload=settings.security_strict_transport_security_preload,
+)
+app.include_router(api_router)
+app.include_router(media_router)
+
+
+@app.get("/healthz")
+async def healthz() -> dict[str, str]:
+    if await check_database():
+        return {"status": "ok"}
+    raise HTTPException(status_code=500, detail="database unavailable")
+
+
+def _configure_frontend_routes(application: FastAPI) -> None:
+    if not settings.frontend_enabled:
+        return
+
+    dist_dir = Path(settings.frontend_dist_dir)
+    index_file = dist_dir / "index.html"
+
+    if not index_file.is_file():
+        return
+
+    assets_dir = dist_dir / "assets"
+    if assets_dir.is_dir():
+        application.mount("/assets", StaticFiles(directory=assets_dir), name="frontend-assets")
+
+    @application.get("/", include_in_schema=False)
+    async def frontend_index() -> FileResponse:
+        return FileResponse(index_file)
+
+    @application.get("/{full_path:path}", include_in_schema=False)
+    async def frontend_entry(full_path: str) -> FileResponse:
+        normalized = full_path.lstrip("/")
+        if normalized in {"healthz", "api"} or normalized.startswith("api/"):
+            raise HTTPException(status_code=404, detail="Not Found")
+
+        candidate = (dist_dir / normalized).resolve()
+        try:
+            candidate.relative_to(dist_dir.resolve())
+        except ValueError as error:
+            raise HTTPException(status_code=404, detail="Not Found") from error
+
+        if candidate.is_file():
+            return FileResponse(candidate)
+
+        return FileResponse(index_file)
+
+
+_configure_frontend_routes(app)
diff --git a/build/lib/app/security/__init__.py b/build/lib/app/security/__init__.py
new file mode 100644
index 0000000..4033692
--- /dev/null
+++ b/build/lib/app/security/__init__.py
@@ -0,0 +1,2 @@
+"""Security middleware and helpers for scholarr."""
+
diff --git a/build/lib/app/security/csrf.py b/build/lib/app/security/csrf.py
new file mode 100644
index 0000000..70eecac
--- /dev/null
+++ b/build/lib/app/security/csrf.py
@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import logging
+from secrets import compare_digest, token_urlsafe
+from urllib.parse import parse_qs
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse, PlainTextResponse, Response
+from starlette.types import Message
+
+
+CSRF_SESSION_KEY = "csrf_token"
+CSRF_FORM_FIELD = "csrf_token"
+CSRF_HEADER_NAME = "x-csrf-token"
+SAFE_METHODS = {"GET", "HEAD", "OPTIONS", "TRACE"}
+logger = logging.getLogger(__name__)
+
+
+def ensure_csrf_token(request: Request) -> str:
+    token = request.session.get(CSRF_SESSION_KEY)
+    if token is None:
+        token = token_urlsafe(32)
+        request.session[CSRF_SESSION_KEY] = token
+    return str(token)
+
+
+class CSRFMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, *, exempt_paths: set[str] | None = None) -> None:
+        super().__init__(app)
+        self._exempt_paths = exempt_paths or set()
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        if self._should_skip(request):
+            return await call_next(request)
+
+        session_token = request.session.get(CSRF_SESSION_KEY)
+        if not session_token:
+            logger.warning(
+                "csrf.missing_session_token",
+                extra={
+                    "event": "csrf.missing_session_token",
+                    "method": request.method,
+                    "path": request.url.path,
+                },
+            )
+            return self._csrf_error_response(
+                request,
+                code="csrf_missing",
+                message="CSRF token missing.",
+            )
+
+        request_token = request.headers.get(CSRF_HEADER_NAME)
+        if request_token is None and self._is_form_payload(request):
+            body = await request.body()
+            request_token = self._token_from_form_body(request, body)
+            request._receive = self._build_receive(body)  # type: ignore[attr-defined]
+
+        if not request_token or not compare_digest(str(session_token), str(request_token)):
+            logger.warning(
+                "csrf.invalid_token",
+                extra={
+                    "event": "csrf.invalid_token",
+                    "method": request.method,
+                    "path": request.url.path,
+                },
+            )
+            return self._csrf_error_response(
+                request,
+                code="csrf_invalid",
+                message="CSRF token invalid.",
+            )
+
+        return await call_next(request)
+
+    def _should_skip(self, request: Request) -> bool:
+        if request.method in SAFE_METHODS:
+            return True
+        path = request.url.path
+        return path in self._exempt_paths
+
+    def _is_form_payload(self, request: Request) -> bool:
+        content_type = request.headers.get("content-type", "")
+        return content_type.startswith("application/x-www-form-urlencoded") or (
+            content_type.startswith("multipart/form-data")
+        )
+
+    def _token_from_form_body(self, request: Request, body: bytes) -> str | None:
+        content_type = request.headers.get("content-type", "")
+        if not content_type.startswith("application/x-www-form-urlencoded"):
+            return None
+        parsed = parse_qs(body.decode("utf-8"), keep_blank_values=True)
+        values = parsed.get(CSRF_FORM_FIELD)
+        if not values:
+            return None
+        return values[0]
+
+    def _build_receive(self, body: bytes):
+        consumed = False
+
+        async def receive() -> Message:
+            nonlocal consumed
+            if consumed:
+                return {"type": "http.request", "body": b"", "more_body": False}
+            consumed = True
+            return {"type": "http.request", "body": body, "more_body": False}
+
+        return receive
+
+    def _csrf_error_response(
+        self,
+        request: Request,
+        *,
+        code: str,
+        message: str,
+    ) -> Response:
+        if request.url.path.startswith("/api/"):
+            request_state = getattr(request, "state", None)
+            request_id = getattr(request_state, "request_id", None) if request_state else None
+            return JSONResponse(
+                {
+                    "error": {
+                        "code": code,
+                        "message": message,
+                        "details": None,
+                    },
+                    "meta": {
+                        "request_id": request_id,
+                    },
+                },
+                status_code=403,
+            )
+        return PlainTextResponse(message, status_code=403)
diff --git a/build/lib/app/services/__init__.py b/build/lib/app/services/__init__.py
new file mode 100644
index 0000000..167f869
--- /dev/null
+++ b/build/lib/app/services/__init__.py
@@ -0,0 +1,2 @@
+"""Service layer for scholarr application workflows."""
+
diff --git a/build/lib/app/services/domains/__init__.py b/build/lib/app/services/domains/__init__.py
new file mode 100644
index 0000000..9d48db4
--- /dev/null
+++ b/build/lib/app/services/domains/__init__.py
@@ -0,0 +1 @@
+from __future__ import annotations
diff --git a/build/lib/app/services/domains/arxiv/application.py b/build/lib/app/services/domains/arxiv/application.py
new file mode 100644
index 0000000..1581a7d
--- /dev/null
+++ b/build/lib/app/services/domains/arxiv/application.py
@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+import xml.etree.ElementTree as ET
+
+import httpx
+
+from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
+from app.settings import settings
+
+if TYPE_CHECKING:
+    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+
+logger = logging.getLogger(__name__)
+
+
+def _build_arxiv_query(title: str, author_surname: str | None) -> str | None:
+    parts = []
+    if title:
+        # arXiv api allows strict title searching using ti:
+        clean_title = title.replace('"', '').replace("'", "")
+        parts.append(f'ti:"{clean_title}"')
+    if author_surname:
+        parts.append(f'au:"{author_surname}"')
+    
+    if not parts:
+        return None
+    return " AND ".join(parts)
+
+
+async def discover_arxiv_id_for_publication(
+    *,
+    item: PublicationListItem | UnreadPublicationItem,
+    request_email: str | None = None,
+    timeout_seconds: float = 3.0,
+) -> str | None:
+    title = (item.title or "").strip()
+    if not title:
+        return None
+        
+    author_surname = None
+    if item.scholar_label:
+        tokens = [t for t in item.scholar_label.strip().split() if t]
+        if tokens:
+            author_surname = tokens[-1].lower()
+
+    query = _build_arxiv_query(title, author_surname)
+    if not query:
+        return None
+
+    url = "https://export.arxiv.org/api/query"
+    params = {
+        "search_query": query,
+        "start": 0,
+        "max_results": 3,
+    }
+
+    headers = {"User-Agent": f"scholar-scraper/1.0 (mailto:{request_email or settings.crossref_api_mailto or 'unknown@example.com'})"}
+    
+    try:
+        async with httpx.AsyncClient(timeout=timeout_seconds, follow_redirects=True, headers=headers) as client:
+            response = await client.get(url, params=params)
+            response.raise_for_status()
+            
+        root = ET.fromstring(response.text)
+        namespace = {'atom': 'http://www.w3.org/2005/Atom'}
+        
+        for entry in root.findall('atom:entry', namespace):
+            id_elem = entry.find('atom:id', namespace)
+            if id_elem is not None and id_elem.text:
+                candidate = str(id_elem.text)
+                if '/abs/' in candidate:
+                    candidate = candidate.split('/abs/')[-1]
+                normalized = normalize_arxiv_id(candidate)
+                if normalized:
+                    logger.debug("arxiv.id_discovered", extra={"event": "arxiv.id_discovered", "arxiv_id": normalized})
+                    return normalized
+                    
+    except Exception as exc:
+        logger.debug(f"Failed to query arXiv API: {exc}")
+        
+    return None
diff --git a/build/lib/app/services/domains/crossref/__init__.py b/build/lib/app/services/domains/crossref/__init__.py
new file mode 100644
index 0000000..8adb7ba
--- /dev/null
+++ b/build/lib/app/services/domains/crossref/__init__.py
@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from app.services.domains.crossref.application import discover_doi_for_publication
+
+__all__ = ["discover_doi_for_publication"]
diff --git a/build/lib/app/services/domains/crossref/application.py b/build/lib/app/services/domains/crossref/application.py
new file mode 100644
index 0000000..f0e1311
--- /dev/null
+++ b/build/lib/app/services/domains/crossref/application.py
@@ -0,0 +1,382 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+import threading
+import time
+from typing import TYPE_CHECKING
+
+from crossref.restful import Etiquette, Works
+
+from app.services.domains.doi.normalize import normalize_doi
+from app.settings import settings
+
+if TYPE_CHECKING:
+    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+
+TOKEN_RE = re.compile(r"[a-z0-9]+")
+NON_ALNUM_RE = re.compile(r"[^a-z0-9\\s]+")
+STOP_WORDS = {"the", "and", "for", "with", "from", "method", "study", "analysis"}
+_RATE_LOCK = threading.Lock()
+_LAST_REQUEST_AT = 0.0
+logger = logging.getLogger(__name__)
+STRICT_TITLE_MATCH_THRESHOLD = 0.75
+RELAXED_TITLE_MATCH_THRESHOLD = 0.85
+
+
+def _rate_limit_wait(min_interval_seconds: float) -> None:
+    global _LAST_REQUEST_AT
+    interval = max(float(min_interval_seconds), 0.0)
+    with _RATE_LOCK:
+        elapsed = time.monotonic() - _LAST_REQUEST_AT
+        remaining = interval - elapsed
+        if remaining > 0:
+            time.sleep(remaining)
+        _LAST_REQUEST_AT = time.monotonic()
+
+
+def _normalized_tokens(value: str) -> list[str]:
+    lowered = value.lower().replace("’", "'").replace("“", "\"").replace("”", "\"")
+    lowered = NON_ALNUM_RE.sub(" ", lowered)
+    return [token for token in TOKEN_RE.findall(lowered) if len(token) >= 3]
+
+
+def _normalized_query(value: str) -> str:
+    tokens = [token for token in _normalized_tokens(value) if token not in STOP_WORDS]
+    if len(tokens) < 3:
+        tokens = _normalized_tokens(value)
+    if len(tokens) < 3:
+        return ""
+    return " ".join(tokens[:12]).strip()
+
+
+def _query_author(value: str) -> str | None:
+    tokens = [token for token in value.strip().split() if token]
+    if len(tokens) < 2:
+        return None
+    return " ".join(tokens[:2])[:64]
+
+
+def _author_surname(value: str) -> str | None:
+    tokens = [token for token in value.strip().split() if token]
+    if not tokens:
+        return None
+    return NON_ALNUM_RE.sub("", tokens[-1].lower()) or None
+
+
+def _query_filters(year: int | None) -> list[tuple[str, str] | None]:
+    if year is None:
+        return [None]
+    return [
+        (f"{year - 1}-01-01", f"{year + 1}-12-31"),
+        (f"{year}-01-01", f"{year}-12-31"),
+        None,
+    ]
+
+
+def _candidate_title(item: dict) -> str:
+    titles = item.get("title")
+    if isinstance(titles, list) and titles:
+        return str(titles[0] or "")
+    return str(item.get("title") or "")
+
+
+def _title_match_score(source: str, candidate: str) -> float:
+    source_tokens = {token for token in _normalized_tokens(source) if len(token) >= 3}
+    candidate_tokens = {token for token in _normalized_tokens(candidate) if len(token) >= 3}
+    if not source_tokens or not candidate_tokens:
+        return 0.0
+    return len(source_tokens & candidate_tokens) / float(len(source_tokens))
+
+
+def _candidate_year(item: dict) -> int | None:
+    issued = item.get("issued")
+    if not isinstance(issued, dict):
+        return None
+    date_parts = issued.get("date-parts")
+    if not isinstance(date_parts, list) or not date_parts:
+        return None
+    first = date_parts[0]
+    if not isinstance(first, list) or not first:
+        return None
+    try:
+        return int(first[0])
+    except (TypeError, ValueError):
+        return None
+
+
+def _candidate_author_match(item: dict, surname: str | None) -> bool:
+    if not surname:
+        return True
+    authors = item.get("author")
+    if not isinstance(authors, list):
+        return False
+    for author in authors:
+        if not isinstance(author, dict):
+            continue
+        family = NON_ALNUM_RE.sub("", str(author.get("family") or "").lower())
+        if family and family == surname:
+            return True
+    return False
+
+
+def _candidate_rank(*, title: str, year: int | None, item: dict) -> tuple[float, str | None]:
+    doi = normalize_doi(str(item.get("DOI") or ""))
+    if doi is None:
+        return 0.0, None
+    score = _title_match_score(title, _candidate_title(item))
+    candidate_year = _candidate_year(item)
+    if year is not None and candidate_year is not None:
+        if abs(year - candidate_year) > 1:
+            return 0.0, None
+        score += 0.1
+    return score, doi
+
+
+def _year_delta(source_year: int | None, candidate_year: int | None) -> int | None:
+    if source_year is None or candidate_year is None:
+        return None
+    return abs(int(source_year) - int(candidate_year))
+
+
+def _candidate_rank_relaxed(
+    *,
+    title: str,
+    year: int | None,
+    item: dict,
+    author_surname: str | None,
+) -> tuple[float, str | None]:
+    doi = normalize_doi(str(item.get("DOI") or ""))
+    if doi is None:
+        return 0.0, None
+    score = _title_match_score(title, _candidate_title(item))
+    if score <= 0:
+        return 0.0, None
+    candidate_year = _candidate_year(item)
+    delta = _year_delta(year, candidate_year)
+    if delta is not None:
+        if delta <= 1:
+            score += 0.05
+        elif delta <= 3:
+            score += 0.0
+        elif delta <= 5:
+            score -= 0.03
+        else:
+            score -= 0.08
+    if _candidate_author_match(item, author_surname):
+        score += 0.03
+    return score, doi
+
+
+def _best_candidate_doi_strict(
+    *,
+    title: str,
+    year: int | None,
+    items: list[dict],
+    author_surname: str | None,
+) -> str | None:
+    best_score = 0.0
+    best_doi: str | None = None
+    best_year: int | None = None
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        if not _candidate_author_match(item, author_surname):
+            continue
+        score, doi = _candidate_rank(title=title, year=year, item=item)
+        candidate_year = _candidate_year(item)
+        if doi is None or score < STRICT_TITLE_MATCH_THRESHOLD:
+            continue
+        if score > best_score:
+            best_score = score
+            best_doi = doi
+            best_year = candidate_year
+            continue
+        if abs(score - best_score) > 0.02:
+            continue
+        if best_year is None or candidate_year is None:
+            continue
+        if candidate_year < best_year:
+            best_doi = doi
+            best_year = candidate_year
+    return best_doi
+
+
+def _best_candidate_doi_relaxed(
+    *,
+    title: str,
+    year: int | None,
+    items: list[dict],
+    author_surname: str | None,
+) -> str | None:
+    best_score = 0.0
+    best_doi: str | None = None
+    best_author_match = False
+    best_delta: int | None = None
+    best_year: int | None = None
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        score, doi = _candidate_rank_relaxed(
+            title=title,
+            year=year,
+            item=item,
+            author_surname=author_surname,
+        )
+        if doi is None or score < RELAXED_TITLE_MATCH_THRESHOLD:
+            continue
+        candidate_year = _candidate_year(item)
+        candidate_author_match = _candidate_author_match(item, author_surname)
+        candidate_delta = _year_delta(year, candidate_year)
+        if score > best_score:
+            best_score = score
+            best_doi = doi
+            best_author_match = candidate_author_match
+            best_delta = candidate_delta
+            best_year = candidate_year
+            continue
+        if abs(score - best_score) > 0.02:
+            continue
+        if candidate_author_match and not best_author_match:
+            best_doi = doi
+            best_author_match = True
+            best_delta = candidate_delta
+            best_year = candidate_year
+            continue
+        if best_delta is None and candidate_delta is not None:
+            best_doi = doi
+            best_author_match = candidate_author_match
+            best_delta = candidate_delta
+            best_year = candidate_year
+            continue
+        if best_delta is not None and candidate_delta is not None and candidate_delta < best_delta:
+            best_doi = doi
+            best_author_match = candidate_author_match
+            best_delta = candidate_delta
+            best_year = candidate_year
+            continue
+        if best_year is None or candidate_year is None:
+            continue
+        if candidate_year < best_year:
+            best_doi = doi
+            best_author_match = candidate_author_match
+            best_delta = candidate_delta
+            best_year = candidate_year
+    return best_doi
+
+
+def _best_candidate_doi(
+    *,
+    title: str,
+    year: int | None,
+    items: list[dict],
+    author_surname: str | None,
+) -> str | None:
+    strict_match = _best_candidate_doi_strict(
+        title=title,
+        year=year,
+        items=items,
+        author_surname=author_surname,
+    )
+    if strict_match:
+        return strict_match
+    return _best_candidate_doi_relaxed(
+        title=title,
+        year=year,
+        items=items,
+        author_surname=author_surname,
+    )
+
+
+def _works_client(email: str | None) -> Works:
+    if email:
+        etiquette = Etiquette(settings.app_name, "0.1.0", "https://scholarr.local", email)
+        return Works(etiquette=etiquette)
+    return Works()
+
+
+def _fetch_items_sync(
+    *,
+    query: str,
+    author: str | None,
+    date_range: tuple[str, str] | None,
+    max_rows: int,
+    email: str | None,
+    min_interval_seconds: float,
+) -> list[dict]:
+    _rate_limit_wait(min_interval_seconds)
+    works = _works_client(email)
+    params = {"bibliographic": query}
+    if author:
+        params["author"] = author
+    request = works.query(**params)
+    if date_range is not None:
+        from_date, until_date = date_range
+        request = request.filter(from_pub_date=from_date, until_pub_date=until_date)
+    request = request.select(["DOI", "title", "issued", "score", "author"])
+    items: list[dict] = []
+    for entry in request:
+        if isinstance(entry, dict):
+            items.append(entry)
+        if len(items) >= max(max_rows, 1):
+            break
+    return items
+
+
+async def _fetch_items(
+    *,
+    query: str,
+    author: str | None,
+    date_range: tuple[str, str] | None,
+    max_rows: int,
+    email: str | None,
+) -> list[dict]:
+    timeout = max(float(settings.crossref_timeout_seconds), 0.5)
+    try:
+        return await asyncio.wait_for(
+            asyncio.to_thread(
+                _fetch_items_sync,
+                query=query,
+                author=author,
+                date_range=date_range,
+                max_rows=max_rows,
+                email=email,
+                min_interval_seconds=settings.crossref_min_interval_seconds,
+            ),
+            timeout=timeout,
+        )
+    except Exception:
+        return []
+
+
+async def discover_doi_for_publication(
+    *,
+    item: PublicationListItem | UnreadPublicationItem,
+    max_rows: int = 10,
+    email: str | None = None,
+) -> str | None:
+    title = (item.title or "").strip()
+    query = _normalized_query(title)
+    if not query:
+        return None
+    author = _query_author(item.scholar_label)
+    author_surname = _author_surname(item.scholar_label)
+    for date_range in _query_filters(item.year):
+        items = await _fetch_items(
+            query=query,
+            author=author,
+            date_range=date_range,
+            max_rows=max_rows,
+            email=email,
+        )
+        doi = _best_candidate_doi(
+            title=title,
+            year=item.year,
+            items=items,
+            author_surname=author_surname,
+        )
+        if doi:
+            logger.debug("crossref.doi_discovered", extra={"event": "crossref.doi_discovered"})
+            return doi
+    return None
diff --git a/build/lib/app/services/domains/dbops/__init__.py b/build/lib/app/services/domains/dbops/__init__.py
new file mode 100644
index 0000000..f5b02e4
--- /dev/null
+++ b/build/lib/app/services/domains/dbops/__init__.py
@@ -0,0 +1,5 @@
+from app.services.domains.dbops.application import run_publication_link_repair
+from app.services.domains.dbops.integrity import collect_integrity_report
+from app.services.domains.dbops.query import list_repair_jobs
+
+__all__ = ["collect_integrity_report", "list_repair_jobs", "run_publication_link_repair"]
diff --git a/build/lib/app/services/domains/dbops/application.py b/build/lib/app/services/domains/dbops/application.py
new file mode 100644
index 0000000..e7ace77
--- /dev/null
+++ b/build/lib/app/services/domains/dbops/application.py
@@ -0,0 +1,364 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from sqlalchemy import delete, exists, func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import DataRepairJob, IngestionQueueItem, Publication, ScholarProfile, ScholarPublication
+
+
+REPAIR_STATUS_PLANNED = "planned"
+REPAIR_STATUS_RUNNING = "running"
+REPAIR_STATUS_COMPLETED = "completed"
+REPAIR_STATUS_FAILED = "failed"
+SCOPE_MODE_SINGLE_USER = "single_user"
+SCOPE_MODE_ALL_USERS = "all_users"
+
+
+def _utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _normalize_scope_mode(scope_mode: str) -> str:
+    normalized = scope_mode.strip().lower()
+    if normalized in {SCOPE_MODE_SINGLE_USER, SCOPE_MODE_ALL_USERS}:
+        return normalized
+    raise ValueError("Unknown scope mode.")
+
+
+def _scope_user_id(*, scope_mode: str, user_id: int | None) -> int | None:
+    if scope_mode == SCOPE_MODE_SINGLE_USER:
+        if user_id is None:
+            raise ValueError("user_id is required when scope_mode=single_user.")
+        return int(user_id)
+    if user_id is not None:
+        raise ValueError("user_id must be omitted when scope_mode=all_users.")
+    return None
+
+
+def _scope_payload(
+    *,
+    scope_mode: str,
+    user_id: int | None,
+    target_scholar_profile_ids: list[int],
+    orphan_gc: bool,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "scope_mode": scope_mode,
+        "scholar_profile_ids": [int(value) for value in target_scholar_profile_ids],
+        "gc_orphan_publications": bool(orphan_gc),
+    }
+    if user_id is not None:
+        payload["user_id"] = int(user_id)
+    return payload
+
+
+async def _target_scholar_profile_ids(
+    db_session: AsyncSession,
+    *,
+    scope_mode: str,
+    user_id: int | None,
+    scholar_profile_ids: list[int] | None,
+) -> list[int]:
+    stmt = select(ScholarProfile.id)
+    if scope_mode == SCOPE_MODE_SINGLE_USER:
+        stmt = stmt.where(ScholarProfile.user_id == user_id)
+    if scholar_profile_ids:
+        normalized_ids = [int(value) for value in scholar_profile_ids]
+        stmt = stmt.where(ScholarProfile.id.in_(normalized_ids))
+    result = await db_session.execute(stmt.order_by(ScholarProfile.id.asc()))
+    ids = [int(row[0]) for row in result.all()]
+    if not ids:
+        raise ValueError("No target scholar profiles found for the requested scope.")
+    return ids
+
+
+async def _count_scope(
+    db_session: AsyncSession,
+    *,
+    user_id: int | None,
+    target_scholar_profile_ids: list[int],
+) -> dict[str, int]:
+    links_result = await db_session.execute(
+        select(func.count())
+        .select_from(ScholarPublication)
+        .where(ScholarPublication.scholar_profile_id.in_(target_scholar_profile_ids))
+    )
+    queue_stmt = (
+        select(func.count())
+        .select_from(IngestionQueueItem)
+        .where(IngestionQueueItem.scholar_profile_id.in_(target_scholar_profile_ids))
+    )
+    if user_id is not None:
+        queue_stmt = queue_stmt.where(IngestionQueueItem.user_id == user_id)
+    queue_result = await db_session.execute(queue_stmt)
+    return {
+        "target_scholar_count": len(target_scholar_profile_ids),
+        "links_in_scope": int(links_result.scalar_one() or 0),
+        "queue_items_in_scope": int(queue_result.scalar_one() or 0),
+    }
+
+
+async def _count_orphan_publications(db_session: AsyncSession) -> int:
+    stmt = (
+        select(func.count())
+        .select_from(Publication)
+        .where(
+            ~exists(
+                select(1).where(ScholarPublication.publication_id == Publication.id)
+            )
+        )
+    )
+    result = await db_session.execute(stmt)
+    return int(result.scalar_one() or 0)
+
+
+async def _create_job(
+    db_session: AsyncSession,
+    *,
+    requested_by: str | None,
+    scope: dict[str, Any],
+    dry_run: bool,
+) -> DataRepairJob:
+    job = DataRepairJob(
+        job_name="repair_publication_links",
+        requested_by=(requested_by or "").strip() or None,
+        scope=scope,
+        dry_run=dry_run,
+        status=REPAIR_STATUS_PLANNED,
+        summary={},
+    )
+    db_session.add(job)
+    await db_session.flush()
+    return job
+
+
+def _job_summary(
+    *,
+    counts: dict[str, int],
+    dry_run: bool,
+    links_deleted: int,
+    queue_items_deleted: int,
+    scholars_reset: int,
+    orphan_publications_before: int,
+    orphan_publications_deleted: int,
+) -> dict[str, Any]:
+    return {
+        **counts,
+        "dry_run": bool(dry_run),
+        "links_deleted": int(links_deleted),
+        "queue_items_deleted": int(queue_items_deleted),
+        "scholars_reset": int(scholars_reset),
+        "orphan_publications_before": int(orphan_publications_before),
+        "orphan_publications_deleted": int(orphan_publications_deleted),
+    }
+
+
+async def _delete_links_for_targets(db_session: AsyncSession, *, target_scholar_profile_ids: list[int]) -> int:
+    result = await db_session.execute(
+        delete(ScholarPublication).where(
+            ScholarPublication.scholar_profile_id.in_(target_scholar_profile_ids)
+        )
+    )
+    return int(result.rowcount or 0)
+
+
+async def _delete_queue_for_targets(
+    db_session: AsyncSession,
+    *,
+    user_id: int | None,
+    target_scholar_profile_ids: list[int],
+) -> int:
+    stmt = delete(IngestionQueueItem).where(
+        IngestionQueueItem.scholar_profile_id.in_(target_scholar_profile_ids)
+    )
+    if user_id is not None:
+        stmt = stmt.where(IngestionQueueItem.user_id == user_id)
+    result = await db_session.execute(stmt)
+    return int(result.rowcount or 0)
+
+
+async def _reset_scholar_tracking_state(
+    db_session: AsyncSession,
+    *,
+    user_id: int | None,
+    target_scholar_profile_ids: list[int],
+) -> int:
+    stmt = update(ScholarProfile).where(ScholarProfile.id.in_(target_scholar_profile_ids))
+    if user_id is not None:
+        stmt = stmt.where(ScholarProfile.user_id == user_id)
+    result = await db_session.execute(
+        stmt.values(
+            baseline_completed=False,
+            last_initial_page_fingerprint_sha256=None,
+            last_initial_page_checked_at=None,
+            last_run_dt=None,
+            last_run_status=None,
+        )
+    )
+    return int(result.rowcount or 0)
+
+
+async def _delete_orphan_publications(db_session: AsyncSession) -> int:
+    result = await db_session.execute(
+        delete(Publication).where(
+            ~exists(select(1).where(ScholarPublication.publication_id == Publication.id))
+        )
+    )
+    return int(result.rowcount or 0)
+
+
+async def _mutation_counts(
+    db_session: AsyncSession,
+    *,
+    user_id: int | None,
+    target_ids: list[int],
+    dry_run: bool,
+    gc_orphan_publications: bool,
+) -> tuple[int, int, int, int]:
+    if dry_run:
+        return 0, 0, 0, 0
+    links_deleted = await _delete_links_for_targets(
+        db_session,
+        target_scholar_profile_ids=target_ids,
+    )
+    queue_deleted = await _delete_queue_for_targets(
+        db_session,
+        user_id=user_id,
+        target_scholar_profile_ids=target_ids,
+    )
+    scholars_reset = await _reset_scholar_tracking_state(
+        db_session,
+        user_id=user_id,
+        target_scholar_profile_ids=target_ids,
+    )
+    orphan_deleted = 0
+    if gc_orphan_publications:
+        orphan_deleted = await _delete_orphan_publications(db_session)
+    return links_deleted, queue_deleted, scholars_reset, orphan_deleted
+
+
+def _result_payload(*, job: DataRepairJob, scope: dict[str, Any], summary: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "job_id": int(job.id),
+        "status": job.status,
+        "scope": scope,
+        "summary": summary,
+    }
+
+
+async def _complete_job(
+    db_session: AsyncSession,
+    *,
+    job: DataRepairJob,
+    summary: dict[str, Any],
+    scope: dict[str, Any],
+) -> dict[str, Any]:
+    job.summary = summary
+    job.status = REPAIR_STATUS_COMPLETED
+    job.finished_at = _utcnow()
+    await db_session.commit()
+    return _result_payload(job=job, scope=scope, summary=summary)
+
+
+async def _fail_job(db_session: AsyncSession, *, job: DataRepairJob, error: Exception) -> None:
+    await db_session.rollback()
+    job.status = REPAIR_STATUS_FAILED
+    job.error_text = str(error)
+    job.finished_at = _utcnow()
+    db_session.add(job)
+    await db_session.commit()
+
+
+async def _prepare_repair_job(
+    db_session: AsyncSession,
+    *,
+    scope_mode: str,
+    user_id: int | None,
+    scholar_profile_ids: list[int] | None,
+    dry_run: bool,
+    gc_orphan_publications: bool,
+    requested_by: str | None,
+) -> tuple[int | None, list[int], dict[str, Any], DataRepairJob]:
+    normalized_scope = _normalize_scope_mode(scope_mode)
+    scope_user_id = _scope_user_id(scope_mode=normalized_scope, user_id=user_id)
+    target_ids = await _target_scholar_profile_ids(
+        db_session,
+        scope_mode=normalized_scope,
+        user_id=scope_user_id,
+        scholar_profile_ids=scholar_profile_ids,
+    )
+    scope = _scope_payload(
+        scope_mode=normalized_scope,
+        user_id=scope_user_id,
+        target_scholar_profile_ids=target_ids,
+        orphan_gc=gc_orphan_publications,
+    )
+    job = await _create_job(db_session, requested_by=requested_by, scope=scope, dry_run=dry_run)
+    job.status = REPAIR_STATUS_RUNNING
+    job.started_at = _utcnow()
+    return scope_user_id, target_ids, scope, job
+
+
+async def _build_repair_summary(
+    db_session: AsyncSession,
+    *,
+    scope_user_id: int | None,
+    target_ids: list[int],
+    dry_run: bool,
+    gc_orphan_publications: bool,
+) -> dict[str, Any]:
+    counts = await _count_scope(db_session, user_id=scope_user_id, target_scholar_profile_ids=target_ids)
+    orphan_before = await _count_orphan_publications(db_session)
+    links_deleted, queue_deleted, scholars_reset, orphan_deleted = await _mutation_counts(
+        db_session,
+        user_id=scope_user_id,
+        target_ids=target_ids,
+        dry_run=dry_run,
+        gc_orphan_publications=gc_orphan_publications,
+    )
+    return _job_summary(
+        counts=counts,
+        dry_run=dry_run,
+        links_deleted=links_deleted,
+        queue_items_deleted=queue_deleted,
+        scholars_reset=scholars_reset,
+        orphan_publications_before=orphan_before,
+        orphan_publications_deleted=orphan_deleted,
+    )
+
+
+async def run_publication_link_repair(
+    db_session: AsyncSession,
+    *,
+    scope_mode: str = SCOPE_MODE_SINGLE_USER,
+    user_id: int | None = None,
+    scholar_profile_ids: list[int] | None = None,
+    dry_run: bool = True,
+    gc_orphan_publications: bool = False,
+    requested_by: str | None = None,
+) -> dict[str, Any]:
+    scope_user_id, target_ids, scope, job = await _prepare_repair_job(
+        db_session,
+        scope_mode=scope_mode,
+        user_id=user_id,
+        scholar_profile_ids=scholar_profile_ids,
+        dry_run=dry_run,
+        gc_orphan_publications=gc_orphan_publications,
+        requested_by=requested_by,
+    )
+
+    try:
+        summary = await _build_repair_summary(
+            db_session,
+            scope_user_id=scope_user_id,
+            target_ids=target_ids,
+            dry_run=dry_run,
+            gc_orphan_publications=gc_orphan_publications,
+        )
+        return await _complete_job(db_session, job=job, summary=summary, scope=scope)
+    except Exception as exc:
+        await _fail_job(db_session, job=job, error=exc)
+        raise
diff --git a/build/lib/app/services/domains/dbops/integrity.py b/build/lib/app/services/domains/dbops/integrity.py
new file mode 100644
index 0000000..4d9c43c
--- /dev/null
+++ b/build/lib/app/services/domains/dbops/integrity.py
@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from sqlalchemy import func, select, text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import Publication
+
+INTEGRITY_CHECK_DEFS = (
+    (
+        "legacy_cluster_id_format",
+        "warning",
+        "Publications with non-namespaced cluster IDs.",
+    ),
+    (
+        "negative_citation_count",
+        "failure",
+        "Publications with negative citation counts.",
+    ),
+    (
+        "orphan_publications",
+        "warning",
+        "Publications with no scholar links.",
+    ),
+    (
+        "orphan_scholar_publication_links",
+        "failure",
+        "Link rows missing parent scholar/publication.",
+    ),
+    (
+        "duplicate_fingerprint_keys",
+        "failure",
+        "Duplicate publication fingerprint keys.",
+    ),
+    (
+        "duplicate_cluster_ids",
+        "failure",
+        "Duplicate non-null publication cluster IDs.",
+    ),
+    (
+        "missing_pdf_url",
+        "metric",
+        "Publications without a resolved PDF URL.",
+    ),
+)
+
+
+async def _legacy_cluster_id_count(db_session: AsyncSession) -> int:
+    stmt = (
+        select(func.count())
+        .select_from(Publication)
+        .where(Publication.cluster_id.is_not(None))
+        .where(~Publication.cluster_id.like("cfv:%"))
+        .where(~Publication.cluster_id.like("cluster:%"))
+    )
+    result = await db_session.execute(stmt)
+    return int(result.scalar_one() or 0)
+
+
+async def _negative_citation_count(db_session: AsyncSession) -> int:
+    result = await db_session.execute(
+        select(func.count()).select_from(Publication).where(Publication.citation_count < 0)
+    )
+    return int(result.scalar_one() or 0)
+
+
+async def _missing_pdf_url_count(db_session: AsyncSession) -> int:
+    result = await db_session.execute(
+        select(func.count()).select_from(Publication).where(Publication.pdf_url.is_(None))
+    )
+    return int(result.scalar_one() or 0)
+
+
+async def _count_from_sql(db_session: AsyncSession, *, sql: str) -> int:
+    result = await db_session.execute(text(sql))
+    return int(result.scalar_one() or 0)
+
+
+def _issues_for_severity(*, checks: list[dict[str, Any]], severity: str) -> list[str]:
+    return [row["name"] for row in checks if row["severity"] == severity and row["count"] > 0]
+
+
+def _check_row(*, name: str, count: int, severity: str, message: str) -> dict[str, Any]:
+    return {
+        "name": name,
+        "count": int(count),
+        "severity": severity,
+        "message": message,
+    }
+
+
+async def _collect_counts(db_session: AsyncSession) -> dict[str, int]:
+    orphan_publications = await _count_from_sql(
+        db_session,
+        sql=(
+            "SELECT count(*) FROM publications p "
+            "LEFT JOIN scholar_publications sp ON sp.publication_id = p.id "
+            "WHERE sp.publication_id IS NULL"
+        ),
+    )
+    orphan_links = await _count_from_sql(
+        db_session,
+        sql=(
+            "SELECT count(*) FROM scholar_publications sp "
+            "LEFT JOIN publications p ON p.id = sp.publication_id "
+            "LEFT JOIN scholar_profiles s ON s.id = sp.scholar_profile_id "
+            "WHERE p.id IS NULL OR s.id IS NULL"
+        ),
+    )
+    duplicate_fingerprints = await _count_from_sql(
+        db_session,
+        sql=(
+            "SELECT count(*) FROM ("
+            "SELECT fingerprint_sha256 FROM publications "
+            "GROUP BY fingerprint_sha256 HAVING count(*) > 1"
+            ") dup"
+        ),
+    )
+    duplicate_cluster_ids = await _count_from_sql(
+        db_session,
+        sql=(
+            "SELECT count(*) FROM ("
+            "SELECT cluster_id FROM publications "
+            "WHERE cluster_id IS NOT NULL "
+            "GROUP BY cluster_id HAVING count(*) > 1"
+            ") dup"
+        ),
+    )
+    return {
+        "legacy_cluster_id_format": await _legacy_cluster_id_count(db_session),
+        "negative_citation_count": await _negative_citation_count(db_session),
+        "orphan_publications": orphan_publications,
+        "orphan_scholar_publication_links": orphan_links,
+        "duplicate_fingerprint_keys": duplicate_fingerprints,
+        "duplicate_cluster_ids": duplicate_cluster_ids,
+        "missing_pdf_url": await _missing_pdf_url_count(db_session),
+    }
+
+
+def _build_checks(*, counts: dict[str, int]) -> list[dict[str, Any]]:
+    return [
+        _check_row(
+            name=name,
+            count=counts[name],
+            severity=severity,
+            message=message,
+        )
+        for name, severity, message in INTEGRITY_CHECK_DEFS
+    ]
+
+
+def _status_from_issues(*, failures: list[str], warnings: list[str]) -> str:
+    status = "ok"
+    if failures:
+        status = "failed"
+    elif warnings:
+        status = "warning"
+    return status
+
+
+async def collect_integrity_report(db_session: AsyncSession) -> dict[str, Any]:
+    counts = await _collect_counts(db_session)
+    checks = _build_checks(counts=counts)
+    failures = _issues_for_severity(checks=checks, severity="failure")
+    warnings = _issues_for_severity(checks=checks, severity="warning")
+
+    return {
+        "status": _status_from_issues(failures=failures, warnings=warnings),
+        "checked_at": datetime.now(timezone.utc).isoformat(),
+        "failures": failures,
+        "warnings": warnings,
+        "checks": checks,
+    }
diff --git a/build/lib/app/services/domains/dbops/query.py b/build/lib/app/services/domains/dbops/query.py
new file mode 100644
index 0000000..2e95e31
--- /dev/null
+++ b/build/lib/app/services/domains/dbops/query.py
@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import DataRepairJob
+
+
+def _bounded_limit(limit: int) -> int:
+    return max(1, min(int(limit), 200))
+
+
+async def list_repair_jobs(
+    db_session: AsyncSession,
+    *,
+    limit: int = 50,
+) -> list[DataRepairJob]:
+    bounded = _bounded_limit(limit)
+    result = await db_session.execute(
+        select(DataRepairJob).order_by(DataRepairJob.created_at.desc()).limit(bounded)
+    )
+    return list(result.scalars())
diff --git a/build/lib/app/services/domains/doi/normalize.py b/build/lib/app/services/domains/doi/normalize.py
new file mode 100644
index 0000000..4719cf3
--- /dev/null
+++ b/build/lib/app/services/domains/doi/normalize.py
@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import re
+from urllib.parse import unquote
+
+DOI_RE = re.compile(r"10\.\d{4,9}/[-._;()/:A-Z0-9]+", re.I)
+
+
+def normalize_doi(value: str | None) -> str | None:
+    if not value:
+        return None
+    match = DOI_RE.search(unquote(value))
+    if not match:
+        return None
+    return match.group(0).rstrip(" .;,)").lower()
+
+
+def first_doi_from_texts(*values: str | None) -> str | None:
+    for value in values:
+        doi = normalize_doi(value)
+        if doi:
+            return doi
+    return None
diff --git a/build/lib/app/services/domains/ingestion/__init__.py b/build/lib/app/services/domains/ingestion/__init__.py
new file mode 100644
index 0000000..9d48db4
--- /dev/null
+++ b/build/lib/app/services/domains/ingestion/__init__.py
@@ -0,0 +1 @@
+from __future__ import annotations
diff --git a/build/lib/app/services/domains/ingestion/application.py b/build/lib/app/services/domains/ingestion/application.py
new file mode 100644
index 0000000..63656b4
--- /dev/null
+++ b/build/lib/app/services/domains/ingestion/application.py
@@ -0,0 +1,2413 @@
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime, timezone
+import hashlib
+import logging
+from typing import Any
+
+from sqlalchemy import select, text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import (
+    CrawlRun,
+    Publication,
+    RunStatus,
+    RunTriggerType,
+    ScholarProfile,
+    ScholarPublication,
+)
+from app.services.domains.ingestion.constants import (
+    FAILED_STATES,
+    FAILURE_BUCKET_BLOCKED,
+    FAILURE_BUCKET_INGESTION,
+    FAILURE_BUCKET_LAYOUT,
+    FAILURE_BUCKET_NETWORK,
+    FAILURE_BUCKET_OTHER,
+    RESUMABLE_PARTIAL_REASON_PREFIXES,
+    RESUMABLE_PARTIAL_REASONS,
+    RUN_LOCK_NAMESPACE,
+)
+from app.services.domains.doi.normalize import first_doi_from_texts
+from app.services.domains.publication_identifiers import application as identifier_service
+from app.services.domains.ingestion.fingerprints import (
+    _build_body_excerpt,
+    _dedupe_publication_candidates,
+    _next_cstart_value,
+    build_initial_page_fingerprint,
+    build_publication_fingerprint,
+    build_publication_url,
+    normalize_title,
+)
+from app.services.domains.ingestion import queue as queue_service
+from app.services.domains.ingestion import safety as run_safety_service
+from app.services.domains.ingestion.types import (
+    PagedLoopState,
+    PagedParseResult,
+    RunAlertSummary,
+    RunAlreadyInProgressError,
+    RunBlockedBySafetyPolicyError,
+    RunExecutionSummary,
+    RunFailureSummary,
+    RunProgress,
+    ScholarProcessingOutcome,
+)
+from app.services.domains.settings import application as user_settings_service
+from app.services.domains.runs.events import run_events
+from app.services.domains.scholar.parser import (
+    ParseState,
+    ParsedProfilePage,
+    PublicationCandidate,
+    ScholarParserError,
+    parse_profile_page,
+)
+from app.services.domains.scholar.source import FetchResult, ScholarSource
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+def _int_or_default(value: Any, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _classify_failure_bucket(*, state: str, state_reason: str) -> str:
+    reason = state_reason.strip().lower()
+    normalized_state = state.strip().lower()
+
+    if normalized_state == ParseState.BLOCKED_OR_CAPTCHA.value or reason.startswith("blocked_"):
+        return FAILURE_BUCKET_BLOCKED
+    if normalized_state == ParseState.NETWORK_ERROR.value or reason.startswith("network_"):
+        return FAILURE_BUCKET_NETWORK
+    if normalized_state == ParseState.LAYOUT_CHANGED.value:
+        return FAILURE_BUCKET_LAYOUT
+    if normalized_state == "ingestion_error":
+        return FAILURE_BUCKET_INGESTION
+    return FAILURE_BUCKET_OTHER
+
+
+class ScholarIngestionService:
+    def __init__(self, *, source: ScholarSource) -> None:
+        self._source = source
+
+    @staticmethod
+    def _effective_request_delay_seconds(value: int) -> int:
+        policy_minimum = user_settings_service.resolve_request_delay_minimum(
+            settings.ingestion_min_request_delay_seconds
+        )
+        return max(policy_minimum, _int_or_default(value, policy_minimum))
+
+    @staticmethod
+    def _log_request_delay_coercion(
+        *,
+        user_id: int,
+        requested_request_delay_seconds: int,
+        effective_request_delay_seconds: int,
+    ) -> None:
+        logger.warning(
+            "ingestion.request_delay_coerced_to_policy_floor",
+            extra={
+                "event": "ingestion.request_delay_coerced_to_policy_floor",
+                "user_id": user_id,
+                "requested_request_delay_seconds": requested_request_delay_seconds,
+                "effective_request_delay_seconds": effective_request_delay_seconds,
+                "policy_minimum_request_delay_seconds": user_settings_service.resolve_request_delay_minimum(
+                    settings.ingestion_min_request_delay_seconds
+                ),
+                "metric_name": "ingestion_request_delay_coerced_total",
+                "metric_value": 1,
+            },
+        )
+
+    async def _load_user_settings_for_run(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_id: int,
+        trigger_type: RunTriggerType,
+    ):
+        user_settings = await user_settings_service.get_or_create_settings(
+            db_session,
+            user_id=user_id,
+        )
+        await self._enforce_safety_gate(
+            db_session,
+            user_settings=user_settings,
+            user_id=user_id,
+            trigger_type=trigger_type,
+        )
+        return user_settings
+
+    async def _enforce_safety_gate(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_settings,
+        user_id: int,
+        trigger_type: RunTriggerType,
+    ) -> None:
+        now_utc = datetime.now(timezone.utc)
+        previous = run_safety_service.get_safety_event_context(user_settings, now_utc=now_utc)
+        if run_safety_service.clear_expired_cooldown(user_settings, now_utc=now_utc):
+            await db_session.commit()
+            await db_session.refresh(user_settings)
+            logger.info(
+                "ingestion.safety_cooldown_cleared",
+                extra={
+                    "event": "ingestion.safety_cooldown_cleared",
+                    "user_id": user_id,
+                    "reason": previous.get("cooldown_reason"),
+                    "cooldown_until": previous.get("cooldown_until"),
+                    "metric_name": "ingestion_safety_cooldown_cleared_total",
+                    "metric_value": 1,
+                },
+            )
+            now_utc = datetime.now(timezone.utc)
+        if run_safety_service.is_cooldown_active(user_settings, now_utc=now_utc):
+            await self._raise_safety_blocked_start(
+                db_session,
+                user_settings=user_settings,
+                user_id=user_id,
+                trigger_type=trigger_type,
+                now_utc=now_utc,
+            )
+
+    async def _raise_safety_blocked_start(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_settings,
+        user_id: int,
+        trigger_type: RunTriggerType,
+        now_utc: datetime,
+    ) -> None:
+        safety_state = run_safety_service.register_cooldown_blocked_start(
+            user_settings,
+            now_utc=now_utc,
+        )
+        await db_session.commit()
+        logger.warning(
+            "ingestion.safety_policy_blocked_run_start",
+            extra={
+                "event": "ingestion.safety_policy_blocked_run_start",
+                "user_id": user_id,
+                "trigger_type": trigger_type.value,
+                "reason": safety_state.get("cooldown_reason"),
+                "cooldown_until": safety_state.get("cooldown_until"),
+                "cooldown_remaining_seconds": safety_state.get("cooldown_remaining_seconds"),
+                "blocked_start_count": ((safety_state.get("counters") or {}).get("blocked_start_count")),
+                "metric_name": "ingestion_safety_run_start_blocked_total",
+                "metric_value": 1,
+            },
+        )
+        raise RunBlockedBySafetyPolicyError(
+            code="scrape_cooldown_active",
+            message="Scrape safety cooldown is active; run start is temporarily blocked.",
+            safety_state=safety_state,
+        )
+
+    @staticmethod
+    def _normalize_run_targets(
+        *,
+        scholar_profile_ids: set[int] | None,
+        start_cstart_by_scholar_id: dict[int, int] | None,
+    ) -> tuple[set[int] | None, dict[int, int]]:
+        filtered_scholar_ids = (
+            {int(value) for value in scholar_profile_ids}
+            if scholar_profile_ids is not None
+            else None
+        )
+        start_cstart_map = {
+            int(key): max(0, int(value))
+            for key, value in (start_cstart_by_scholar_id or {}).items()
+        }
+        return filtered_scholar_ids, start_cstart_map
+
+    async def _load_target_scholars(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_id: int,
+        filtered_scholar_ids: set[int] | None,
+    ) -> list[ScholarProfile]:
+        scholars_stmt = (
+            select(ScholarProfile)
+            .where(ScholarProfile.user_id == user_id, ScholarProfile.is_enabled.is_(True))
+            .order_by(ScholarProfile.created_at.asc(), ScholarProfile.id.asc())
+        )
+        if filtered_scholar_ids is not None:
+            scholars_stmt = scholars_stmt.where(ScholarProfile.id.in_(filtered_scholar_ids))
+        scholars_result = await db_session.execute(scholars_stmt)
+        scholars = list(scholars_result.scalars().all())
+        await self._clear_missing_filtered_jobs(
+            db_session,
+            user_id=user_id,
+            filtered_scholar_ids=filtered_scholar_ids,
+            scholars=scholars,
+        )
+        return scholars
+
+    async def _clear_missing_filtered_jobs(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_id: int,
+        filtered_scholar_ids: set[int] | None,
+        scholars: list[ScholarProfile],
+    ) -> None:
+        if filtered_scholar_ids is None:
+            return
+        found_ids = {int(scholar.id) for scholar in scholars}
+        missing_ids = filtered_scholar_ids - found_ids
+        for scholar_profile_id in missing_ids:
+            await queue_service.clear_job_for_scholar(
+                db_session,
+                user_id=user_id,
+                scholar_profile_id=scholar_profile_id,
+            )
+
+    @staticmethod
+    def _create_running_run(
+        *,
+        user_id: int,
+        trigger_type: RunTriggerType,
+        scholar_count: int,
+        idempotency_key: str | None,
+    ) -> CrawlRun:
+        return CrawlRun(
+            user_id=user_id,
+            trigger_type=trigger_type,
+            status=RunStatus.RUNNING,
+            scholar_count=scholar_count,
+            new_pub_count=0,
+            idempotency_key=idempotency_key,
+            error_log={},
+        )
+
+    @staticmethod
+    def _log_run_started(
+        *,
+        user_id: int,
+        trigger_type: RunTriggerType,
+        scholar_count: int,
+        filtered: bool,
+        request_delay_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        max_pages_per_scholar: int,
+        page_size: int,
+        idempotency_key: str | None,
+        alert_blocked_failure_threshold: int,
+        alert_network_failure_threshold: int,
+        alert_retry_scheduled_threshold: int,
+    ) -> None:
+        logger.info(
+            "ingestion.run_started",
+            extra={
+                "event": "ingestion.run_started",
+                "user_id": user_id,
+                "trigger_type": trigger_type.value,
+                "scholar_count": scholar_count,
+                "is_filtered_run": filtered,
+                "request_delay_seconds": request_delay_seconds,
+                "network_error_retries": network_error_retries,
+                "retry_backoff_seconds": retry_backoff_seconds,
+                "max_pages_per_scholar": max_pages_per_scholar,
+                "page_size": page_size,
+                "idempotency_key": idempotency_key,
+                "alert_blocked_failure_threshold": alert_blocked_failure_threshold,
+                "alert_network_failure_threshold": alert_network_failure_threshold,
+                "alert_retry_scheduled_threshold": alert_retry_scheduled_threshold,
+            },
+        )
+
+    @staticmethod
+    async def _wait_between_scholars(*, index: int, request_delay_seconds: int) -> None:
+        if index <= 0 or request_delay_seconds <= 0:
+            return
+        await asyncio.sleep(float(request_delay_seconds))
+
+    @staticmethod
+    def _assert_valid_paged_parse_result(
+        *,
+        scholar_id: str,
+        paged_parse_result: PagedParseResult,
+    ) -> None:
+        parsed_page = paged_parse_result.parsed_page
+        if parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS}:
+            if any(code.startswith("layout_") for code in parsed_page.warnings):
+                raise RuntimeError(f"Layout warning marked as terminal for scholar_id={scholar_id}.")
+        for publication in paged_parse_result.publications:
+            if not publication.title.strip():
+                raise RuntimeError(f"Malformed publication title for scholar_id={scholar_id}.")
+            if publication.citation_count is not None and int(publication.citation_count) < 0:
+                raise RuntimeError(f"Negative citation count for scholar_id={scholar_id}.")
+
+    @staticmethod
+    def _apply_first_page_profile_metadata(
+        *,
+        scholar: ScholarProfile,
+        paged_parse_result: PagedParseResult,
+        run_dt: datetime,
+    ) -> None:
+        first_page = paged_parse_result.first_page_parsed_page
+        if first_page.profile_name and not (scholar.display_name or "").strip():
+            scholar.display_name = first_page.profile_name
+        if first_page.profile_image_url:
+            scholar.profile_image_url = first_page.profile_image_url
+        scholar.last_initial_page_checked_at = run_dt
+
+    @staticmethod
+    def _log_scholar_parsed(
+        *,
+        user_id: int,
+        run_id: int,
+        scholar: ScholarProfile,
+        paged_parse_result: PagedParseResult,
+    ) -> None:
+        parsed_page = paged_parse_result.parsed_page
+        logger.info(
+            "ingestion.scholar_parsed",
+            extra={
+                "event": "ingestion.scholar_parsed",
+                "user_id": user_id,
+                "crawl_run_id": run_id,
+                "scholar_profile_id": scholar.id,
+                "scholar_id": scholar.scholar_id,
+                "state": parsed_page.state.value,
+                "publication_count": len(paged_parse_result.publications),
+                "has_show_more_button": parsed_page.has_show_more_button,
+                "pages_fetched": paged_parse_result.pages_fetched,
+                "pages_attempted": paged_parse_result.pages_attempted,
+                "has_more_remaining": paged_parse_result.has_more_remaining,
+                "pagination_truncated_reason": paged_parse_result.pagination_truncated_reason,
+                "warning_count": len(parsed_page.warnings),
+                "skipped_no_change": paged_parse_result.skipped_no_change,
+            },
+        )
+
+    @staticmethod
+    def _build_result_entry(
+        *,
+        scholar: ScholarProfile,
+        start_cstart: int,
+        paged_parse_result: PagedParseResult,
+    ) -> dict[str, Any]:
+        parsed_page = paged_parse_result.parsed_page
+        return {
+            "scholar_profile_id": scholar.id,
+            "scholar_id": scholar.scholar_id,
+            "state": parsed_page.state.value,
+            "state_reason": parsed_page.state_reason,
+            "outcome": "failed",
+            "attempt_count": len(paged_parse_result.attempt_log),
+            "publication_count": len(paged_parse_result.publications),
+            "start_cstart": start_cstart,
+            "articles_range": parsed_page.articles_range,
+            "warnings": parsed_page.warnings,
+            "has_show_more_button": parsed_page.has_show_more_button,
+            "pages_fetched": paged_parse_result.pages_fetched,
+            "pages_attempted": paged_parse_result.pages_attempted,
+            "has_more_remaining": paged_parse_result.has_more_remaining,
+            "pagination_truncated_reason": paged_parse_result.pagination_truncated_reason,
+            "continuation_cstart": paged_parse_result.continuation_cstart,
+            "skipped_no_change": paged_parse_result.skipped_no_change,
+            "initial_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
+        }
+
+    def _skipped_no_change_outcome(
+        self,
+        *,
+        scholar: ScholarProfile,
+        run_dt: datetime,
+        paged_parse_result: PagedParseResult,
+        result_entry: dict[str, Any],
+    ) -> ScholarProcessingOutcome:
+        first_page = paged_parse_result.first_page_parsed_page
+        scholar.last_run_status = RunStatus.SUCCESS
+        scholar.last_run_dt = run_dt
+        result_entry["state"] = first_page.state.value
+        result_entry["state_reason"] = "no_change_initial_page_signature"
+        result_entry["outcome"] = "success"
+        result_entry["publication_count"] = 0
+        result_entry["warnings"] = first_page.warnings
+        result_entry["debug"] = {
+            "state_reason": "no_change_initial_page_signature",
+            "first_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
+            "attempt_log": paged_parse_result.attempt_log,
+            "page_logs": paged_parse_result.page_logs,
+        }
+        return ScholarProcessingOutcome(
+            result_entry=result_entry,
+            succeeded_count_delta=1,
+            failed_count_delta=0,
+            partial_count_delta=0,
+            discovered_publication_count=0,
+        )
+
+    async def _upsert_publications_outcome(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        run_dt: datetime,
+        paged_parse_result: PagedParseResult,
+        result_entry: dict[str, Any],
+    ) -> ScholarProcessingOutcome:
+        parsed_page = paged_parse_result.parsed_page
+        publications = paged_parse_result.publications
+        had_page_failure = parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}
+        has_partial_set = len(publications) > 0 and had_page_failure
+        if (not had_page_failure) or has_partial_set:
+            return await self._upsert_success_or_exception(
+                db_session,
+                run=run,
+                scholar=scholar,
+                run_dt=run_dt,
+                paged_parse_result=paged_parse_result,
+                result_entry=result_entry,
+                has_partial_publication_set=has_partial_set,
+            )
+        return self._parse_failure_outcome(
+            scholar=scholar,
+            run_dt=run_dt,
+            paged_parse_result=paged_parse_result,
+            result_entry=result_entry,
+        )
+
+    async def _upsert_success_or_exception(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        run_dt: datetime,
+        paged_parse_result: PagedParseResult,
+        result_entry: dict[str, Any],
+        has_partial_publication_set: bool,
+    ) -> ScholarProcessingOutcome:
+        try:
+            return await self._upsert_success(
+                db_session,
+                run=run,
+                scholar=scholar,
+                run_dt=run_dt,
+                paged_parse_result=paged_parse_result,
+                result_entry=result_entry,
+                has_partial_publication_set=has_partial_publication_set,
+            )
+        except Exception as exc:
+            return self._upsert_exception_outcome(
+                run=run,
+                scholar=scholar,
+                run_dt=run_dt,
+                paged_parse_result=paged_parse_result,
+                result_entry=result_entry,
+                exc=exc,
+            )
+
+    async def _upsert_success(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        run_dt: datetime,
+        paged_parse_result: PagedParseResult,
+        result_entry: dict[str, Any],
+        has_partial_publication_set: bool,
+    ) -> ScholarProcessingOutcome:
+        # We no longer aggregate and upsert the publications here.
+        # Eager DB insertions have already saved and committed them inside `_fetch_and_parse_all_pages_with_retry` and `_paginate_loop`.
+        discovered_count = paged_parse_result.discovered_publication_count
+        is_partial = (
+            paged_parse_result.has_more_remaining
+            or paged_parse_result.pagination_truncated_reason is not None
+            or has_partial_publication_set
+        )
+        scholar.last_run_status = RunStatus.PARTIAL_FAILURE if is_partial else RunStatus.SUCCESS
+        scholar.last_run_dt = run_dt
+        if not is_partial and paged_parse_result.first_page_fingerprint_sha256:
+            scholar.last_initial_page_fingerprint_sha256 = paged_parse_result.first_page_fingerprint_sha256
+        result_entry["outcome"] = "partial" if is_partial else "success"
+        if is_partial:
+            result_entry["debug"] = self._build_failure_debug_context(
+                fetch_result=paged_parse_result.fetch_result,
+                parsed_page=paged_parse_result.parsed_page,
+                attempt_log=paged_parse_result.attempt_log,
+                page_logs=paged_parse_result.page_logs,
+            )
+        return ScholarProcessingOutcome(
+            result_entry=result_entry,
+            succeeded_count_delta=1,
+            failed_count_delta=0,
+            partial_count_delta=1 if is_partial else 0,
+            discovered_publication_count=discovered_count,
+        )
+
+    def _upsert_exception_outcome(
+        self,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        run_dt: datetime,
+        paged_parse_result: PagedParseResult,
+        result_entry: dict[str, Any],
+        exc: Exception,
+    ) -> ScholarProcessingOutcome:
+        scholar.last_run_status = RunStatus.FAILED
+        scholar.last_run_dt = run_dt
+        result_entry["state"] = "ingestion_error"
+        result_entry["state_reason"] = "publication_upsert_exception"
+        result_entry["outcome"] = "failed"
+        result_entry["error"] = str(exc)
+        result_entry["debug"] = self._build_failure_debug_context(
+            fetch_result=paged_parse_result.fetch_result,
+            parsed_page=paged_parse_result.parsed_page,
+            attempt_log=paged_parse_result.attempt_log,
+            page_logs=paged_parse_result.page_logs,
+            exception=exc,
+        )
+        logger.exception(
+            "ingestion.scholar_failed",
+            extra={
+                "event": "ingestion.scholar_failed",
+                "crawl_run_id": run.id,
+                "scholar_profile_id": scholar.id,
+                "scholar_id": scholar.scholar_id,
+            },
+        )
+        return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
+
+    def _parse_failure_outcome(
+        self,
+        *,
+        scholar: ScholarProfile,
+        run_dt: datetime,
+        paged_parse_result: PagedParseResult,
+        result_entry: dict[str, Any],
+    ) -> ScholarProcessingOutcome:
+        scholar.last_run_status = RunStatus.FAILED
+        scholar.last_run_dt = run_dt
+        result_entry["debug"] = self._build_failure_debug_context(
+            fetch_result=paged_parse_result.fetch_result,
+            parsed_page=paged_parse_result.parsed_page,
+            attempt_log=paged_parse_result.attempt_log,
+            page_logs=paged_parse_result.page_logs,
+        )
+        logger.warning(
+            "ingestion.scholar_parse_failed",
+            extra={
+                "event": "ingestion.scholar_parse_failed",
+                "scholar_profile_id": scholar.id,
+                "scholar_id": scholar.scholar_id,
+                "state": paged_parse_result.parsed_page.state.value,
+                "state_reason": paged_parse_result.parsed_page.state_reason,
+                "status_code": paged_parse_result.fetch_result.status_code,
+            },
+        )
+        return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
+
+    async def _sync_continuation_queue(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_id: int,
+        scholar: ScholarProfile,
+        run: CrawlRun,
+        start_cstart: int,
+        result_entry: dict[str, Any],
+        paged_parse_result: PagedParseResult,
+        auto_queue_continuations: bool,
+        queue_delay_seconds: int,
+    ) -> None:
+        queue_reason, queue_cstart = self._resolve_continuation_queue_target(
+            outcome=str(result_entry.get("outcome", "")),
+            state=str(result_entry.get("state", "")),
+            pagination_truncated_reason=paged_parse_result.pagination_truncated_reason,
+            continuation_cstart=paged_parse_result.continuation_cstart,
+            fallback_cstart=start_cstart,
+        )
+        if auto_queue_continuations and queue_reason is not None:
+            await queue_service.upsert_job(
+                db_session,
+                user_id=user_id,
+                scholar_profile_id=scholar.id,
+                resume_cstart=queue_cstart,
+                reason=queue_reason,
+                run_id=run.id,
+                delay_seconds=queue_delay_seconds,
+            )
+            result_entry["continuation_enqueued"] = True
+            result_entry["continuation_reason"] = queue_reason
+            result_entry["continuation_cstart"] = queue_cstart
+            return
+        if await queue_service.clear_job_for_scholar(db_session, user_id=user_id, scholar_profile_id=scholar.id):
+            result_entry["continuation_cleared"] = True
+
+    async def _process_scholar(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        user_id: int,
+        request_delay_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+        max_pages_per_scholar: int,
+        page_size: int,
+        start_cstart: int,
+        auto_queue_continuations: bool,
+        queue_delay_seconds: int,
+    ) -> ScholarProcessingOutcome:
+        try:
+            return await self._process_scholar_inner(
+                db_session,
+                run=run,
+                scholar=scholar,
+                user_id=user_id,
+                request_delay_seconds=request_delay_seconds,
+                network_error_retries=network_error_retries,
+                retry_backoff_seconds=retry_backoff_seconds,
+                rate_limit_retries=rate_limit_retries,
+                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+                max_pages_per_scholar=max_pages_per_scholar,
+                page_size=page_size,
+                start_cstart=start_cstart,
+                auto_queue_continuations=auto_queue_continuations,
+                queue_delay_seconds=queue_delay_seconds,
+            )
+        except Exception as exc:
+            return self._unexpected_scholar_exception_outcome(
+                run=run,
+                scholar=scholar,
+                start_cstart=start_cstart,
+                exc=exc,
+            )
+
+    async def _process_scholar_inner(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        user_id: int,
+        request_delay_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+        max_pages_per_scholar: int,
+        page_size: int,
+        start_cstart: int,
+        auto_queue_continuations: bool,
+        queue_delay_seconds: int,
+    ) -> ScholarProcessingOutcome:
+        run_dt, paged_parse_result, result_entry = await self._fetch_and_prepare_scholar_result(
+            db_session,
+            run=run,
+            scholar=scholar,
+            user_id=user_id,
+            start_cstart=start_cstart,
+            request_delay_seconds=request_delay_seconds,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+            max_pages_per_scholar=max_pages_per_scholar,
+            page_size=page_size,
+        )
+        outcome = await self._resolve_scholar_outcome(
+            db_session,
+            run=run,
+            scholar=scholar,
+            run_dt=run_dt,
+            paged_parse_result=paged_parse_result,
+            result_entry=result_entry,
+        )
+        await self._sync_continuation_queue(
+            db_session,
+            user_id=user_id,
+            scholar=scholar,
+            run=run,
+            start_cstart=start_cstart,
+            result_entry=outcome.result_entry,
+            paged_parse_result=paged_parse_result,
+            auto_queue_continuations=auto_queue_continuations,
+            queue_delay_seconds=queue_delay_seconds,
+        )
+        return outcome
+
+    async def _fetch_and_prepare_scholar_result(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        user_id: int,
+        start_cstart: int,
+        request_delay_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+        max_pages_per_scholar: int,
+        page_size: int,
+    ) -> tuple[datetime, PagedParseResult, dict[str, Any]]:
+        run_dt = datetime.now(timezone.utc)
+        paged_parse_result = await self._fetch_and_parse_all_pages_with_retry(
+            scholar=scholar,
+            run=run,
+            db_session=db_session,
+            start_cstart=start_cstart,
+            request_delay_seconds=request_delay_seconds,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+            max_pages=max_pages_per_scholar,
+            page_size=page_size,
+            previous_initial_page_fingerprint_sha256=scholar.last_initial_page_fingerprint_sha256,
+        )
+        self._assert_valid_paged_parse_result(scholar_id=scholar.scholar_id, paged_parse_result=paged_parse_result)
+        self._apply_first_page_profile_metadata(scholar=scholar, paged_parse_result=paged_parse_result, run_dt=run_dt)
+        self._log_scholar_parsed(user_id=user_id, run_id=run.id, scholar=scholar, paged_parse_result=paged_parse_result)
+        result_entry = self._build_result_entry(
+            scholar=scholar,
+            start_cstart=start_cstart,
+            paged_parse_result=paged_parse_result,
+        )
+        return run_dt, paged_parse_result, result_entry
+
+    async def _resolve_scholar_outcome(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        run_dt: datetime,
+        paged_parse_result: PagedParseResult,
+        result_entry: dict[str, Any],
+    ) -> ScholarProcessingOutcome:
+        if paged_parse_result.skipped_no_change:
+            return self._skipped_no_change_outcome(
+                scholar=scholar,
+                run_dt=run_dt,
+                paged_parse_result=paged_parse_result,
+                result_entry=result_entry,
+            )
+        return await self._upsert_publications_outcome(
+            db_session,
+            run=run,
+            scholar=scholar,
+            run_dt=run_dt,
+            paged_parse_result=paged_parse_result,
+            result_entry=result_entry,
+        )
+
+    @staticmethod
+    def _apply_outcome_to_progress(
+        *,
+        progress: RunProgress,
+        run: CrawlRun,
+        outcome: ScholarProcessingOutcome,
+    ) -> None:
+        progress.succeeded_count += outcome.succeeded_count_delta
+        progress.failed_count += outcome.failed_count_delta
+        progress.partial_count += outcome.partial_count_delta
+        run.new_pub_count = int(run.new_pub_count or 0) + outcome.discovered_publication_count
+        progress.scholar_results.append(outcome.result_entry)
+
+    def _unexpected_scholar_exception_outcome(
+        self,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        start_cstart: int,
+        exc: Exception,
+    ) -> ScholarProcessingOutcome:
+        scholar.last_run_status = RunStatus.FAILED
+        scholar.last_run_dt = datetime.now(timezone.utc)
+        logger.exception(
+            "ingestion.scholar_unexpected_failure",
+            extra={
+                "event": "ingestion.scholar_unexpected_failure",
+                "crawl_run_id": run.id,
+                "scholar_profile_id": scholar.id,
+                "scholar_id": scholar.scholar_id,
+            },
+        )
+        return ScholarProcessingOutcome(
+            result_entry={
+                "scholar_profile_id": scholar.id,
+                "scholar_id": scholar.scholar_id,
+                "state": "ingestion_error",
+                "state_reason": "scholar_processing_exception",
+                "outcome": "failed",
+                "attempt_count": 0,
+                "publication_count": 0,
+                "start_cstart": start_cstart,
+                "warnings": [],
+                "error": str(exc),
+                "debug": {"exception_type": type(exc).__name__, "exception_message": str(exc)},
+            },
+            succeeded_count_delta=0,
+            failed_count_delta=1,
+            partial_count_delta=0,
+            discovered_publication_count=0,
+        )
+
+    @staticmethod
+    def _summarize_failures(
+        *,
+        scholar_results: list[dict[str, Any]],
+    ) -> RunFailureSummary:
+        failed_state_counts: dict[str, int] = {}
+        failed_reason_counts: dict[str, int] = {}
+        scrape_failure_counts: dict[str, int] = {}
+        retries_scheduled_count = 0
+        scholars_with_retries_count = 0
+        retry_exhausted_count = 0
+        for entry in scholar_results:
+            retries_for_entry = max(0, _int_or_default(entry.get("attempt_count"), 0) - 1)
+            if retries_for_entry > 0:
+                retries_scheduled_count += retries_for_entry
+                scholars_with_retries_count += 1
+            if str(entry.get("outcome", "")) != "failed":
+                continue
+            state = str(entry.get("state", "")).strip()
+            if state not in FAILED_STATES:
+                continue
+            failed_state_counts[state] = failed_state_counts.get(state, 0) + 1
+            reason = str(entry.get("state_reason", "")).strip()
+            if reason:
+                failed_reason_counts[reason] = failed_reason_counts.get(reason, 0) + 1
+            bucket = _classify_failure_bucket(state=state, state_reason=reason)
+            scrape_failure_counts[bucket] = scrape_failure_counts.get(bucket, 0) + 1
+            if state == ParseState.NETWORK_ERROR.value and retries_for_entry > 0:
+                retry_exhausted_count += 1
+        return RunFailureSummary(
+            failed_state_counts=failed_state_counts,
+            failed_reason_counts=failed_reason_counts,
+            scrape_failure_counts=scrape_failure_counts,
+            retries_scheduled_count=retries_scheduled_count,
+            scholars_with_retries_count=scholars_with_retries_count,
+            retry_exhausted_count=retry_exhausted_count,
+        )
+
+    @staticmethod
+    def _build_alert_summary(
+        *,
+        failure_summary: RunFailureSummary,
+        alert_blocked_failure_threshold: int,
+        alert_network_failure_threshold: int,
+        alert_retry_scheduled_threshold: int,
+    ) -> RunAlertSummary:
+        blocked_failure_count = int(failure_summary.scrape_failure_counts.get(FAILURE_BUCKET_BLOCKED, 0))
+        network_failure_count = int(failure_summary.scrape_failure_counts.get(FAILURE_BUCKET_NETWORK, 0))
+        blocked_threshold = max(1, int(alert_blocked_failure_threshold))
+        network_threshold = max(1, int(alert_network_failure_threshold))
+        retry_threshold = max(1, int(alert_retry_scheduled_threshold))
+        alert_flags = {
+            "blocked_failure_threshold_exceeded": blocked_failure_count >= blocked_threshold,
+            "network_failure_threshold_exceeded": network_failure_count >= network_threshold,
+            "retry_scheduled_threshold_exceeded": failure_summary.retries_scheduled_count >= retry_threshold,
+        }
+        return RunAlertSummary(
+            blocked_failure_count=blocked_failure_count,
+            network_failure_count=network_failure_count,
+            blocked_failure_threshold=blocked_threshold,
+            network_failure_threshold=network_threshold,
+            retry_scheduled_threshold=retry_threshold,
+            alert_flags=alert_flags,
+        )
+
+    @staticmethod
+    def _log_alert_thresholds(
+        *,
+        user_id: int,
+        run_id: int,
+        failure_summary: RunFailureSummary,
+        alert_summary: RunAlertSummary,
+    ) -> None:
+        if alert_summary.alert_flags["blocked_failure_threshold_exceeded"]:
+            logger.warning(
+                "ingestion.alert_blocked_failure_threshold_exceeded",
+                extra={
+                    "event": "ingestion.alert_blocked_failure_threshold_exceeded",
+                    "user_id": user_id,
+                    "crawl_run_id": run_id,
+                    "blocked_failure_count": alert_summary.blocked_failure_count,
+                    "threshold": alert_summary.blocked_failure_threshold,
+                    "metric_name": "ingestion_blocked_failure_threshold_exceeded_total",
+                    "metric_value": 1,
+                },
+            )
+        if alert_summary.alert_flags["network_failure_threshold_exceeded"]:
+            logger.warning(
+                "ingestion.alert_network_failure_threshold_exceeded",
+                extra={
+                    "event": "ingestion.alert_network_failure_threshold_exceeded",
+                    "user_id": user_id,
+                    "crawl_run_id": run_id,
+                    "network_failure_count": alert_summary.network_failure_count,
+                    "threshold": alert_summary.network_failure_threshold,
+                    "metric_name": "ingestion_network_failure_threshold_exceeded_total",
+                    "metric_value": 1,
+                },
+            )
+        if alert_summary.alert_flags["retry_scheduled_threshold_exceeded"]:
+            logger.warning(
+                "ingestion.alert_retry_scheduled_threshold_exceeded",
+                extra={
+                    "event": "ingestion.alert_retry_scheduled_threshold_exceeded",
+                    "user_id": user_id,
+                    "crawl_run_id": run_id,
+                    "retries_scheduled_count": failure_summary.retries_scheduled_count,
+                    "threshold": alert_summary.retry_scheduled_threshold,
+                    "metric_name": "ingestion_retry_scheduled_threshold_exceeded_total",
+                    "metric_value": 1,
+                },
+            )
+
+    @staticmethod
+    def _apply_safety_outcome(
+        *,
+        user_settings,
+        run: CrawlRun,
+        user_id: int,
+        alert_summary: RunAlertSummary,
+    ) -> None:
+        pre_apply_state = run_safety_service.get_safety_event_context(
+            user_settings,
+            now_utc=datetime.now(timezone.utc),
+        )
+        safety_state, cooldown_trigger_reason = run_safety_service.apply_run_safety_outcome(
+            user_settings,
+            run_id=int(run.id),
+            blocked_failure_count=alert_summary.blocked_failure_count,
+            network_failure_count=alert_summary.network_failure_count,
+            blocked_failure_threshold=alert_summary.blocked_failure_threshold,
+            network_failure_threshold=alert_summary.network_failure_threshold,
+            blocked_cooldown_seconds=settings.ingestion_safety_cooldown_blocked_seconds,
+            network_cooldown_seconds=settings.ingestion_safety_cooldown_network_seconds,
+            now_utc=datetime.now(timezone.utc),
+        )
+        ScholarIngestionService._log_safety_transition(
+            user_id=user_id,
+            run_id=int(run.id),
+            alert_summary=alert_summary,
+            pre_apply_state=pre_apply_state,
+            safety_state=safety_state,
+            cooldown_trigger_reason=cooldown_trigger_reason,
+        )
+
+    @staticmethod
+    def _log_safety_transition(
+        *,
+        user_id: int,
+        run_id: int,
+        alert_summary: RunAlertSummary,
+        pre_apply_state: dict[str, Any],
+        safety_state: dict[str, Any],
+        cooldown_trigger_reason: str | None,
+    ) -> None:
+        if cooldown_trigger_reason is not None:
+            logger.warning(
+                "ingestion.safety_cooldown_entered",
+                extra={
+                    "event": "ingestion.safety_cooldown_entered",
+                    "user_id": user_id,
+                    "crawl_run_id": run_id,
+                    "reason": cooldown_trigger_reason,
+                    "blocked_failure_count": alert_summary.blocked_failure_count,
+                    "network_failure_count": alert_summary.network_failure_count,
+                    "blocked_failure_threshold": alert_summary.blocked_failure_threshold,
+                    "network_failure_threshold": alert_summary.network_failure_threshold,
+                    "cooldown_until": safety_state.get("cooldown_until"),
+                    "cooldown_remaining_seconds": safety_state.get("cooldown_remaining_seconds"),
+                    "safety_counters": safety_state.get("counters", {}),
+                    "metric_name": "ingestion_safety_cooldown_entered_total",
+                    "metric_value": 1,
+                },
+            )
+        elif pre_apply_state.get("cooldown_active") and not safety_state.get("cooldown_active"):
+            logger.info(
+                "ingestion.safety_cooldown_cleared",
+                extra={
+                    "event": "ingestion.safety_cooldown_cleared",
+                    "user_id": user_id,
+                    "crawl_run_id": run_id,
+                    "reason": pre_apply_state.get("cooldown_reason"),
+                    "cooldown_until": pre_apply_state.get("cooldown_until"),
+                    "metric_name": "ingestion_safety_cooldown_cleared_total",
+                    "metric_value": 1,
+                },
+            )
+
+    def _finalize_run_record(
+        self,
+        *,
+        run: CrawlRun,
+        scholars: list[ScholarProfile],
+        progress: RunProgress,
+        failure_summary: RunFailureSummary,
+        alert_summary: RunAlertSummary,
+        idempotency_key: str | None,
+    ) -> None:
+        run.end_dt = datetime.now(timezone.utc)
+        if run.status != RunStatus.CANCELED:
+            run.status = self._resolve_run_status(
+                scholar_count=len(scholars),
+                succeeded_count=progress.succeeded_count,
+                failed_count=progress.failed_count,
+                partial_count=progress.partial_count,
+            )
+        run.error_log = {
+            "scholar_results": progress.scholar_results,
+            "summary": {
+                "succeeded_count": progress.succeeded_count,
+                "failed_count": progress.failed_count,
+                "partial_count": progress.partial_count,
+                "failed_state_counts": failure_summary.failed_state_counts,
+                "failed_reason_counts": failure_summary.failed_reason_counts,
+                "scrape_failure_counts": failure_summary.scrape_failure_counts,
+                "retry_counts": {
+                    "retries_scheduled_count": failure_summary.retries_scheduled_count,
+                    "scholars_with_retries_count": failure_summary.scholars_with_retries_count,
+                    "retry_exhausted_count": failure_summary.retry_exhausted_count,
+                },
+                "alert_thresholds": {
+                    "blocked_failure_threshold": alert_summary.blocked_failure_threshold,
+                    "network_failure_threshold": alert_summary.network_failure_threshold,
+                    "retry_scheduled_threshold": alert_summary.retry_scheduled_threshold,
+                },
+                "alert_flags": alert_summary.alert_flags,
+            },
+            "meta": {"idempotency_key": idempotency_key} if idempotency_key else {},
+        }
+
+    @staticmethod
+    def _log_run_completed(
+        *,
+        user_id: int,
+        run: CrawlRun,
+        scholars: list[ScholarProfile],
+        progress: RunProgress,
+        alert_summary: RunAlertSummary,
+        failure_summary: RunFailureSummary,
+    ) -> None:
+        logger.info(
+            "ingestion.run_completed",
+            extra={
+                "event": "ingestion.run_completed",
+                "user_id": user_id,
+                "crawl_run_id": run.id,
+                "status": run.status.value,
+                "scholar_count": len(scholars),
+                "succeeded_count": progress.succeeded_count,
+                "failed_count": progress.failed_count,
+                "partial_count": progress.partial_count,
+                "new_publication_count": run.new_pub_count,
+                "blocked_failure_count": alert_summary.blocked_failure_count,
+                "network_failure_count": alert_summary.network_failure_count,
+                "retries_scheduled_count": failure_summary.retries_scheduled_count,
+                "alert_flags": alert_summary.alert_flags,
+            },
+        )
+
+    @staticmethod
+    def _paging_kwargs(
+        *,
+        request_delay_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+        max_pages_per_scholar: int,
+        page_size: int,
+    ) -> dict[str, Any]:
+        return {
+            "request_delay_seconds": request_delay_seconds,
+            "network_error_retries": network_error_retries,
+            "retry_backoff_seconds": retry_backoff_seconds,
+            "rate_limit_retries": rate_limit_retries,
+            "rate_limit_backoff_seconds": rate_limit_backoff_seconds,
+            "max_pages_per_scholar": max_pages_per_scholar,
+            "page_size": page_size,
+        }
+
+    @staticmethod
+    def _threshold_kwargs(
+        *,
+        alert_blocked_failure_threshold: int,
+        alert_network_failure_threshold: int,
+        alert_retry_scheduled_threshold: int,
+    ) -> dict[str, Any]:
+        return {
+            "alert_blocked_failure_threshold": alert_blocked_failure_threshold,
+            "alert_network_failure_threshold": alert_network_failure_threshold,
+            "alert_retry_scheduled_threshold": alert_retry_scheduled_threshold,
+        }
+
+    @staticmethod
+    def _run_execution_summary(
+        *,
+        run: CrawlRun,
+        scholars: list[ScholarProfile],
+        progress: RunProgress,
+    ) -> RunExecutionSummary:
+        return RunExecutionSummary(
+            crawl_run_id=run.id,
+            status=run.status,
+            scholar_count=len(scholars),
+            succeeded_count=progress.succeeded_count,
+            failed_count=progress.failed_count,
+            partial_count=progress.partial_count,
+            new_publication_count=run.new_pub_count,
+        )
+
+    async def _initialize_run_for_user(self, db_session: AsyncSession, *, user_id: int, trigger_type: RunTriggerType, scholar_profile_ids: set[int] | None, start_cstart_by_scholar_id: dict[int, int] | None, request_delay_seconds: int, network_error_retries: int, retry_backoff_seconds: float, rate_limit_retries: int, rate_limit_backoff_seconds: float, max_pages_per_scholar: int, page_size: int, idempotency_key: str | None, alert_blocked_failure_threshold: int, alert_network_failure_threshold: int, alert_retry_scheduled_threshold: int) -> tuple[Any, CrawlRun, list[ScholarProfile], dict[int, int]]:
+        user_settings = await self._load_user_settings_for_run(
+            db_session,
+            user_id=user_id,
+            trigger_type=trigger_type,
+        )
+        if not await self._try_acquire_user_lock(db_session, user_id=user_id):
+            raise RunAlreadyInProgressError(f"Run already in progress for user_id={user_id}.")
+        filtered_scholar_ids, start_cstart_map = self._normalize_run_targets(
+            scholar_profile_ids=scholar_profile_ids,
+            start_cstart_by_scholar_id=start_cstart_by_scholar_id,
+        )
+        scholars = await self._load_target_scholars(
+            db_session,
+            user_id=user_id,
+            filtered_scholar_ids=filtered_scholar_ids,
+        )
+        run = await self._start_run_record_for_targets(
+            db_session,
+            user_id=user_id,
+            trigger_type=trigger_type,
+            scholars=scholars,
+            filtered=filtered_scholar_ids is not None,
+            request_delay_seconds=request_delay_seconds,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            max_pages_per_scholar=max_pages_per_scholar,
+            page_size=page_size,
+            idempotency_key=idempotency_key,
+            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
+            alert_network_failure_threshold=alert_network_failure_threshold,
+            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+        )
+        return user_settings, run, scholars, start_cstart_map
+
+    async def _start_run_record_for_targets(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_id: int,
+        trigger_type: RunTriggerType,
+        scholars: list[ScholarProfile],
+        filtered: bool,
+        request_delay_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        max_pages_per_scholar: int,
+        page_size: int,
+        idempotency_key: str | None,
+        alert_blocked_failure_threshold: int,
+        alert_network_failure_threshold: int,
+        alert_retry_scheduled_threshold: int,
+    ) -> CrawlRun:
+        self._log_run_started(
+            user_id=user_id,
+            trigger_type=trigger_type,
+            scholar_count=len(scholars),
+            filtered=filtered,
+            request_delay_seconds=request_delay_seconds,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            max_pages_per_scholar=max_pages_per_scholar,
+            page_size=page_size,
+            idempotency_key=idempotency_key,
+            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
+            alert_network_failure_threshold=alert_network_failure_threshold,
+            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+        )
+        run = self._create_running_run(
+            user_id=user_id,
+            trigger_type=trigger_type,
+            scholar_count=len(scholars),
+            idempotency_key=idempotency_key,
+        )
+        db_session.add(run)
+        await db_session.flush()
+        return run
+
+    async def _run_scholar_iteration(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        scholars: list[ScholarProfile],
+        user_id: int,
+        start_cstart_map: dict[int, int],
+        request_delay_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+        max_pages_per_scholar: int,
+        page_size: int,
+        auto_queue_continuations: bool,
+        queue_delay_seconds: int,
+    ) -> RunProgress:
+        from app.db.models import RunStatus
+
+        progress = RunProgress()
+        for index, scholar in enumerate(scholars):
+            await db_session.refresh(run)
+            if run.status == RunStatus.CANCELED:
+                logger.info(
+                    "ingestion.run_canceled",
+                    extra={"event": "ingestion.run_canceled", "run_id": run.id, "user_id": user_id},
+                )
+                break
+            await self._wait_between_scholars(index=index, request_delay_seconds=request_delay_seconds)
+            start_cstart = int(start_cstart_map.get(int(scholar.id), 0))
+            outcome = await self._process_scholar(
+                db_session,
+                run=run,
+                scholar=scholar,
+                user_id=user_id,
+                request_delay_seconds=request_delay_seconds,
+                network_error_retries=network_error_retries,
+                retry_backoff_seconds=retry_backoff_seconds,
+                rate_limit_retries=rate_limit_retries,
+                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+                max_pages_per_scholar=max_pages_per_scholar,
+                page_size=page_size,
+                start_cstart=start_cstart,
+                auto_queue_continuations=auto_queue_continuations,
+                queue_delay_seconds=queue_delay_seconds,
+            )
+            self._apply_outcome_to_progress(progress=progress, run=run, outcome=outcome)
+        return progress
+
+    def _complete_run_for_user(
+        self,
+        *,
+        user_settings: Any,
+        run: CrawlRun,
+        scholars: list[ScholarProfile],
+        user_id: int,
+        progress: RunProgress,
+        idempotency_key: str | None,
+        alert_blocked_failure_threshold: int,
+        alert_network_failure_threshold: int,
+        alert_retry_scheduled_threshold: int,
+    ) -> tuple[RunFailureSummary, RunAlertSummary]:
+        failure_summary = self._summarize_failures(scholar_results=progress.scholar_results)
+        alert_summary = self._build_alert_summary(
+            failure_summary=failure_summary,
+            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
+            alert_network_failure_threshold=alert_network_failure_threshold,
+            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+        )
+        self._log_alert_thresholds(
+            user_id=user_id,
+            run_id=int(run.id),
+            failure_summary=failure_summary,
+            alert_summary=alert_summary,
+        )
+        self._apply_safety_outcome(user_settings=user_settings, run=run, user_id=user_id, alert_summary=alert_summary)
+        self._finalize_run_record(
+            run=run,
+            scholars=scholars,
+            progress=progress,
+            failure_summary=failure_summary,
+            alert_summary=alert_summary,
+            idempotency_key=idempotency_key,
+        )
+        return failure_summary, alert_summary
+
+    async def run_for_user(self, db_session: AsyncSession, *, user_id: int, trigger_type: RunTriggerType, request_delay_seconds: int, network_error_retries: int = 1, retry_backoff_seconds: float = 1.0, max_pages_per_scholar: int = 30, page_size: int = 100, scholar_profile_ids: set[int] | None = None, start_cstart_by_scholar_id: dict[int, int] | None = None, auto_queue_continuations: bool = True, queue_delay_seconds: int = 60, idempotency_key: str | None = None, alert_blocked_failure_threshold: int = 1, alert_network_failure_threshold: int = 2, alert_retry_scheduled_threshold: int = 3) -> RunExecutionSummary:
+        effective_request_delay_seconds = self._effective_request_delay_seconds(request_delay_seconds)
+        if effective_request_delay_seconds != _int_or_default(request_delay_seconds, effective_request_delay_seconds):
+            self._log_request_delay_coercion(
+                user_id=user_id,
+                requested_request_delay_seconds=_int_or_default(request_delay_seconds, 0),
+                effective_request_delay_seconds=effective_request_delay_seconds,
+            )
+        paging_kwargs = self._paging_kwargs(request_delay_seconds=effective_request_delay_seconds, network_error_retries=network_error_retries, retry_backoff_seconds=retry_backoff_seconds, rate_limit_retries=settings.ingestion_rate_limit_retries, rate_limit_backoff_seconds=settings.ingestion_rate_limit_backoff_seconds, max_pages_per_scholar=max_pages_per_scholar, page_size=page_size)
+        threshold_kwargs = self._threshold_kwargs(alert_blocked_failure_threshold=alert_blocked_failure_threshold, alert_network_failure_threshold=alert_network_failure_threshold, alert_retry_scheduled_threshold=alert_retry_scheduled_threshold)
+        user_settings, run, scholars, start_cstart_map = await self._initialize_run_for_user(
+            db_session,
+            user_id=user_id,
+            trigger_type=trigger_type,
+            scholar_profile_ids=scholar_profile_ids,
+            start_cstart_by_scholar_id=start_cstart_by_scholar_id,
+            idempotency_key=idempotency_key,
+            **paging_kwargs,
+            **threshold_kwargs,
+        )
+        progress = await self._run_scholar_iteration(
+            db_session,
+            run=run,
+            scholars=scholars,
+            user_id=user_id,
+            start_cstart_map=start_cstart_map,
+            auto_queue_continuations=auto_queue_continuations,
+            queue_delay_seconds=queue_delay_seconds,
+            **paging_kwargs,
+        )
+        failure_summary, alert_summary = self._complete_run_for_user(
+            user_settings=user_settings,
+            run=run,
+            scholars=scholars,
+            user_id=user_id,
+            progress=progress,
+            idempotency_key=idempotency_key,
+            **threshold_kwargs,
+        )
+        await db_session.commit()
+        self._log_run_completed(user_id=user_id, run=run, scholars=scholars, progress=progress, alert_summary=alert_summary, failure_summary=failure_summary)
+        return self._run_execution_summary(run=run, scholars=scholars, progress=progress)
+
+    async def _fetch_profile_page(
+        self,
+        *,
+        scholar_id: str,
+        cstart: int,
+        page_size: int,
+    ) -> FetchResult:
+        try:
+            page_fetcher = getattr(self._source, "fetch_profile_page_html", None)
+            if callable(page_fetcher):
+                return await page_fetcher(
+                    scholar_id,
+                    cstart=cstart,
+                    pagesize=page_size,
+                )
+            if cstart <= 0:
+                return await self._source.fetch_profile_html(scholar_id)
+            return FetchResult(
+                requested_url=(
+                    "https://scholar.google.com/citations"
+                    f"?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
+                ),
+                status_code=None,
+                final_url=None,
+                body="",
+                error="source_does_not_support_pagination",
+            )
+        except Exception as exc:
+            logger.exception(
+                "ingestion.fetch_unexpected_error",
+                extra={
+                    "event": "ingestion.fetch_unexpected_error",
+                    "scholar_id": scholar_id,
+                    "cstart": cstart,
+                    "page_size": page_size,
+                },
+            )
+            return FetchResult(
+                requested_url=(
+                    "https://scholar.google.com/citations"
+                    f"?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
+                ),
+                status_code=None,
+                final_url=None,
+                body="",
+                error=str(exc),
+            )
+
+    @staticmethod
+    def _attempt_log_entry(
+        *,
+        attempt: int,
+        cstart: int,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+    ) -> dict[str, Any]:
+        return {
+            "attempt": attempt,
+            "cstart": cstart,
+            "state": parsed_page.state.value,
+            "state_reason": parsed_page.state_reason,
+            "status_code": fetch_result.status_code,
+            "fetch_error": fetch_result.error,
+        }
+
+    @staticmethod
+    def _should_retry_page_fetch(
+        *,
+        parsed_page: ParsedProfilePage,
+        network_attempt_count: int,
+        rate_limit_attempt_count: int,
+        network_error_retries: int,
+        rate_limit_retries: int,
+    ) -> bool:
+        if parsed_page.state == ParseState.NETWORK_ERROR:
+            return network_attempt_count <= network_error_retries
+        if parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA and parsed_page.state_reason == "blocked_http_429_rate_limited":
+            return rate_limit_attempt_count <= rate_limit_retries
+        return False
+
+    @staticmethod
+    async def _sleep_retry_backoff(
+        *,
+        scholar_id: str,
+        cstart: int,
+        network_attempt_count: int,
+        rate_limit_attempt_count: int,
+        retry_backoff_seconds: float,
+        rate_limit_backoff_seconds: float,
+        state_reason: str,
+    ) -> None:
+        if state_reason == "blocked_http_429_rate_limited":
+            sleep_seconds = rate_limit_backoff_seconds * rate_limit_attempt_count
+            attempt_label = rate_limit_attempt_count
+        else:
+            sleep_seconds = retry_backoff_seconds * (2 ** (network_attempt_count - 1))
+            attempt_label = network_attempt_count
+
+        logger.warning(
+            "ingestion.scholar_retry_scheduled",
+            extra={
+                "event": "ingestion.scholar_retry_scheduled",
+                "scholar_id": scholar_id,
+                "cstart": cstart,
+                "attempt_count": attempt_label,
+                "sleep_seconds": sleep_seconds,
+                "state_reason": state_reason,
+            },
+        )
+        if sleep_seconds > 0:
+            await asyncio.sleep(sleep_seconds)
+
+    async def _fetch_and_parse_page_with_retry(
+        self,
+        *,
+        scholar_id: str,
+        cstart: int,
+        page_size: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+    ) -> tuple[FetchResult, ParsedProfilePage, list[dict[str, Any]]]:
+        network_attempts = 0
+        rate_limit_attempts = 0
+        attempt_log: list[dict[str, Any]] = []
+        fetch_result: FetchResult | None = None
+        parsed_page: ParsedProfilePage | None = None
+
+        while True:
+            fetch_result = await self._fetch_profile_page(
+                scholar_id=scholar_id,
+                cstart=cstart,
+                page_size=page_size,
+            )
+            parsed_page = self._parse_profile_page_or_layout_error(fetch_result=fetch_result)
+            
+            if parsed_page.state == ParseState.NETWORK_ERROR:
+                network_attempts += 1
+                total_attempts = network_attempts
+            elif parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA and parsed_page.state_reason == "blocked_http_429_rate_limited":
+                rate_limit_attempts += 1
+                total_attempts = rate_limit_attempts
+            else:
+                total_attempts = network_attempts + rate_limit_attempts + 1
+
+            attempt_log.append(
+                self._attempt_log_entry(
+                    attempt=total_attempts,
+                    cstart=cstart,
+                    fetch_result=fetch_result,
+                    parsed_page=parsed_page,
+                )
+            )
+
+            if not self._should_retry_page_fetch(
+                parsed_page=parsed_page,
+                network_attempt_count=network_attempts,
+                rate_limit_attempt_count=rate_limit_attempts,
+                network_error_retries=network_error_retries,
+                rate_limit_retries=rate_limit_retries,
+            ):
+                break
+
+            await self._sleep_retry_backoff(
+                scholar_id=scholar_id,
+                cstart=cstart,
+                network_attempt_count=network_attempts,
+                rate_limit_attempt_count=rate_limit_attempts,
+                retry_backoff_seconds=max(float(retry_backoff_seconds), 0.0),
+                rate_limit_backoff_seconds=max(float(rate_limit_backoff_seconds), 0.0),
+                state_reason=parsed_page.state_reason,
+            )
+
+        if fetch_result is None or parsed_page is None:
+            raise RuntimeError("Fetch-and-parse retry loop produced no result.")
+        return fetch_result, parsed_page, attempt_log
+
+    def _parse_profile_page_or_layout_error(
+        self,
+        *,
+        fetch_result: FetchResult,
+    ) -> ParsedProfilePage:
+        try:
+            return parse_profile_page(fetch_result)
+        except ScholarParserError as exc:
+            return self._parsed_page_from_parser_error(
+                fetch_result=fetch_result,
+                code=exc.code,
+            )
+
+    @staticmethod
+    def _parsed_page_from_parser_error(
+        *,
+        fetch_result: FetchResult,
+        code: str,
+    ) -> ParsedProfilePage:
+        return ParsedProfilePage(
+            state=ParseState.LAYOUT_CHANGED,
+            state_reason=code,
+            profile_name=None,
+            profile_image_url=None,
+            publications=[],
+            marker_counts={},
+            warnings=[code],
+            has_show_more_button=False,
+            has_operation_error_banner=False,
+            articles_range=None,
+        )
+
+    @staticmethod
+    def _page_log_entry(
+        *,
+        page_number: int,
+        cstart: int,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        attempt_count: int,
+    ) -> dict[str, Any]:
+        return {
+            "page": page_number,
+            "cstart": cstart,
+            "state": parsed_page.state.value,
+            "state_reason": parsed_page.state_reason,
+            "status_code": fetch_result.status_code,
+            "publication_count": len(parsed_page.publications),
+            "articles_range": parsed_page.articles_range,
+            "has_show_more_button": parsed_page.has_show_more_button,
+            "warning_codes": parsed_page.warnings,
+            "attempt_count": attempt_count,
+        }
+
+    @staticmethod
+    def _should_skip_no_change(
+        *,
+        start_cstart: int,
+        first_page_fingerprint_sha256: str | None,
+        previous_initial_page_fingerprint_sha256: str | None,
+        parsed_page: ParsedProfilePage,
+    ) -> bool:
+        return (
+            start_cstart <= 0
+            and first_page_fingerprint_sha256 is not None
+            and previous_initial_page_fingerprint_sha256 is not None
+            and first_page_fingerprint_sha256 == previous_initial_page_fingerprint_sha256
+            and parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS}
+        )
+
+    @staticmethod
+    def _skip_no_change_result(
+        *,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        first_page_fingerprint_sha256: str | None,
+        attempt_log: list[dict[str, Any]],
+        page_logs: list[dict[str, Any]],
+    ) -> PagedParseResult:
+        return PagedParseResult(
+            fetch_result=fetch_result,
+            parsed_page=parsed_page,
+            first_page_fetch_result=fetch_result,
+            first_page_parsed_page=parsed_page,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+            publications=[],
+            attempt_log=attempt_log,
+            page_logs=page_logs,
+            pages_fetched=1,
+            pages_attempted=1,
+            has_more_remaining=False,
+            pagination_truncated_reason=None,
+            continuation_cstart=None,
+            skipped_no_change=True,
+            discovered_publication_count=0,
+        )
+
+    @staticmethod
+    def _initial_failure_result(
+        *,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        first_page_fingerprint_sha256: str | None,
+        start_cstart: int,
+        attempt_log: list[dict[str, Any]],
+        page_logs: list[dict[str, Any]],
+    ) -> PagedParseResult:
+        continuation_cstart = start_cstart if parsed_page.state == ParseState.NETWORK_ERROR else None
+        return PagedParseResult(
+            fetch_result=fetch_result,
+            parsed_page=parsed_page,
+            first_page_fetch_result=fetch_result,
+            first_page_parsed_page=parsed_page,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+            publications=[],
+            attempt_log=attempt_log,
+            page_logs=page_logs,
+            pages_fetched=0,
+            pages_attempted=1,
+            has_more_remaining=False,
+            pagination_truncated_reason=None,
+            continuation_cstart=continuation_cstart,
+            skipped_no_change=False,
+            discovered_publication_count=0,
+        )
+
+    @staticmethod
+    def _build_loop_state(
+        *,
+        start_cstart: int,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        attempt_log: list[dict[str, Any]],
+        page_logs: list[dict[str, Any]],
+    ) -> PagedLoopState:
+        next_cstart = _next_cstart_value(
+            articles_range=parsed_page.articles_range,
+            fallback=start_cstart + len(parsed_page.publications),
+        )
+        return PagedLoopState(
+            fetch_result=fetch_result,
+            parsed_page=parsed_page,
+            attempt_log=attempt_log,
+            page_logs=page_logs,
+            publications=list(parsed_page.publications),
+            pages_fetched=1,
+            pages_attempted=1,
+            current_cstart=start_cstart,
+            next_cstart=next_cstart,
+        )
+
+    @staticmethod
+    def _set_truncated_state(
+        *,
+        state: PagedLoopState,
+        reason: str,
+        continuation_cstart: int,
+    ) -> None:
+        state.has_more_remaining = True
+        state.pagination_truncated_reason = reason
+        state.continuation_cstart = continuation_cstart
+
+    def _should_stop_pagination(self, *, state: PagedLoopState, bounded_max_pages: int) -> bool:
+        if state.pages_fetched >= bounded_max_pages:
+            self._set_truncated_state(
+                state=state,
+                reason="max_pages_reached",
+                continuation_cstart=(
+                    state.next_cstart if state.next_cstart > state.current_cstart else state.current_cstart
+                ),
+            )
+            return True
+        if state.next_cstart <= state.current_cstart:
+            self._set_truncated_state(
+                state=state,
+                reason="pagination_cursor_stalled",
+                continuation_cstart=state.current_cstart,
+            )
+            return True
+        return False
+
+    async def _fetch_next_page(
+        self,
+        *,
+        scholar_id: str,
+        state: PagedLoopState,
+        request_delay_seconds: int,
+        bounded_page_size: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+    ) -> tuple[FetchResult, ParsedProfilePage, list[dict[str, Any]]]:
+        if request_delay_seconds > 0:
+            await asyncio.sleep(float(request_delay_seconds))
+        state.current_cstart = state.next_cstart
+        return await self._fetch_and_parse_page_with_retry(
+            scholar_id=scholar_id,
+            cstart=state.current_cstart,
+            page_size=bounded_page_size,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+        )
+
+    @staticmethod
+    def _record_next_page(
+        *,
+        state: PagedLoopState,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        page_attempt_log: list[dict[str, Any]],
+    ) -> None:
+        state.pages_attempted += 1
+        state.attempt_log.extend(page_attempt_log)
+        state.page_logs.append(
+            ScholarIngestionService._page_log_entry(
+                page_number=state.pages_attempted,
+                cstart=state.current_cstart,
+                fetch_result=fetch_result,
+                parsed_page=parsed_page,
+                attempt_count=len(page_attempt_log),
+            )
+        )
+        state.fetch_result = fetch_result
+        state.parsed_page = parsed_page
+
+    @staticmethod
+    def _handle_page_state_transition(*, state: PagedLoopState) -> bool:
+        if state.parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}:
+            ScholarIngestionService._set_truncated_state(
+                state=state,
+                reason=f"page_state_{state.parsed_page.state.value}",
+                continuation_cstart=state.current_cstart,
+            )
+            return True
+        if state.parsed_page.state == ParseState.NO_RESULTS and len(state.parsed_page.publications) == 0:
+            state.pages_fetched += 1
+            return True
+        state.pages_fetched += 1
+        state.publications.extend(state.parsed_page.publications)
+        state.next_cstart = _next_cstart_value(
+            articles_range=state.parsed_page.articles_range,
+            fallback=state.current_cstart + len(state.parsed_page.publications),
+        )
+        return False
+
+    async def _fetch_initial_page_context(
+        self,
+        *,
+        scholar_id: str,
+        start_cstart: int,
+        bounded_page_size: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+    ) -> tuple[FetchResult, ParsedProfilePage, str | None, list[dict[str, Any]], list[dict[str, Any]]]:
+        fetch_result, parsed_page, first_attempt_log = await self._fetch_and_parse_page_with_retry(
+            scholar_id=scholar_id,
+            cstart=start_cstart,
+            page_size=bounded_page_size,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+        )
+        first_page_fingerprint_sha256 = build_initial_page_fingerprint(parsed_page)
+        attempt_log = list(first_attempt_log)
+        page_logs = [
+            self._page_log_entry(
+                page_number=1,
+                cstart=start_cstart,
+                fetch_result=fetch_result,
+                parsed_page=parsed_page,
+                attempt_count=len(first_attempt_log),
+            )
+        ]
+        return fetch_result, parsed_page, first_page_fingerprint_sha256, attempt_log, page_logs
+
+    async def _paginate_loop(
+        self,
+        *,
+        scholar: ScholarProfile,
+        run: CrawlRun,
+        db_session: AsyncSession,
+        state: PagedLoopState,
+        bounded_max_pages: int,
+        request_delay_seconds: int,
+        bounded_page_size: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+    ) -> None:
+        if state.parsed_page.publications:
+            discovered_count = await self._upsert_profile_publications(
+                db_session, run=run, scholar=scholar, publications=list(state.parsed_page.publications)
+            )
+            state.discovered_publication_count += discovered_count
+            await db_session.commit()
+            
+        while state.parsed_page.has_show_more_button:
+            from app.db.models import RunStatus
+            await db_session.refresh(run)
+            if run.status == RunStatus.CANCELED:
+                logger.info(
+                    "ingestion.pagination_canceled",
+                    extra={"event": "ingestion.pagination_canceled", "run_id": run.id},
+                )
+                self._set_truncated_state(
+                    state=state,
+                    reason="run_canceled",
+                    continuation_cstart=state.current_cstart,
+                )
+                return
+
+            if self._should_stop_pagination(state=state, bounded_max_pages=bounded_max_pages):
+                return
+            next_fetch_result, next_parsed_page, next_attempt_log = await self._fetch_next_page(
+                scholar_id=scholar.scholar_id,
+                state=state,
+                request_delay_seconds=request_delay_seconds,
+                bounded_page_size=bounded_page_size,
+                network_error_retries=network_error_retries,
+                retry_backoff_seconds=retry_backoff_seconds,
+                rate_limit_retries=rate_limit_retries,
+                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+            )
+            self._record_next_page(
+                state=state,
+                fetch_result=next_fetch_result,
+                parsed_page=next_parsed_page,
+                page_attempt_log=next_attempt_log,
+            )
+            
+            # Immediately commit the new page's publications to the DB
+            if next_parsed_page.publications:
+                discovered_count = await self._upsert_profile_publications(
+                    db_session, run=run, scholar=scholar, publications=list(next_parsed_page.publications)
+                )
+                state.discovered_publication_count += discovered_count
+                await db_session.commit()
+
+            if self._handle_page_state_transition(state=state):
+                return
+
+    @staticmethod
+    def _result_from_pagination_state(
+        *,
+        state: PagedLoopState,
+        first_page_fetch_result: FetchResult,
+        first_page_parsed_page: ParsedProfilePage,
+        first_page_fingerprint_sha256: str | None,
+    ) -> PagedParseResult:
+        return PagedParseResult(
+            fetch_result=state.fetch_result,
+            parsed_page=state.parsed_page,
+            first_page_fetch_result=first_page_fetch_result,
+            first_page_parsed_page=first_page_parsed_page,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+            publications=_dedupe_publication_candidates(state.publications),
+            attempt_log=state.attempt_log,
+            page_logs=state.page_logs,
+            pages_fetched=state.pages_fetched,
+            pages_attempted=state.pages_attempted,
+            has_more_remaining=state.has_more_remaining,
+            pagination_truncated_reason=state.pagination_truncated_reason,
+            continuation_cstart=state.continuation_cstart,
+            skipped_no_change=False,
+            discovered_publication_count=state.discovered_publication_count,
+        )
+
+    def _short_circuit_initial_page(
+        self,
+        *,
+        start_cstart: int,
+        previous_initial_page_fingerprint_sha256: str | None,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        first_page_fingerprint_sha256: str | None,
+        attempt_log: list[dict[str, Any]],
+        page_logs: list[dict[str, Any]],
+    ) -> PagedParseResult | None:
+        if self._should_skip_no_change(
+            start_cstart=start_cstart,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+            previous_initial_page_fingerprint_sha256=previous_initial_page_fingerprint_sha256,
+            parsed_page=parsed_page,
+        ):
+            return self._skip_no_change_result(
+                fetch_result=fetch_result,
+                parsed_page=parsed_page,
+                first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+                attempt_log=attempt_log,
+                page_logs=page_logs,
+            )
+        if parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}:
+            return self._initial_failure_result(
+                fetch_result=fetch_result,
+                parsed_page=parsed_page,
+                first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+                start_cstart=start_cstart,
+                attempt_log=attempt_log,
+                page_logs=page_logs,
+            )
+        return None
+
+    async def _fetch_and_parse_all_pages_with_retry(
+        self,
+        *,
+        scholar: ScholarProfile,
+        run: CrawlRun,
+        db_session: AsyncSession,
+        start_cstart: int,
+        request_delay_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+        max_pages: int,
+        page_size: int,
+        previous_initial_page_fingerprint_sha256: str | None = None
+    ) -> PagedParseResult:
+        bounded_max_pages = max(1, int(max_pages))
+        bounded_page_size = max(1, int(page_size))
+        fetch_result, parsed_page, first_page_fingerprint_sha256, attempt_log, page_logs = (
+            await self._fetch_initial_page_context(
+            scholar_id=scholar.scholar_id,
+            start_cstart=start_cstart,
+            bounded_page_size=bounded_page_size,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+        ))
+        shortcut_result = self._short_circuit_initial_page(
+            start_cstart=start_cstart,
+            previous_initial_page_fingerprint_sha256=previous_initial_page_fingerprint_sha256,
+            fetch_result=fetch_result,
+            parsed_page=parsed_page,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+            attempt_log=attempt_log,
+            page_logs=page_logs,
+        )
+        if shortcut_result is not None:
+            return shortcut_result
+        state = self._build_loop_state(
+            start_cstart=start_cstart,
+            fetch_result=fetch_result,
+            parsed_page=parsed_page,
+            attempt_log=attempt_log,
+            page_logs=page_logs,
+        )
+        await self._paginate_loop(
+            scholar=scholar,
+            run=run,
+            db_session=db_session,
+            state=state,
+            bounded_max_pages=bounded_max_pages,
+            request_delay_seconds=request_delay_seconds,
+            bounded_page_size=bounded_page_size,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+        )
+        return self._result_from_pagination_state(
+            state=state,
+            first_page_fetch_result=fetch_result,
+            first_page_parsed_page=parsed_page,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+        )
+
+    async def _enrich_publications_with_openalex(
+        self,
+        scholar: ScholarProfile,
+        publications: list[PublicationCandidate],
+    ) -> list[PublicationCandidate]:
+        if not publications:
+            return publications
+
+        from app.services.domains.openalex.client import OpenAlexClient
+        from app.services.domains.openalex.matching import find_best_match
+        
+        client = OpenAlexClient(api_key=settings.openalex_api_key, mailto=settings.crossref_api_mailto)
+        
+        # Batch requests by 25 to stay within URL length limits
+        batch_size = 25
+        enriched: list[PublicationCandidate] = []
+        
+        import re
+        for i in range(0, len(publications), batch_size):
+            batch = publications[i:i + batch_size]
+            
+            titles = []
+            for p in batch:
+                if not p.title:
+                    continue
+                # Strip all non-alphanumeric words to prevent OpenAlex API injection crashes
+                # and minimize punctuation-based duplicate misses.
+                safe_title = re.sub(r"[^\w\s]", " ", p.title)
+                safe_title = " ".join(safe_title.split())
+                if safe_title:
+                    titles.append(safe_title)
+            
+            if not titles:
+                enriched.extend(batch)
+                continue
+            
+            query = "|".join(t for t in titles)
+            try:
+                openalex_works = await client.get_works_by_filter(
+                    {"title.search": query}, limit=batch_size * 3
+                )
+            except Exception as e:
+                logger.warning(
+                    "ingestion.openalex_enrichment_failed",
+                    extra={"error": str(e), "batch_size": len(batch), "scholar_id": scholar.id}
+                )
+                openalex_works = []
+                
+            for p in batch:
+                match = find_best_match(
+                    target_title=p.title,
+                    target_year=p.year,
+                    target_authors=p.authors_text or scholar.name,
+                    candidates=openalex_works
+                )
+                if match:
+                    new_p = PublicationCandidate(
+                        title=p.title,
+                        title_url=p.title_url,
+                        cluster_id=p.cluster_id,
+                        year=match.publication_year or p.year,
+                        citation_count=match.cited_by_count,
+                        authors_text=p.authors_text,
+                        venue_text=p.venue_text,
+                        pdf_url=match.oa_url or p.pdf_url,
+                    )
+                    enriched.append(new_p)
+                else:
+                    enriched.append(p)
+
+        return enriched
+
+    async def _upsert_profile_publications(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        publications: list[PublicationCandidate],
+    ) -> int:
+        publications = await self._enrich_publications_with_openalex(scholar, publications)
+        
+        seen_publication_ids: set[int] = set()
+        discovered_count = 0
+
+        for candidate in publications:
+            publication = await self._resolve_publication(db_session, candidate)
+            if publication.id in seen_publication_ids:
+                continue
+            seen_publication_ids.add(publication.id)
+
+            link_result = await db_session.execute(
+                select(ScholarPublication).where(
+                    ScholarPublication.scholar_profile_id == scholar.id,
+                    ScholarPublication.publication_id == publication.id,
+                )
+            )
+            link = link_result.scalar_one_or_none()
+            if link is not None:
+                continue
+
+            link = ScholarPublication(
+                scholar_profile_id=scholar.id,
+                publication_id=publication.id,
+                is_read=False,
+                first_seen_run_id=run.id,
+            )
+            db_session.add(link)
+            discovered_count += 1
+
+            logger.debug(
+                "ingestion.publication_discovered",
+                extra={
+                    "event": "ingestion.publication_discovered",
+                    "scholar_profile_id": scholar.id,
+                    "publication_id": publication.id,
+                    "crawl_run_id": run.id,
+                },
+            )
+            
+            # Commit immediately to ensure the row becomes visible to the UI immediately
+            await db_session.commit()
+            
+            # Emit Server-Sent Event for live UI progress updates
+            await run_events.publish(
+                run_id=run.id,
+                event_type="publication_discovered",
+                data={
+                    "publication_id": publication.id,
+                    "title": publication.title_raw,
+                    "pub_url": publication.pub_url,
+                    "scholar_profile_id": scholar.id,
+                    "scholar_label": scholar.display_name or scholar.scholar_id,
+                    "first_seen_at": datetime.now(timezone.utc).isoformat(),
+                }
+            )
+
+        if not scholar.baseline_completed:
+            scholar.baseline_completed = True
+
+        return discovered_count
+
+    @staticmethod
+    def _validate_publication_candidate(candidate: PublicationCandidate) -> None:
+        if not candidate.title.strip():
+            raise RuntimeError("Publication candidate is missing title.")
+        if candidate.citation_count is not None and int(candidate.citation_count) < 0:
+            raise RuntimeError("Publication candidate has negative citation_count.")
+
+    async def _find_publication_by_cluster(
+        self,
+        db_session: AsyncSession,
+        *,
+        cluster_id: str | None,
+    ) -> Publication | None:
+        if not cluster_id:
+            return None
+        result = await db_session.execute(
+            select(Publication).where(Publication.cluster_id == cluster_id)
+        )
+        return result.scalar_one_or_none()
+
+    async def _find_publication_by_fingerprint(
+        self,
+        db_session: AsyncSession,
+        *,
+        fingerprint: str,
+    ) -> Publication | None:
+        result = await db_session.execute(
+            select(Publication).where(Publication.fingerprint_sha256 == fingerprint)
+        )
+        return result.scalar_one_or_none()
+
+    @staticmethod
+    def _select_existing_publication(
+        *,
+        cluster_publication: Publication | None,
+        fingerprint_publication: Publication | None,
+    ) -> Publication | None:
+        if cluster_publication is not None:
+            return cluster_publication
+        return fingerprint_publication
+
+    async def _create_publication(
+        self,
+        db_session: AsyncSession,
+        *,
+        candidate: PublicationCandidate,
+        fingerprint: str,
+    ) -> Publication:
+        publication = Publication(
+            cluster_id=candidate.cluster_id,
+            fingerprint_sha256=fingerprint,
+            title_raw=candidate.title,
+            title_normalized=normalize_title(candidate.title),
+            year=candidate.year,
+            citation_count=int(candidate.citation_count or 0),
+            author_text=candidate.authors_text,
+            venue_text=candidate.venue_text,
+            pub_url=build_publication_url(candidate.title_url),
+            pdf_url=None,
+        )
+        db_session.add(publication)
+        await db_session.flush()
+        logger.debug(
+            "ingestion.publication_created",
+            extra={
+                "event": "ingestion.publication_created",
+                "publication_id": publication.id,
+                "cluster_id": publication.cluster_id,
+            },
+        )
+        return publication
+
+    @staticmethod
+    def _update_existing_publication(
+        *,
+        publication: Publication,
+        candidate: PublicationCandidate,
+    ) -> None:
+        if candidate.cluster_id and publication.cluster_id is None:
+            publication.cluster_id = candidate.cluster_id
+        publication.title_raw = candidate.title
+        publication.title_normalized = normalize_title(candidate.title)
+        if candidate.year is not None:
+            publication.year = candidate.year
+        if candidate.citation_count is not None:
+            publication.citation_count = int(candidate.citation_count)
+        if candidate.authors_text:
+            publication.author_text = candidate.authors_text
+        if candidate.venue_text:
+            publication.venue_text = candidate.venue_text
+        if candidate.title_url:
+            publication.pub_url = build_publication_url(candidate.title_url)
+        local_doi = first_doi_from_texts(candidate.title_url, candidate.venue_text, candidate.title)
+
+    async def _resolve_publication(
+        self,
+        db_session: AsyncSession,
+        candidate: PublicationCandidate,
+    ) -> Publication:
+        self._validate_publication_candidate(candidate)
+        fingerprint = build_publication_fingerprint(candidate)
+        cluster_publication = await self._find_publication_by_cluster(
+            db_session,
+            cluster_id=candidate.cluster_id,
+        )
+        fingerprint_publication = await self._find_publication_by_fingerprint(
+            db_session,
+            fingerprint=fingerprint,
+        )
+        publication = self._select_existing_publication(
+            cluster_publication=cluster_publication,
+            fingerprint_publication=fingerprint_publication,
+        )
+        if publication is None:
+            created = await self._create_publication(
+                db_session,
+                candidate=candidate,
+                fingerprint=fingerprint,
+            )
+            await identifier_service.discover_and_sync_identifiers_for_publication(
+                db_session,
+                publication=created,
+                scholar_label=candidate.authors_text or "",
+            )
+            return created
+        self._update_existing_publication(
+            publication=publication,
+            candidate=candidate,
+        )
+        await identifier_service.discover_and_sync_identifiers_for_publication(
+            db_session,
+            publication=publication,
+            scholar_label=candidate.authors_text or "",
+        )
+        return publication
+
+    def _resolve_run_status(
+        self,
+        *,
+        scholar_count: int,
+        succeeded_count: int,
+        failed_count: int,
+        partial_count: int,
+    ) -> RunStatus:
+        if scholar_count == 0:
+            return RunStatus.SUCCESS
+        if failed_count == scholar_count:
+            return RunStatus.FAILED
+        if failed_count > 0 or partial_count > 0:
+            return RunStatus.PARTIAL_FAILURE
+        if succeeded_count > 0:
+            return RunStatus.SUCCESS
+        return RunStatus.FAILED
+
+    def _resolve_continuation_queue_target(
+        self,
+        *,
+        outcome: str,
+        state: str,
+        pagination_truncated_reason: str | None,
+        continuation_cstart: int | None,
+        fallback_cstart: int,
+    ) -> tuple[str | None, int]:
+        if outcome == "partial":
+            reason = (pagination_truncated_reason or "").strip()
+            if reason in RESUMABLE_PARTIAL_REASONS or reason.startswith(
+                RESUMABLE_PARTIAL_REASON_PREFIXES
+            ):
+                return reason, queue_service.normalize_cstart(
+                    continuation_cstart if continuation_cstart is not None else fallback_cstart
+                )
+            return None, queue_service.normalize_cstart(fallback_cstart)
+
+        if outcome == "failed" and state == ParseState.NETWORK_ERROR.value:
+            return "network_error_retry", queue_service.normalize_cstart(
+                continuation_cstart if continuation_cstart is not None else fallback_cstart
+            )
+
+        return None, queue_service.normalize_cstart(fallback_cstart)
+
+    def _build_failure_debug_context(
+        self,
+        *,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        attempt_log: list[dict[str, Any]],
+        page_logs: list[dict[str, Any]] | None = None,
+        exception: Exception | None = None,
+    ) -> dict[str, Any]:
+        context: dict[str, Any] = {
+            "requested_url": fetch_result.requested_url,
+            "final_url": fetch_result.final_url,
+            "status_code": fetch_result.status_code,
+            "fetch_error": fetch_result.error,
+            "state_reason": parsed_page.state_reason,
+            "profile_name": parsed_page.profile_name,
+            "profile_image_url": parsed_page.profile_image_url,
+            "articles_range": parsed_page.articles_range,
+            "has_show_more_button": parsed_page.has_show_more_button,
+            "has_operation_error_banner": parsed_page.has_operation_error_banner,
+            "warning_codes": parsed_page.warnings,
+            "marker_counts_nonzero": {
+                key: value for key, value in parsed_page.marker_counts.items() if value > 0
+            },
+            "body_length": len(fetch_result.body),
+            "body_sha256": hashlib.sha256(fetch_result.body.encode("utf-8")).hexdigest()
+            if fetch_result.body
+            else None,
+            "body_excerpt": _build_body_excerpt(fetch_result.body),
+            "attempt_log": attempt_log,
+        }
+        if page_logs:
+            context["page_logs"] = page_logs
+        if exception is not None:
+            context["exception_type"] = type(exception).__name__
+            context["exception_message"] = str(exception)
+        return context
+
+    async def _try_acquire_user_lock(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_id: int,
+    ) -> bool:
+        result = await db_session.execute(
+            text(
+                "SELECT pg_try_advisory_xact_lock(:namespace, :user_key)"
+            ),
+            {
+                "namespace": RUN_LOCK_NAMESPACE,
+                "user_key": int(user_id),
+            },
+        )
+        return bool(result.scalar_one())
diff --git a/build/lib/app/services/domains/ingestion/constants.py b/build/lib/app/services/domains/ingestion/constants.py
new file mode 100644
index 0000000..cfe2ba0
--- /dev/null
+++ b/build/lib/app/services/domains/ingestion/constants.py
@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import re
+
+from app.services.domains.scholar.parser import ParseState
+
+TITLE_ALNUM_RE = re.compile(r"[^a-z0-9]+")
+WORD_RE = re.compile(r"[a-z0-9]+")
+HTML_TAG_RE = re.compile(r"<[^>]+>", re.S)
+SPACE_RE = re.compile(r"\s+")
+
+FAILED_STATES = {
+    ParseState.BLOCKED_OR_CAPTCHA.value,
+    ParseState.LAYOUT_CHANGED.value,
+    ParseState.NETWORK_ERROR.value,
+    "ingestion_error",
+}
+
+FAILURE_BUCKET_BLOCKED = "blocked_or_captcha"
+FAILURE_BUCKET_NETWORK = "network_error"
+FAILURE_BUCKET_LAYOUT = "layout_changed"
+FAILURE_BUCKET_INGESTION = "ingestion_error"
+FAILURE_BUCKET_OTHER = "other_failure"
+
+RUN_LOCK_NAMESPACE = 8217
+RESUMABLE_PARTIAL_REASONS = {
+    "max_pages_reached",
+    "pagination_cursor_stalled",
+}
+RESUMABLE_PARTIAL_REASON_PREFIXES = ("page_state_network_error",)
+INITIAL_PAGE_FINGERPRINT_MAX_PUBLICATIONS = 30
diff --git a/build/lib/app/services/domains/ingestion/fingerprints.py b/build/lib/app/services/domains/ingestion/fingerprints.py
new file mode 100644
index 0000000..b59710e
--- /dev/null
+++ b/build/lib/app/services/domains/ingestion/fingerprints.py
@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from typing import Any
+from urllib.parse import urljoin
+
+from app.services.domains.ingestion.constants import (
+    HTML_TAG_RE,
+    INITIAL_PAGE_FINGERPRINT_MAX_PUBLICATIONS,
+    SPACE_RE,
+    TITLE_ALNUM_RE,
+    WORD_RE,
+)
+from app.services.domains.scholar.parser import ParseState, ParsedProfilePage, PublicationCandidate
+
+
+def normalize_title(value: str) -> str:
+    lowered = value.lower()
+    return TITLE_ALNUM_RE.sub("", lowered)
+
+
+def _first_author_last_name(authors_text: str | None) -> str:
+    if not authors_text:
+        return ""
+    first_author = authors_text.split(",", maxsplit=1)[0].strip().lower()
+    words = WORD_RE.findall(first_author)
+    if not words:
+        return ""
+    return words[-1]
+
+
+def _first_venue_word(venue_text: str | None) -> str:
+    if not venue_text:
+        return ""
+    words = WORD_RE.findall(venue_text.lower())
+    if not words:
+        return ""
+    return words[0]
+
+
+def build_publication_fingerprint(candidate: PublicationCandidate) -> str:
+    canonical = "|".join(
+        [
+            normalize_title(candidate.title),
+            str(candidate.year) if candidate.year is not None else "",
+            _first_author_last_name(candidate.authors_text),
+            _first_venue_word(candidate.venue_text),
+        ]
+    )
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def build_initial_page_fingerprint(parsed_page: ParsedProfilePage) -> str | None:
+    if parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}:
+        return None
+
+    normalized_rows: list[dict[str, Any]] = []
+    for publication in parsed_page.publications[:INITIAL_PAGE_FINGERPRINT_MAX_PUBLICATIONS]:
+        normalized_rows.append(
+            {
+                "cluster_id": publication.cluster_id or "",
+                "title_normalized": normalize_title(publication.title),
+                "year": publication.year,
+                "citation_count": publication.citation_count,
+            }
+        )
+
+    payload = {
+        "state": parsed_page.state.value,
+        "articles_range": parsed_page.articles_range or "",
+        "has_show_more_button": parsed_page.has_show_more_button,
+        "profile_name": parsed_page.profile_name or "",
+        "publications": normalized_rows,
+    }
+    canonical = json.dumps(
+        payload,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=True,
+    )
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def build_publication_url(path_or_url: str | None) -> str | None:
+    if not path_or_url:
+        return None
+    return urljoin("https://scholar.google.com", path_or_url)
+
+
+def _next_cstart_value(*, articles_range: str | None, fallback: int) -> int:
+    if articles_range:
+        numbers = re.findall(r"\d+", articles_range)
+        if len(numbers) >= 2:
+            try:
+                return int(numbers[1])
+            except ValueError:
+                pass
+    return int(fallback)
+
+
+def _title_tokens(value: str) -> set[str]:
+    """Extract normalized word tokens for fuzzy title comparison."""
+    return set(WORD_RE.findall(value.lower()))
+
+
+def fuzzy_titles_match(
+    title_a: str,
+    title_b: str,
+    *,
+    threshold: float = 0.85,
+) -> bool:
+    """Return True if two titles are near-duplicates by token-level Jaccard similarity.
+
+    A threshold of 0.85 catches common academic duplicate patterns:
+    differences in punctuation, minor word variations, subtitle changes.
+    """
+    tokens_a = _title_tokens(title_a)
+    tokens_b = _title_tokens(title_b)
+    if not tokens_a or not tokens_b:
+        return False
+    intersection = tokens_a & tokens_b
+    union = tokens_a | tokens_b
+    return (len(intersection) / len(union)) >= threshold
+
+
+def _dedupe_publication_candidates(
+    publications: list[PublicationCandidate],
+) -> list[PublicationCandidate]:
+    deduped: list[PublicationCandidate] = []
+    seen: set[str] = set()
+    seen_titles: list[tuple[str, int]] = []  # (normalized_title, index into deduped)
+
+    for publication in publications:
+        if publication.cluster_id:
+            identity = f"cluster:{publication.cluster_id}"
+        else:
+            identity = "|".join(
+                [
+                    "fallback",
+                    normalize_title(publication.title),
+                    str(publication.year) if publication.year is not None else "",
+                    _first_author_last_name(publication.authors_text),
+                    _first_venue_word(publication.venue_text),
+                ]
+            )
+        if identity in seen:
+            continue
+
+        # Fuzzy title check — catch near-identical titles not caught by exact fingerprint
+        norm_title = normalize_title(publication.title)
+        is_fuzzy_dup = False
+        for existing_title, _idx in seen_titles:
+            if fuzzy_titles_match(norm_title, existing_title):
+                is_fuzzy_dup = True
+                break
+        if is_fuzzy_dup:
+            continue
+
+        seen.add(identity)
+        seen_titles.append((norm_title, len(deduped)))
+        deduped.append(publication)
+    return deduped
+
+
+def _build_body_excerpt(body: str, *, max_chars: int = 220) -> str | None:
+    if not body:
+        return None
+    flattened = SPACE_RE.sub(" ", HTML_TAG_RE.sub(" ", body)).strip()
+    if not flattened:
+        return None
+    if len(flattened) <= max_chars:
+        return flattened
+    return f"{flattened[:max_chars - 1]}..."
diff --git a/build/lib/app/services/domains/ingestion/queue.py b/build/lib/app/services/domains/ingestion/queue.py
new file mode 100644
index 0000000..7494420
--- /dev/null
+++ b/build/lib/app/services/domains/ingestion/queue.py
@@ -0,0 +1,348 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import IngestionQueueItem, QueueItemStatus
+
+
+@dataclass(frozen=True)
+class ContinuationQueueJob:
+    id: int
+    user_id: int
+    scholar_profile_id: int
+    resume_cstart: int
+    reason: str
+    status: str
+    attempt_count: int
+    next_attempt_dt: datetime
+
+
+ACTIVE_QUEUE_STATUSES: tuple[str, ...] = (
+    QueueItemStatus.QUEUED.value,
+    QueueItemStatus.RETRYING.value,
+)
+
+
+def normalize_cstart(value: int | None) -> int:
+    if value is None:
+        return 0
+    return max(0, int(value))
+
+
+def compute_backoff_seconds(*, base_seconds: int, attempt_count: int, max_seconds: int) -> int:
+    base = max(1, int(base_seconds))
+    attempts = max(1, int(attempt_count))
+    maximum = max(base, int(max_seconds))
+    seconds = base * (2 ** max(0, attempts - 1))
+    return min(seconds, maximum)
+
+
+async def _get_item_for_user_scholar(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int,
+) -> IngestionQueueItem | None:
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(
+            IngestionQueueItem.user_id == user_id,
+            IngestionQueueItem.scholar_profile_id == scholar_profile_id,
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+def _build_queue_item(
+    *,
+    now: datetime,
+    user_id: int,
+    scholar_profile_id: int,
+    normalized_cstart: int,
+    reason: str,
+    run_id: int | None,
+    next_attempt_dt: datetime,
+) -> IngestionQueueItem:
+    return IngestionQueueItem(
+        user_id=user_id,
+        scholar_profile_id=scholar_profile_id,
+        resume_cstart=normalized_cstart,
+        reason=reason,
+        status=QueueItemStatus.QUEUED.value,
+        attempt_count=0,
+        next_attempt_dt=next_attempt_dt,
+        last_run_id=run_id,
+        last_error=None,
+        dropped_reason=None,
+        dropped_at=None,
+        created_at=now,
+        updated_at=now,
+    )
+
+
+def _update_existing_queue_item(
+    *,
+    item: IngestionQueueItem,
+    now: datetime,
+    normalized_cstart: int,
+    reason: str,
+    run_id: int | None,
+    next_attempt_dt: datetime,
+) -> None:
+    item.resume_cstart = normalized_cstart
+    item.reason = reason
+    if item.status == QueueItemStatus.DROPPED.value:
+        item.attempt_count = 0
+    item.status = QueueItemStatus.QUEUED.value
+    item.next_attempt_dt = next_attempt_dt
+    item.last_run_id = run_id
+    item.last_error = None
+    item.dropped_reason = None
+    item.dropped_at = None
+    item.updated_at = now
+
+
+async def upsert_job(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int,
+    resume_cstart: int,
+    reason: str,
+    run_id: int | None,
+    delay_seconds: int,
+) -> IngestionQueueItem:
+    now = datetime.now(timezone.utc)
+    next_attempt_dt = now + timedelta(seconds=max(0, int(delay_seconds)))
+    item = await _get_item_for_user_scholar(
+        db_session,
+        user_id=user_id,
+        scholar_profile_id=scholar_profile_id,
+    )
+    normalized_cstart = normalize_cstart(resume_cstart)
+    if item is None:
+        item = _build_queue_item(
+            now=now,
+            user_id=user_id,
+            scholar_profile_id=scholar_profile_id,
+            normalized_cstart=normalized_cstart,
+            reason=reason,
+            run_id=run_id,
+            next_attempt_dt=next_attempt_dt,
+        )
+        db_session.add(item)
+        return item
+
+    _update_existing_queue_item(
+        item=item,
+        now=now,
+        normalized_cstart=normalized_cstart,
+        reason=reason,
+        run_id=run_id,
+        next_attempt_dt=next_attempt_dt,
+    )
+    return item
+
+
+async def clear_job_for_scholar(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int,
+) -> bool:
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(
+            IngestionQueueItem.user_id == user_id,
+            IngestionQueueItem.scholar_profile_id == scholar_profile_id,
+        )
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return False
+    await db_session.delete(item)
+    return True
+
+
+async def delete_job_by_id(
+    db_session: AsyncSession,
+    *,
+    job_id: int,
+) -> bool:
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return False
+    await db_session.delete(item)
+    return True
+
+
+async def list_due_jobs(
+    db_session: AsyncSession,
+    *,
+    now: datetime,
+    limit: int,
+) -> list[ContinuationQueueJob]:
+    result = await db_session.execute(
+        select(IngestionQueueItem)
+        .where(
+            IngestionQueueItem.next_attempt_dt <= now,
+            IngestionQueueItem.status.in_(ACTIVE_QUEUE_STATUSES),
+        )
+        .order_by(
+            IngestionQueueItem.next_attempt_dt.asc(),
+            IngestionQueueItem.id.asc(),
+        )
+        .limit(limit)
+    )
+    rows = list(result.scalars().all())
+    jobs: list[ContinuationQueueJob] = []
+    for row in rows:
+        jobs.append(
+            ContinuationQueueJob(
+                id=int(row.id),
+                user_id=int(row.user_id),
+                scholar_profile_id=int(row.scholar_profile_id),
+                resume_cstart=normalize_cstart(row.resume_cstart),
+                reason=row.reason,
+                status=row.status,
+                attempt_count=int(row.attempt_count),
+                next_attempt_dt=row.next_attempt_dt,
+            )
+        )
+    return jobs
+
+
+async def increment_attempt_count(
+    db_session: AsyncSession,
+    *,
+    job_id: int,
+) -> IngestionQueueItem | None:
+    now = datetime.now(timezone.utc)
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    item.attempt_count = int(item.attempt_count or 0) + 1
+    item.updated_at = now
+    return item
+
+
+async def reset_attempt_count(
+    db_session: AsyncSession,
+    *,
+    job_id: int,
+) -> IngestionQueueItem | None:
+    now = datetime.now(timezone.utc)
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    item.attempt_count = 0
+    item.updated_at = now
+    return item
+
+
+async def reschedule_job(
+    db_session: AsyncSession,
+    *,
+    job_id: int,
+    delay_seconds: int,
+    reason: str,
+    error: str | None = None,
+) -> IngestionQueueItem | None:
+    now = datetime.now(timezone.utc)
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    item.next_attempt_dt = now + timedelta(seconds=max(1, int(delay_seconds)))
+    item.status = QueueItemStatus.QUEUED.value
+    item.reason = reason
+    item.last_error = error
+    item.dropped_reason = None
+    item.dropped_at = None
+    item.updated_at = now
+    return item
+
+
+async def mark_retrying(
+    db_session: AsyncSession,
+    *,
+    job_id: int,
+    reason: str | None = None,
+) -> IngestionQueueItem | None:
+    now = datetime.now(timezone.utc)
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    if item.status == QueueItemStatus.DROPPED.value:
+        return item
+    item.status = QueueItemStatus.RETRYING.value
+    if reason:
+        item.reason = reason
+    item.updated_at = now
+    return item
+
+
+async def mark_dropped(
+    db_session: AsyncSession,
+    *,
+    job_id: int,
+    reason: str,
+    error: str | None = None,
+) -> IngestionQueueItem | None:
+    now = datetime.now(timezone.utc)
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    item.status = QueueItemStatus.DROPPED.value
+    item.reason = "dropped"
+    item.dropped_reason = reason
+    item.dropped_at = now
+    if error is not None:
+        item.last_error = error
+    item.updated_at = now
+    return item
+
+
+async def mark_queued_now(
+    db_session: AsyncSession,
+    *,
+    job_id: int,
+    reason: str,
+    reset_attempt_count: bool = False,
+) -> IngestionQueueItem | None:
+    now = datetime.now(timezone.utc)
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    item.status = QueueItemStatus.QUEUED.value
+    item.reason = reason
+    item.next_attempt_dt = now
+    if reset_attempt_count:
+        item.attempt_count = 0
+    item.last_error = None
+    item.dropped_reason = None
+    item.dropped_at = None
+    item.updated_at = now
+    return item
diff --git a/build/lib/app/services/domains/ingestion/safety.py b/build/lib/app/services/domains/ingestion/safety.py
new file mode 100644
index 0000000..debb8c5
--- /dev/null
+++ b/build/lib/app/services/domains/ingestion/safety.py
@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+from app.db.models import UserSetting
+
+COOLDOWN_REASON_BLOCKED_FAILURE_THRESHOLD = "blocked_failure_threshold_exceeded"
+COOLDOWN_REASON_NETWORK_FAILURE_THRESHOLD = "network_failure_threshold_exceeded"
+
+_COUNTER_CONSECUTIVE_BLOCKED_RUNS = "consecutive_blocked_runs"
+_COUNTER_CONSECUTIVE_NETWORK_RUNS = "consecutive_network_runs"
+_COUNTER_COOLDOWN_ENTRY_COUNT = "cooldown_entry_count"
+_COUNTER_BLOCKED_START_COUNT = "blocked_start_count"
+_COUNTER_LAST_BLOCKED_FAILURE_COUNT = "last_blocked_failure_count"
+_COUNTER_LAST_NETWORK_FAILURE_COUNT = "last_network_failure_count"
+_COUNTER_LAST_EVALUATED_RUN_ID = "last_evaluated_run_id"
+
+
+def _utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _safe_int(value: Any, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _safe_optional_int(value: Any) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _normalize_datetime(value: datetime | None) -> datetime | None:
+    if value is None:
+        return None
+    if value.tzinfo is None:
+        return value.replace(tzinfo=timezone.utc)
+    return value.astimezone(timezone.utc)
+
+
+def _state_dict(settings: UserSetting) -> dict[str, Any]:
+    state = settings.scrape_safety_state
+    if isinstance(state, dict):
+        return state
+    return {}
+
+
+def _counters_from_state(settings: UserSetting) -> dict[str, Any]:
+    state = _state_dict(settings)
+    return {
+        _COUNTER_CONSECUTIVE_BLOCKED_RUNS: max(
+            0,
+            _safe_int(state.get(_COUNTER_CONSECUTIVE_BLOCKED_RUNS), 0),
+        ),
+        _COUNTER_CONSECUTIVE_NETWORK_RUNS: max(
+            0,
+            _safe_int(state.get(_COUNTER_CONSECUTIVE_NETWORK_RUNS), 0),
+        ),
+        _COUNTER_COOLDOWN_ENTRY_COUNT: max(
+            0,
+            _safe_int(state.get(_COUNTER_COOLDOWN_ENTRY_COUNT), 0),
+        ),
+        _COUNTER_BLOCKED_START_COUNT: max(
+            0,
+            _safe_int(state.get(_COUNTER_BLOCKED_START_COUNT), 0),
+        ),
+        _COUNTER_LAST_BLOCKED_FAILURE_COUNT: max(
+            0,
+            _safe_int(state.get(_COUNTER_LAST_BLOCKED_FAILURE_COUNT), 0),
+        ),
+        _COUNTER_LAST_NETWORK_FAILURE_COUNT: max(
+            0,
+            _safe_int(state.get(_COUNTER_LAST_NETWORK_FAILURE_COUNT), 0),
+        ),
+        _COUNTER_LAST_EVALUATED_RUN_ID: _safe_optional_int(
+            state.get(_COUNTER_LAST_EVALUATED_RUN_ID),
+        ),
+    }
+
+
+def _cooldown_reason_label(reason: str | None) -> str | None:
+    if reason == COOLDOWN_REASON_BLOCKED_FAILURE_THRESHOLD:
+        return "Blocked responses exceeded safety threshold"
+    if reason == COOLDOWN_REASON_NETWORK_FAILURE_THRESHOLD:
+        return "Network failures exceeded safety threshold"
+    return None
+
+
+def _recommended_action(reason: str | None) -> str | None:
+    if reason == COOLDOWN_REASON_BLOCKED_FAILURE_THRESHOLD:
+        return (
+            "Google Scholar appears to be blocking requests. Wait for cooldown to expire, "
+            "increase request delay, and avoid repeated manual retries."
+        )
+    if reason == COOLDOWN_REASON_NETWORK_FAILURE_THRESHOLD:
+        return (
+            "Network failures crossed the threshold. Verify connectivity and retry after cooldown."
+        )
+    return None
+
+
+def is_cooldown_active(
+    settings: UserSetting,
+    *,
+    now_utc: datetime | None = None,
+) -> bool:
+    now = now_utc or _utcnow()
+    cooldown_until = _normalize_datetime(settings.scrape_cooldown_until)
+    if cooldown_until is None:
+        return False
+    return cooldown_until > now
+
+
+def clear_expired_cooldown(
+    settings: UserSetting,
+    *,
+    now_utc: datetime | None = None,
+) -> bool:
+    now = now_utc or _utcnow()
+    cooldown_until = _normalize_datetime(settings.scrape_cooldown_until)
+    if cooldown_until is None:
+        return False
+    if cooldown_until > now:
+        return False
+    settings.scrape_cooldown_until = None
+    settings.scrape_cooldown_reason = None
+    return True
+
+
+def register_cooldown_blocked_start(
+    settings: UserSetting,
+    *,
+    now_utc: datetime | None = None,
+) -> dict[str, Any]:
+    now = now_utc or _utcnow()
+    counters = _counters_from_state(settings)
+    counters[_COUNTER_BLOCKED_START_COUNT] = int(counters[_COUNTER_BLOCKED_START_COUNT]) + 1
+    settings.scrape_safety_state = counters
+    return get_safety_state_payload(settings, now_utc=now)
+
+
+def _update_run_counters(
+    *,
+    counters: dict[str, Any],
+    run_id: int,
+    blocked_failure_count: int,
+    network_failure_count: int,
+) -> tuple[int, int]:
+    bounded_blocked_failures = max(0, int(blocked_failure_count))
+    bounded_network_failures = max(0, int(network_failure_count))
+    counters[_COUNTER_LAST_BLOCKED_FAILURE_COUNT] = bounded_blocked_failures
+    counters[_COUNTER_LAST_NETWORK_FAILURE_COUNT] = bounded_network_failures
+    counters[_COUNTER_LAST_EVALUATED_RUN_ID] = int(run_id)
+    counters[_COUNTER_CONSECUTIVE_BLOCKED_RUNS] = (
+        int(counters[_COUNTER_CONSECUTIVE_BLOCKED_RUNS]) + 1
+        if bounded_blocked_failures > 0
+        else 0
+    )
+    counters[_COUNTER_CONSECUTIVE_NETWORK_RUNS] = (
+        int(counters[_COUNTER_CONSECUTIVE_NETWORK_RUNS]) + 1
+        if bounded_network_failures > 0
+        else 0
+    )
+    return bounded_blocked_failures, bounded_network_failures
+
+
+def _resolve_cooldown_trigger(
+    *,
+    blocked_failures: int,
+    network_failures: int,
+    blocked_failure_threshold: int,
+    network_failure_threshold: int,
+    blocked_cooldown_seconds: int,
+    network_cooldown_seconds: int,
+) -> tuple[str | None, int]:
+    if blocked_failures >= max(1, int(blocked_failure_threshold)):
+        return COOLDOWN_REASON_BLOCKED_FAILURE_THRESHOLD, max(60, int(blocked_cooldown_seconds))
+    if network_failures >= max(1, int(network_failure_threshold)):
+        return COOLDOWN_REASON_NETWORK_FAILURE_THRESHOLD, max(60, int(network_cooldown_seconds))
+    return None, 0
+
+
+def _apply_cooldown_decision(
+    *,
+    settings: UserSetting,
+    counters: dict[str, Any],
+    now: datetime,
+    reason: str | None,
+    cooldown_seconds: int,
+) -> None:
+    if reason is None:
+        clear_expired_cooldown(settings, now_utc=now)
+        return
+    settings.scrape_cooldown_reason = reason
+    settings.scrape_cooldown_until = now + timedelta(seconds=max(60, int(cooldown_seconds)))
+    counters[_COUNTER_COOLDOWN_ENTRY_COUNT] = int(counters[_COUNTER_COOLDOWN_ENTRY_COUNT]) + 1
+
+
+def apply_run_safety_outcome(
+    settings: UserSetting,
+    *,
+    run_id: int,
+    blocked_failure_count: int,
+    network_failure_count: int,
+    blocked_failure_threshold: int,
+    network_failure_threshold: int,
+    blocked_cooldown_seconds: int,
+    network_cooldown_seconds: int,
+    now_utc: datetime | None = None,
+) -> tuple[dict[str, Any], str | None]:
+    now = now_utc or _utcnow()
+    counters = _counters_from_state(settings)
+    blocked_failures, network_failures = _update_run_counters(
+        counters=counters,
+        run_id=run_id,
+        blocked_failure_count=blocked_failure_count,
+        network_failure_count=network_failure_count,
+    )
+    reason, cooldown_seconds = _resolve_cooldown_trigger(
+        blocked_failures=blocked_failures,
+        network_failures=network_failures,
+        blocked_failure_threshold=blocked_failure_threshold,
+        network_failure_threshold=network_failure_threshold,
+        blocked_cooldown_seconds=blocked_cooldown_seconds,
+        network_cooldown_seconds=network_cooldown_seconds,
+    )
+    _apply_cooldown_decision(
+        settings=settings,
+        counters=counters,
+        now=now,
+        reason=reason,
+        cooldown_seconds=cooldown_seconds,
+    )
+    settings.scrape_safety_state = counters
+    return get_safety_state_payload(settings, now_utc=now), reason
+
+
+def get_safety_state_payload(
+    settings: UserSetting,
+    *,
+    now_utc: datetime | None = None,
+) -> dict[str, Any]:
+    now = now_utc or _utcnow()
+    cooldown_until = _normalize_datetime(settings.scrape_cooldown_until)
+    cooldown_active = bool(cooldown_until is not None and cooldown_until > now)
+    cooldown_remaining_seconds = 0
+    if cooldown_active and cooldown_until is not None:
+        cooldown_remaining_seconds = max(0, int((cooldown_until - now).total_seconds()))
+
+    reason = settings.scrape_cooldown_reason if cooldown_active else None
+
+    return {
+        "cooldown_active": cooldown_active,
+        "cooldown_reason": reason,
+        "cooldown_reason_label": _cooldown_reason_label(reason),
+        "cooldown_until": cooldown_until,
+        "cooldown_remaining_seconds": cooldown_remaining_seconds,
+        "recommended_action": _recommended_action(reason),
+        "counters": _counters_from_state(settings),
+    }
+
+
+def get_safety_event_context(
+    settings: UserSetting,
+    *,
+    now_utc: datetime | None = None,
+) -> dict[str, Any]:
+    payload = get_safety_state_payload(settings, now_utc=now_utc)
+    return {
+        "cooldown_active": bool(payload.get("cooldown_active")),
+        "cooldown_reason": payload.get("cooldown_reason"),
+        "cooldown_until": payload.get("cooldown_until"),
+        "cooldown_remaining_seconds": int(payload.get("cooldown_remaining_seconds") or 0),
+        "safety_counters": payload.get("counters", {}),
+    }
diff --git a/build/lib/app/services/domains/ingestion/scheduler.py b/build/lib/app/services/domains/ingestion/scheduler.py
new file mode 100644
index 0000000..b05e84d
--- /dev/null
+++ b/build/lib/app/services/domains/ingestion/scheduler.py
@@ -0,0 +1,622 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+import logging
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import (
+    CrawlRun,
+    QueueItemStatus,
+    RunTriggerType,
+    ScholarProfile,
+    User,
+    UserSetting,
+)
+from app.db.session import get_session_factory
+from app.services.domains.ingestion import queue as queue_service
+from app.services.domains.ingestion.application import (
+    RunAlreadyInProgressError,
+    RunBlockedBySafetyPolicyError,
+    ScholarIngestionService,
+)
+from app.services.domains.settings import application as user_settings_service
+from app.services.domains.scholar.source import LiveScholarSource
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+def _request_delay_floor_seconds() -> int:
+    return user_settings_service.resolve_request_delay_minimum(
+        settings.ingestion_min_request_delay_seconds
+    )
+
+
+def _effective_request_delay_seconds(value: int | None) -> int:
+    floor = _request_delay_floor_seconds()
+    try:
+        parsed = int(value) if value is not None else floor
+    except (TypeError, ValueError):
+        parsed = floor
+    return max(floor, parsed)
+
+
+@dataclass(frozen=True)
+class _AutoRunCandidate:
+    user_id: int
+    run_interval_minutes: int
+    request_delay_seconds: int
+    cooldown_until: datetime | None
+    cooldown_reason: str | None
+
+
+class SchedulerService:
+    def __init__(
+        self,
+        *,
+        enabled: bool,
+        tick_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        max_pages_per_scholar: int,
+        page_size: int,
+        continuation_queue_enabled: bool,
+        continuation_base_delay_seconds: int,
+        continuation_max_delay_seconds: int,
+        continuation_max_attempts: int,
+        queue_batch_size: int,
+    ) -> None:
+        self._enabled = enabled
+        self._tick_seconds = max(5, int(tick_seconds))
+        self._network_error_retries = max(0, int(network_error_retries))
+        self._retry_backoff_seconds = max(0.0, float(retry_backoff_seconds))
+        self._max_pages_per_scholar = max(1, int(max_pages_per_scholar))
+        self._page_size = max(1, int(page_size))
+        self._continuation_queue_enabled = bool(continuation_queue_enabled)
+        self._continuation_base_delay_seconds = max(1, int(continuation_base_delay_seconds))
+        self._continuation_max_delay_seconds = max(
+            self._continuation_base_delay_seconds,
+            int(continuation_max_delay_seconds),
+        )
+        self._continuation_max_attempts = max(1, int(continuation_max_attempts))
+        self._queue_batch_size = max(1, int(queue_batch_size))
+        self._task: asyncio.Task[None] | None = None
+        self._source = LiveScholarSource()
+
+    async def start(self) -> None:
+        if not self._enabled:
+            logger.info(
+                "scheduler.disabled",
+                extra={
+                    "event": "scheduler.disabled",
+                },
+            )
+            return
+        if self._task is not None:
+            return
+        self._task = asyncio.create_task(self._run_loop(), name="scholarr-scheduler")
+        logger.info(
+            "scheduler.started",
+            extra={
+                "event": "scheduler.started",
+                "tick_seconds": self._tick_seconds,
+                "network_error_retries": self._network_error_retries,
+                "retry_backoff_seconds": self._retry_backoff_seconds,
+                "max_pages_per_scholar": self._max_pages_per_scholar,
+                "page_size": self._page_size,
+                "continuation_queue_enabled": self._continuation_queue_enabled,
+                "continuation_base_delay_seconds": self._continuation_base_delay_seconds,
+                "continuation_max_delay_seconds": self._continuation_max_delay_seconds,
+                "continuation_max_attempts": self._continuation_max_attempts,
+                "queue_batch_size": self._queue_batch_size,
+            },
+        )
+
+    async def stop(self) -> None:
+        if self._task is None:
+            return
+        self._task.cancel()
+        try:
+            await self._task
+        except asyncio.CancelledError:
+            pass
+        finally:
+            self._task = None
+        logger.info("scheduler.stopped", extra={"event": "scheduler.stopped"})
+
+    async def _run_loop(self) -> None:
+        while True:
+            try:
+                await self._tick_once()
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception(
+                    "scheduler.tick_failed",
+                    extra={
+                        "event": "scheduler.tick_failed",
+                    },
+                )
+            await asyncio.sleep(float(self._tick_seconds))
+
+    async def _tick_once(self) -> None:
+        if self._continuation_queue_enabled:
+            await self._drain_continuation_queue()
+        
+        await self._drain_pdf_queue()
+
+        candidates = await self._load_candidates()
+        if not candidates:
+            return
+        now = datetime.now(timezone.utc)
+        for candidate in candidates:
+            if not await self._is_due(candidate, now=now):
+                continue
+            await self._run_candidate(candidate)
+
+    async def _load_candidate_rows(self) -> list[tuple]:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            result = await session.execute(
+                select(
+                    UserSetting.user_id,
+                    UserSetting.run_interval_minutes,
+                    UserSetting.request_delay_seconds,
+                    UserSetting.scrape_cooldown_until,
+                    UserSetting.scrape_cooldown_reason,
+                )
+                .join(User, User.id == UserSetting.user_id)
+                .where(User.is_active.is_(True), UserSetting.auto_run_enabled.is_(True))
+                .order_by(UserSetting.user_id.asc())
+            )
+            return result.all()
+
+    @staticmethod
+    def _candidate_from_row(row: tuple, *, now_utc: datetime) -> _AutoRunCandidate | None:
+        user_id, run_interval_minutes, request_delay_seconds, cooldown_until, cooldown_reason = row
+        if cooldown_until is not None and cooldown_until.tzinfo is None:
+            cooldown_until = cooldown_until.replace(tzinfo=timezone.utc)
+        if cooldown_until is not None and cooldown_until > now_utc:
+            logger.info(
+                "scheduler.run_skipped_safety_cooldown_precheck",
+                extra={
+                    "event": "scheduler.run_skipped_safety_cooldown_precheck",
+                    "user_id": int(user_id),
+                    "reason": cooldown_reason,
+                    "cooldown_until": cooldown_until,
+                    "cooldown_remaining_seconds": int((cooldown_until - now_utc).total_seconds()),
+                    "metric_name": "scheduler_run_skipped_safety_cooldown_total",
+                    "metric_value": 1,
+                },
+            )
+            return None
+        return _AutoRunCandidate(
+            user_id=int(user_id),
+            run_interval_minutes=int(run_interval_minutes),
+            request_delay_seconds=_effective_request_delay_seconds(request_delay_seconds),
+            cooldown_until=cooldown_until,
+            cooldown_reason=(str(cooldown_reason).strip() if cooldown_reason else None),
+        )
+
+    async def _load_candidates(self) -> list[_AutoRunCandidate]:
+        if not settings.ingestion_automation_allowed:
+            return []
+        rows = await self._load_candidate_rows()
+        now_utc = datetime.now(timezone.utc)
+        candidates: list[_AutoRunCandidate] = []
+        for row in rows:
+            candidate = self._candidate_from_row(row, now_utc=now_utc)
+            if candidate is not None:
+                candidates.append(candidate)
+        return candidates
+
+    async def _is_due(self, candidate: _AutoRunCandidate, *, now: datetime) -> bool:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            result = await session.execute(
+                select(CrawlRun.start_dt)
+                .where(
+                    CrawlRun.user_id == candidate.user_id,
+                )
+                .order_by(CrawlRun.start_dt.desc(), CrawlRun.id.desc())
+                .limit(1)
+            )
+            last_run = result.scalar_one_or_none()
+
+        if last_run is None:
+            return True
+
+        next_due_dt = last_run + timedelta(
+            minutes=candidate.run_interval_minutes
+        )
+        return now >= next_due_dt
+
+    async def _run_candidate_ingestion(
+        self,
+        *,
+        candidate: _AutoRunCandidate,
+    ):
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            ingestion = ScholarIngestionService(source=self._source)
+            try:
+                return await ingestion.run_for_user(
+                    session,
+                    user_id=candidate.user_id,
+                    trigger_type=RunTriggerType.SCHEDULED,
+                    request_delay_seconds=candidate.request_delay_seconds,
+                    network_error_retries=self._network_error_retries,
+                    retry_backoff_seconds=self._retry_backoff_seconds,
+                    max_pages_per_scholar=self._max_pages_per_scholar,
+                    page_size=self._page_size,
+                    auto_queue_continuations=self._continuation_queue_enabled,
+                    queue_delay_seconds=self._continuation_base_delay_seconds,
+                    alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
+                    alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
+                    alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
+                )
+            except RunAlreadyInProgressError:
+                await session.rollback()
+                logger.info("scheduler.run_skipped_locked", extra={"event": "scheduler.run_skipped_locked", "user_id": candidate.user_id})
+                return None
+            except RunBlockedBySafetyPolicyError as exc:
+                await session.rollback()
+                logger.info(
+                    "scheduler.run_skipped_safety_cooldown",
+                    extra={
+                        "event": "scheduler.run_skipped_safety_cooldown",
+                        "user_id": candidate.user_id,
+                        "reason": exc.safety_state.get("cooldown_reason"),
+                        "cooldown_until": exc.safety_state.get("cooldown_until"),
+                        "cooldown_remaining_seconds": exc.safety_state.get("cooldown_remaining_seconds"),
+                        "metric_name": "scheduler_run_skipped_safety_cooldown_total",
+                        "metric_value": 1,
+                    },
+                )
+                return None
+            except Exception:
+                await session.rollback()
+                logger.exception("scheduler.run_failed", extra={"event": "scheduler.run_failed", "user_id": candidate.user_id})
+                return None
+
+    async def _run_candidate(self, candidate: _AutoRunCandidate) -> None:
+        run_summary = await self._run_candidate_ingestion(candidate=candidate)
+        if run_summary is None:
+            return
+        logger.info(
+            "scheduler.run_completed",
+            extra={
+                "event": "scheduler.run_completed",
+                "user_id": candidate.user_id,
+                "run_id": run_summary.crawl_run_id,
+                "status": run_summary.status.value,
+                "scholar_count": run_summary.scholar_count,
+                "new_publication_count": run_summary.new_publication_count,
+            },
+        )
+
+    async def _drain_continuation_queue(self) -> None:
+        now = datetime.now(timezone.utc)
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            jobs = await queue_service.list_due_jobs(
+                session,
+                now=now,
+                limit=self._queue_batch_size,
+            )
+        for job in jobs:
+            await self._run_queue_job(job)
+
+    async def _drop_queue_job_if_max_attempts(
+        self,
+        job: queue_service.ContinuationQueueJob,
+    ) -> bool:
+        if job.attempt_count < self._continuation_max_attempts:
+            return False
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            dropped = await queue_service.mark_dropped(
+                session,
+                job_id=job.id,
+                reason="max_attempts_reached",
+            )
+            await session.commit()
+        if dropped is not None:
+            logger.warning(
+                "scheduler.queue_item_dropped_max_attempts",
+                extra={
+                    "event": "scheduler.queue_item_dropped_max_attempts",
+                    "queue_item_id": job.id,
+                    "user_id": job.user_id,
+                    "scholar_profile_id": job.scholar_profile_id,
+                    "attempt_count": job.attempt_count,
+                    "max_attempts": self._continuation_max_attempts,
+                },
+            )
+        return True
+
+    async def _mark_queue_job_retrying(
+        self,
+        job: queue_service.ContinuationQueueJob,
+    ) -> bool:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            queue_item = await queue_service.mark_retrying(session, job_id=job.id)
+            await session.commit()
+        if queue_item is None:
+            return False
+        if queue_item.status == QueueItemStatus.DROPPED.value:
+            return False
+        return True
+
+    async def _queue_job_has_available_scholar(
+        self,
+        job: queue_service.ContinuationQueueJob,
+    ) -> bool:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            scholar_result = await session.execute(
+                select(ScholarProfile.id).where(
+                    ScholarProfile.user_id == job.user_id,
+                    ScholarProfile.id == job.scholar_profile_id,
+                    ScholarProfile.is_enabled.is_(True),
+                )
+            )
+            scholar_id = scholar_result.scalar_one_or_none()
+            if scholar_id is not None:
+                return True
+            dropped = await queue_service.mark_dropped(
+                session,
+                job_id=job.id,
+                reason="scholar_unavailable",
+            )
+            await session.commit()
+        if dropped is not None:
+            logger.info(
+                "scheduler.queue_item_dropped_scholar_unavailable",
+                extra={
+                    "event": "scheduler.queue_item_dropped_scholar_unavailable",
+                    "queue_item_id": job.id,
+                    "user_id": job.user_id,
+                    "scholar_profile_id": job.scholar_profile_id,
+                },
+            )
+        return False
+
+    async def _reschedule_queue_job_lock_active(self, job: queue_service.ContinuationQueueJob) -> None:
+        session_factory = get_session_factory()
+        async with session_factory() as recovery_session:
+            await queue_service.reschedule_job(
+                recovery_session,
+                job_id=job.id,
+                delay_seconds=max(self._tick_seconds, 15),
+                reason="user_run_lock_active",
+                error="run_already_in_progress",
+            )
+            await recovery_session.commit()
+        logger.info(
+            "scheduler.queue_item_deferred_lock",
+            extra={"event": "scheduler.queue_item_deferred_lock", "queue_item_id": job.id, "user_id": job.user_id},
+        )
+
+    async def _reschedule_queue_job_safety_cooldown(
+        self,
+        job: queue_service.ContinuationQueueJob,
+        exc: RunBlockedBySafetyPolicyError,
+    ) -> None:
+        cooldown_remaining_seconds = max(
+            self._tick_seconds,
+            int(exc.safety_state.get("cooldown_remaining_seconds") or 0),
+        )
+        session_factory = get_session_factory()
+        async with session_factory() as recovery_session:
+            await queue_service.reschedule_job(
+                recovery_session,
+                job_id=job.id,
+                delay_seconds=max(self._tick_seconds, cooldown_remaining_seconds),
+                reason="scrape_safety_cooldown",
+                error=str(exc.message),
+            )
+            await recovery_session.commit()
+        logger.info(
+            "scheduler.queue_item_deferred_safety_cooldown",
+            extra={
+                "event": "scheduler.queue_item_deferred_safety_cooldown",
+                "queue_item_id": job.id,
+                "user_id": job.user_id,
+                "reason": exc.safety_state.get("cooldown_reason"),
+                "cooldown_remaining_seconds": cooldown_remaining_seconds,
+                "metric_name": "scheduler_queue_item_deferred_safety_cooldown_total",
+                "metric_value": 1,
+            },
+        )
+
+    async def _reschedule_queue_job_after_exception(
+        self,
+        job: queue_service.ContinuationQueueJob,
+        *,
+        exc: Exception,
+    ) -> None:
+        session_factory = get_session_factory()
+        async with session_factory() as recovery_session:
+            queue_item = await queue_service.increment_attempt_count(recovery_session, job_id=job.id)
+            if queue_item is None:
+                await recovery_session.commit()
+                return
+            if int(queue_item.attempt_count) >= self._continuation_max_attempts:
+                await queue_service.mark_dropped(
+                    recovery_session,
+                    job_id=job.id,
+                    reason="scheduler_exception_max_attempts",
+                    error=str(exc),
+                )
+                await recovery_session.commit()
+                logger.warning(
+                    "scheduler.queue_item_dropped_after_exception",
+                    extra={"event": "scheduler.queue_item_dropped_after_exception", "queue_item_id": job.id, "user_id": job.user_id, "attempt_count": queue_item.attempt_count},
+                )
+                return
+            delay_seconds = queue_service.compute_backoff_seconds(
+                base_seconds=self._continuation_base_delay_seconds,
+                attempt_count=int(queue_item.attempt_count),
+                max_seconds=self._continuation_max_delay_seconds,
+            )
+            await queue_service.reschedule_job(
+                recovery_session,
+                job_id=job.id,
+                delay_seconds=delay_seconds,
+                reason="scheduler_exception",
+                error=str(exc),
+            )
+            await recovery_session.commit()
+        logger.exception("scheduler.queue_item_run_failed", extra={"event": "scheduler.queue_item_run_failed", "queue_item_id": job.id, "user_id": job.user_id})
+
+    async def _run_ingestion_for_queue_job(
+        self,
+        job: queue_service.ContinuationQueueJob,
+    ):
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            request_delay_seconds = await self._load_request_delay_for_user(session, user_id=job.user_id)
+            ingestion = ScholarIngestionService(source=self._source)
+            try:
+                return await ingestion.run_for_user(
+                    session,
+                    user_id=job.user_id,
+                    trigger_type=RunTriggerType.SCHEDULED,
+                    request_delay_seconds=request_delay_seconds,
+                    network_error_retries=self._network_error_retries,
+                    retry_backoff_seconds=self._retry_backoff_seconds,
+                    rate_limit_retries=settings.ingestion_rate_limit_retries,
+                    rate_limit_backoff_seconds=settings.ingestion_rate_limit_backoff_seconds,
+                    max_pages_per_scholar=self._max_pages_per_scholar,
+                    page_size=self._page_size,
+                    scholar_profile_ids={job.scholar_profile_id},
+                    start_cstart_by_scholar_id={job.scholar_profile_id: job.resume_cstart},
+                    auto_queue_continuations=self._continuation_queue_enabled,
+                    queue_delay_seconds=self._continuation_base_delay_seconds,
+                    alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
+                    alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
+                    alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
+                )
+            except RunAlreadyInProgressError:
+                await session.rollback()
+                await self._reschedule_queue_job_lock_active(job)
+            except RunBlockedBySafetyPolicyError as exc:
+                await session.rollback()
+                await self._reschedule_queue_job_safety_cooldown(job, exc)
+            except Exception as exc:
+                await session.rollback()
+                await self._reschedule_queue_job_after_exception(job, exc=exc)
+        return None
+
+    @staticmethod
+    def _log_queue_item_resolved(
+        *,
+        event_name: str,
+        job: queue_service.ContinuationQueueJob,
+        run_summary,
+        attempt_count: int | None = None,
+        delay_seconds: int | None = None,
+    ) -> None:
+        payload = {
+            "event": event_name,
+            "queue_item_id": job.id,
+            "user_id": job.user_id,
+            "run_id": run_summary.crawl_run_id,
+            "status": run_summary.status.value,
+        }
+        if attempt_count is not None:
+            payload["attempt_count"] = attempt_count
+        if delay_seconds is not None:
+            payload["delay_seconds"] = delay_seconds
+        logger.info(event_name, extra=payload)
+
+    async def _finalize_queue_job_after_run(self, job: queue_service.ContinuationQueueJob, run_summary) -> None:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            if int(run_summary.failed_count) <= 0:
+                queue_item = await queue_service.reset_attempt_count(session, job_id=job.id)
+                await session.commit()
+                if queue_item is None:
+                    self._log_queue_item_resolved(event_name="scheduler.queue_item_resolved", job=job, run_summary=run_summary)
+                    return
+                self._log_queue_item_resolved(
+                    event_name="scheduler.queue_item_progressed",
+                    job=job,
+                    run_summary=run_summary,
+                    attempt_count=int(queue_item.attempt_count),
+                )
+                return
+            queue_item = await queue_service.increment_attempt_count(session, job_id=job.id)
+            if queue_item is None:
+                await session.commit()
+                self._log_queue_item_resolved(event_name="scheduler.queue_item_resolved", job=job, run_summary=run_summary)
+                return
+            if int(queue_item.attempt_count) >= self._continuation_max_attempts:
+                await queue_service.mark_dropped(session, job_id=job.id, reason="max_attempts_after_run")
+                await session.commit()
+                logger.warning(
+                    "scheduler.queue_item_dropped_max_attempts_after_run",
+                    extra={"event": "scheduler.queue_item_dropped_max_attempts_after_run", "queue_item_id": job.id, "user_id": job.user_id, "attempt_count": queue_item.attempt_count, "run_id": run_summary.crawl_run_id, "status": run_summary.status.value},
+                )
+                return
+            delay_seconds = queue_service.compute_backoff_seconds(base_seconds=self._continuation_base_delay_seconds, attempt_count=int(queue_item.attempt_count), max_seconds=self._continuation_max_delay_seconds)
+            await queue_service.reschedule_job(session, job_id=job.id, delay_seconds=delay_seconds, reason=queue_item.reason, error=queue_item.last_error)
+            await session.commit()
+        self._log_queue_item_resolved(
+            event_name="scheduler.queue_item_rescheduled_failed",
+            job=job,
+            run_summary=run_summary,
+            attempt_count=int(queue_item.attempt_count),
+            delay_seconds=delay_seconds,
+        )
+
+    async def _run_queue_job(self, job: queue_service.ContinuationQueueJob) -> None:
+        if await self._drop_queue_job_if_max_attempts(job):
+            return
+        if not await self._mark_queue_job_retrying(job):
+            return
+        if not await self._queue_job_has_available_scholar(job):
+            return
+        run_summary = await self._run_ingestion_for_queue_job(job)
+        if run_summary is None:
+            return
+        await self._finalize_queue_job_after_run(job, run_summary)
+
+    async def _drain_pdf_queue(self) -> None:
+        from app.services.domains.publications.pdf_queue import drain_ready_jobs
+        
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            try:
+                processed = await drain_ready_jobs(
+                    session,
+                    limit=settings.scheduler_pdf_queue_batch_size,
+                    max_attempts=settings.pdf_auto_retry_max_attempts,
+                )
+                if processed > 0:
+                    logger.info("scheduler.pdf_queue_drain_completed", extra={
+                        "event": "scheduler.pdf_queue_drain_completed",
+                        "processed_count": processed,
+                    })
+            except Exception:
+                logger.exception("scheduler.pdf_queue_drain_failed", extra={
+                    "event": "scheduler.pdf_queue_drain_failed",
+                })
+
+    async def _load_request_delay_for_user(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_id: int,
+    ) -> int:
+        result = await db_session.execute(
+            select(UserSetting.request_delay_seconds).where(UserSetting.user_id == user_id)
+        )
+        delay = result.scalar_one_or_none()
+        return _effective_request_delay_seconds(delay)
diff --git a/build/lib/app/services/domains/ingestion/types.py b/build/lib/app/services/domains/ingestion/types.py
new file mode 100644
index 0000000..09d87f1
--- /dev/null
+++ b/build/lib/app/services/domains/ingestion/types.py
@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from app.db.models import RunStatus
+from app.services.domains.scholar.parser import ParsedProfilePage, PublicationCandidate
+from app.services.domains.scholar.source import FetchResult
+
+
+@dataclass(frozen=True)
+class RunExecutionSummary:
+    crawl_run_id: int
+    status: RunStatus
+    scholar_count: int
+    succeeded_count: int
+    failed_count: int
+    partial_count: int
+    new_publication_count: int
+
+
+@dataclass(frozen=True)
+class PagedParseResult:
+    fetch_result: FetchResult
+    parsed_page: ParsedProfilePage
+    first_page_fetch_result: FetchResult
+    first_page_parsed_page: ParsedProfilePage
+    first_page_fingerprint_sha256: str | None
+    publications: list[PublicationCandidate]
+    attempt_log: list[dict[str, Any]]
+    page_logs: list[dict[str, Any]]
+    pages_fetched: int
+    pages_attempted: int
+    has_more_remaining: bool
+    pagination_truncated_reason: str | None
+    continuation_cstart: int | None
+    skipped_no_change: bool
+    discovered_publication_count: int
+
+
+@dataclass
+class RunProgress:
+    succeeded_count: int = 0
+    failed_count: int = 0
+    partial_count: int = 0
+    scholar_results: list[dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class ScholarProcessingOutcome:
+    result_entry: dict[str, Any]
+    succeeded_count_delta: int
+    failed_count_delta: int
+    partial_count_delta: int
+    discovered_publication_count: int
+
+
+@dataclass(frozen=True)
+class RunFailureSummary:
+    failed_state_counts: dict[str, int]
+    failed_reason_counts: dict[str, int]
+    scrape_failure_counts: dict[str, int]
+    retries_scheduled_count: int
+    scholars_with_retries_count: int
+    retry_exhausted_count: int
+
+
+@dataclass(frozen=True)
+class RunAlertSummary:
+    blocked_failure_count: int
+    network_failure_count: int
+    blocked_failure_threshold: int
+    network_failure_threshold: int
+    retry_scheduled_threshold: int
+    alert_flags: dict[str, bool]
+
+
+@dataclass
+class PagedLoopState:
+    fetch_result: FetchResult
+    parsed_page: ParsedProfilePage
+    attempt_log: list[dict[str, Any]]
+    page_logs: list[dict[str, Any]]
+    publications: list[PublicationCandidate]
+    pages_fetched: int
+    pages_attempted: int
+    current_cstart: int
+    next_cstart: int
+    has_more_remaining: bool = False
+    pagination_truncated_reason: str | None = None
+    continuation_cstart: int | None = None
+    discovered_publication_count: int = 0
+
+
+class RunAlreadyInProgressError(RuntimeError):
+    """Raised when a run lock for a user is already held by another process."""
+
+
+class RunBlockedBySafetyPolicyError(RuntimeError):
+    def __init__(
+        self,
+        *,
+        code: str,
+        message: str,
+        safety_state: dict[str, Any],
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.safety_state = safety_state
diff --git a/build/lib/app/services/domains/openalex/__init__.py b/build/lib/app/services/domains/openalex/__init__.py
new file mode 100644
index 0000000..a51555a
--- /dev/null
+++ b/build/lib/app/services/domains/openalex/__init__.py
@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
diff --git a/build/lib/app/services/domains/openalex/client.py b/build/lib/app/services/domains/openalex/client.py
new file mode 100644
index 0000000..c62d876
--- /dev/null
+++ b/build/lib/app/services/domains/openalex/client.py
@@ -0,0 +1,135 @@
+import asyncio
+import logging
+from typing import Any, Mapping
+
+import httpx
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from app.services.domains.openalex.types import OpenAlexWork
+
+logger = logging.getLogger(__name__)
+
+OPENALEX_BASE_URL = "https://api.openalex.org"
+
+
+class OpenAlexClientError(Exception):
+    pass
+
+
+class OpenAlexRateLimitError(OpenAlexClientError):
+    pass
+
+
+class OpenAlexClient:
+    def __init__(
+        self,
+        api_key: str | None = None,
+        mailto: str | None = None,
+        timeout: float = 10.0,
+    ) -> None:
+        self.api_key = api_key
+        self.mailto = mailto
+        self.timeout = timeout
+
+    @property
+    def _base_params(self) -> dict[str, str]:
+        params = {}
+        if self.mailto:
+            params["mailto"] = self.mailto
+        if self.api_key:
+            params["api_key"] = self.api_key
+        return params
+
+    @retry(
+        retry=retry_if_exception_type((httpx.NetworkError, httpx.TimeoutException, OpenAlexRateLimitError)),
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        reraise=True,
+    )
+    async def get_work_by_doi(self, doi: str) -> OpenAlexWork | None:
+        """Fetch a single work by DOI directly."""
+        clean_doi = doi.replace("https://doi.org/", "")
+        if not clean_doi:
+            return None
+
+        url = f"{OPENALEX_BASE_URL}/works/{clean_doi}"
+        
+        headers = {}
+        if self.mailto:
+            headers["User-Agent"] = f"scholar-scraper/1.0 (mailto:{self.mailto})"
+        else:
+            headers["User-Agent"] = "scholar-scraper/1.0"
+
+        async with httpx.AsyncClient(timeout=self.timeout, follow_redirects=True, headers=headers) as client:
+            response = await client.get(url, params=self._base_params)
+
+        if response.status_code == 404:
+            return None
+        if response.status_code == 429:
+            raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex work by DOI")
+        if response.status_code >= 400:
+            logger.warning("OpenAlex API error: %s %s", response.status_code, response.text)
+            raise OpenAlexClientError(f"API Error {response.status_code}")
+
+        data = response.json()
+        return OpenAlexWork.from_api_dict(data)
+
+    @retry(
+        retry=retry_if_exception_type((httpx.NetworkError, httpx.TimeoutException, OpenAlexRateLimitError)),
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        reraise=True,
+    )
+    async def get_works_by_filter(
+        self,
+        filters: dict[str, str],
+        limit: int = 50,
+    ) -> list[OpenAlexWork]:
+        """
+        Fetch works using the ?filter= query parameter.
+        Supports fetching multiple records by joining filters with | (OR logic).
+        """
+        if not filters:
+            return []
+
+        # Example: {"doi": "10.foo|10.bar", "title.search": "query"}
+        filter_str = ",".join(f"{k}:{v}" for k, v in filters.items())
+        
+        params = self._base_params.copy()
+        params["filter"] = filter_str
+        params["per-page"] = str(limit)
+
+        url = f"{OPENALEX_BASE_URL}/works"
+        
+        headers = {}
+        if self.mailto:
+            headers["User-Agent"] = f"scholar-scraper/1.0 (mailto:{self.mailto})"
+        else:
+            headers["User-Agent"] = "scholar-scraper/1.0"
+
+        async with httpx.AsyncClient(timeout=self.timeout, follow_redirects=True, headers=headers) as client:
+            response = await client.get(url, params=params)
+
+        if response.status_code == 429:
+            raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex works list")
+        if response.status_code >= 400:
+            logger.warning("OpenAlex API error (filters=%s): %s %s", filters, response.status_code, response.text)
+            raise OpenAlexClientError(f"API Error {response.status_code}")
+
+        data = response.json()
+        results = data.get("results") or []
+        
+        parsed_works = []
+        for raw_work in results:
+            try:
+                parsed_works.append(OpenAlexWork.from_api_dict(raw_work))
+            except Exception as e:
+                logger.warning("Failed to parse OpenAlex raw dict: %s", e)
+                continue
+
+        return parsed_works
diff --git a/build/lib/app/services/domains/openalex/matching.py b/build/lib/app/services/domains/openalex/matching.py
new file mode 100644
index 0000000..cfa511c
--- /dev/null
+++ b/build/lib/app/services/domains/openalex/matching.py
@@ -0,0 +1,108 @@
+import logging
+import re
+
+from rapidfuzz import fuzz
+
+from app.services.domains.openalex.types import OpenAlexWork
+
+logger = logging.getLogger(__name__)
+
+# A minimum similarity score out of 100 for a title to be considered a match candidate.
+TITLE_MATCH_THRESHOLD = 90.0
+# The margin within the top score where a secondary tiebreaker (author/year) is necessary.
+TIEBREAKER_MARGIN = 5.0
+
+
+def _clean_string(s: str | None) -> str:
+    if not s:
+        return ""
+    # Strip non-alphanumeric (keep spaces), lowercase, and collapse whitespace
+    cleaned = re.sub(r"[^a-z0-9\s]", " ", s.lower())
+    return " ".join(cleaned.split())
+
+
+def _author_overlap_score(target_authors: str | None, candidate_authors: list[str]) -> bool:
+    if not target_authors or not candidate_authors:
+        return False
+    
+    target_clean = _clean_string(target_authors)
+    if not target_clean:
+        return False
+        
+    for candidate in candidate_authors:
+        cand_clean = _clean_string(candidate)
+        if cand_clean and (cand_clean in target_clean or target_clean in cand_clean):
+            return True
+        # Alternatively check rapidfuzz token_set_ratio
+        if cand_clean and fuzz.token_set_ratio(target_clean, cand_clean) > 80:
+            return True
+            
+    return False
+
+
+def find_best_match(
+    target_title: str,
+    target_year: int | None,
+    target_authors: str | None,
+    candidates: list[OpenAlexWork],
+) -> OpenAlexWork | None:
+    """
+    Finds the best matching OpenAlexWork from a list of candidates, prioritizing title similarity (>90%)
+    with year and author overlap as tiebreakers for close candidates.
+    """
+    if not target_title or not candidates:
+        return None
+
+    clean_target = _clean_string(target_title)
+    if not clean_target:
+        return None
+
+    scored_candidates: list[tuple[float, OpenAlexWork]] = []
+
+    for cand in candidates:
+        if not cand.title:
+            continue
+            
+        clean_cand = _clean_string(cand.title)
+        
+        # Primary sort: string similarity ratio
+        score = fuzz.ratio(clean_target, clean_cand)
+        
+        if score >= TITLE_MATCH_THRESHOLD:
+            scored_candidates.append((score, cand))
+
+    if not scored_candidates:
+        return None
+
+    # Sort descending by score
+    scored_candidates.sort(key=lambda x: x[0], reverse=True)
+    
+    best_score = scored_candidates[0][0]
+    
+    # Extract all candidates within the tiebreaker margin
+    top_scored_candidates = [
+        (score, cand) for score, cand in scored_candidates 
+        if best_score - score <= TIEBREAKER_MARGIN
+    ]
+
+    if len(top_scored_candidates) == 1:
+        return top_scored_candidates[0][1]
+
+    # We have a tie or near-tie. Use year and author overlap to break the tie.
+    # Score candidates: +1 for year match (within 1 year), +1 for author overlap
+    tiebreaker_scores: list[tuple[int, float, OpenAlexWork]] = []
+    
+    for original_score, cand in top_scored_candidates:
+        tb_score = 0
+        if target_year is not None and cand.publication_year is not None:
+            if abs(target_year - cand.publication_year) <= 1:
+                tb_score += 1
+                
+        candidate_author_names = [a.display_name for a in cand.authors if a.display_name]
+        if _author_overlap_score(target_authors, candidate_author_names):
+            tb_score += 1
+            
+        tiebreaker_scores.append((tb_score, original_score, cand))
+        
+    tiebreaker_scores.sort(key=lambda x: (x[0], x[1]), reverse=True)
+    return tiebreaker_scores[0][2]
diff --git a/build/lib/app/services/domains/openalex/types.py b/build/lib/app/services/domains/openalex/types.py
new file mode 100644
index 0000000..0d86754
--- /dev/null
+++ b/build/lib/app/services/domains/openalex/types.py
@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Mapping
+
+
+@dataclass(frozen=True)
+class OpenAlexAuthor:
+    openalex_id: str | None
+    display_name: str | None
+
+
+@dataclass(frozen=True)
+class OpenAlexWork:
+    openalex_id: str
+    doi: str | None
+    pmid: str | None
+    pmcid: str | None
+    title: str | None
+    publication_year: int | None
+    cited_by_count: int
+    is_oa: bool
+    oa_url: str | None
+    authors: list[OpenAlexAuthor] = field(default_factory=list)
+    raw_data: Mapping[str, Any] = field(default_factory=dict, repr=False)
+
+    @classmethod
+    def from_api_dict(cls, data: Mapping[str, Any]) -> OpenAlexWork:
+        ids = data.get("ids") or {}
+        
+        # Extract DOI without the https://doi.org/ prefix
+        doi = ids.get("doi")
+        if doi and doi.startswith("https://doi.org/"):
+            doi = doi[16:]
+            
+        # Extract PMID without the url prefix
+        pmid = ids.get("pmid")
+        if pmid and pmid.startswith("https://pubmed.ncbi.nlm.nih.gov/"):
+            pmid = pmid[32:]
+            
+        # Extract PMCID without the url prefix
+        pmcid = ids.get("pmcid")
+        if pmcid and pmcid.startswith("https://www.ncbi.nlm.nih.gov/pmc/articles/"):
+            pmcid = pmcid[42:]
+
+        open_access = data.get("open_access") or {}
+        
+        authors = []
+        for authorship in data.get("authorships") or []:
+            author_data = authorship.get("author") or {}
+            authors.append(
+                OpenAlexAuthor(
+                    openalex_id=author_data.get("id"),
+                    display_name=author_data.get("display_name"),
+                )
+            )
+
+        return cls(
+            openalex_id=data.get("id", ""),
+            doi=doi,
+            pmid=pmid,
+            pmcid=pmcid,
+            title=data.get("title"),
+            publication_year=data.get("publication_year"),
+            cited_by_count=data.get("cited_by_count", 0),
+            is_oa=bool(open_access.get("is_oa")),
+            oa_url=open_access.get("oa_url"),
+            authors=authors,
+            raw_data=dict(data),
+        )
diff --git a/build/lib/app/services/domains/portability/__init__.py b/build/lib/app/services/domains/portability/__init__.py
new file mode 100644
index 0000000..28aae8b
--- /dev/null
+++ b/build/lib/app/services/domains/portability/__init__.py
@@ -0,0 +1 @@
+from app.services.domains.portability.application import *
diff --git a/build/lib/app/services/domains/portability/application.py b/build/lib/app/services/domains/portability/application.py
new file mode 100644
index 0000000..7e0b56e
--- /dev/null
+++ b/build/lib/app/services/domains/portability/application.py
@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import Publication
+from app.services.domains.portability.constants import (
+    EXPORT_SCHEMA_VERSION,
+    MAX_IMPORT_PUBLICATIONS,
+    MAX_IMPORT_SCHOLARS,
+)
+from app.services.domains.portability.exporting import export_user_data
+from app.services.domains.portability.normalize import _validate_import_sizes
+from app.services.domains.portability.publication_import import (
+    _build_imported_publication_input,
+    _initialize_import_counters,
+    _upsert_imported_publication,
+)
+from app.services.domains.portability.scholar_import import _upsert_imported_scholars
+from app.services.domains.portability.types import ImportExportError, ImportedPublicationInput
+
+
+async def import_user_data(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholars: list[dict[str, Any]],
+    publications: list[dict[str, Any]],
+) -> dict[str, int]:
+    _validate_import_sizes(scholars=scholars, publications=publications)
+    scholar_map, counters = await _upsert_imported_scholars(
+        db_session,
+        user_id=user_id,
+        scholars=scholars,
+    )
+    cluster_cache: dict[str, Publication | None] = {}
+    fingerprint_cache: dict[str, Publication | None] = {}
+    _initialize_import_counters(counters)
+    for item in publications:
+        parsed_item = _build_imported_publication_input(
+            item=item,
+            scholar_map=scholar_map,
+        )
+        if parsed_item is None:
+            counters["skipped_records"] += 1
+            continue
+        await _upsert_imported_publication(
+            db_session,
+            payload=parsed_item,
+            cluster_cache=cluster_cache,
+            fingerprint_cache=fingerprint_cache,
+            counters=counters,
+        )
+    await db_session.commit()
+    return counters
+
+
+__all__ = [
+    "EXPORT_SCHEMA_VERSION",
+    "MAX_IMPORT_SCHOLARS",
+    "MAX_IMPORT_PUBLICATIONS",
+    "ImportExportError",
+    "ImportedPublicationInput",
+    "export_user_data",
+    "import_user_data",
+]
diff --git a/build/lib/app/services/domains/portability/constants.py b/build/lib/app/services/domains/portability/constants.py
new file mode 100644
index 0000000..6815347
--- /dev/null
+++ b/build/lib/app/services/domains/portability/constants.py
@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import re
+
+EXPORT_SCHEMA_VERSION = 1
+MAX_IMPORT_SCHOLARS = 10_000
+MAX_IMPORT_PUBLICATIONS = 100_000
+WORD_RE = re.compile(r"[a-z0-9]+")
+SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
diff --git a/build/lib/app/services/domains/portability/exporting.py b/build/lib/app/services/domains/portability/exporting.py
new file mode 100644
index 0000000..5c89006
--- /dev/null
+++ b/build/lib/app/services/domains/portability/exporting.py
@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import Publication, ScholarProfile, ScholarPublication
+from app.services.domains.portability.constants import EXPORT_SCHEMA_VERSION
+
+
+def _exported_at_iso() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def _serialize_export_scholar(profile: ScholarProfile) -> dict[str, Any]:
+    return {
+        "scholar_id": profile.scholar_id,
+        "display_name": profile.display_name,
+        "is_enabled": bool(profile.is_enabled),
+        "profile_image_override_url": profile.profile_image_override_url,
+    }
+
+
+def _serialize_export_publication(row: tuple[Any, ...]) -> dict[str, Any]:
+    (
+        scholar_id,
+        cluster_id,
+        fingerprint_sha256,
+        title_raw,
+        year,
+        citation_count,
+        author_text,
+        venue_text,
+        pub_url,
+        pdf_url,
+        is_read,
+    ) = row
+    return {
+        "scholar_id": scholar_id,
+        "cluster_id": cluster_id,
+        "fingerprint_sha256": fingerprint_sha256,
+        "title": title_raw,
+        "year": year,
+        "citation_count": int(citation_count or 0),
+        "author_text": author_text,
+        "venue_text": venue_text,
+        "pub_url": pub_url,
+        "pdf_url": pdf_url,
+        "is_read": bool(is_read),
+    }
+
+
+async def export_user_data(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+) -> dict[str, Any]:
+    scholars_result = await db_session.execute(
+        select(ScholarProfile)
+        .where(ScholarProfile.user_id == user_id)
+        .order_by(ScholarProfile.id.asc())
+    )
+    publication_result = await db_session.execute(
+        select(
+            ScholarProfile.scholar_id,
+            Publication.cluster_id,
+            Publication.fingerprint_sha256,
+            Publication.title_raw,
+            Publication.year,
+            Publication.citation_count,
+            Publication.author_text,
+            Publication.venue_text,
+            Publication.pub_url,
+            Publication.pdf_url,
+            ScholarPublication.is_read,
+        )
+        .join(ScholarPublication, ScholarPublication.scholar_profile_id == ScholarProfile.id)
+        .join(Publication, Publication.id == ScholarPublication.publication_id)
+        .where(ScholarProfile.user_id == user_id)
+        .order_by(ScholarPublication.created_at.desc(), Publication.id.desc())
+    )
+    scholars = [_serialize_export_scholar(profile) for profile in scholars_result.scalars().all()]
+    publications = [_serialize_export_publication(row) for row in publication_result.all()]
+    return {
+        "schema_version": EXPORT_SCHEMA_VERSION,
+        "exported_at": _exported_at_iso(),
+        "scholars": scholars,
+        "publications": publications,
+    }
diff --git a/build/lib/app/services/domains/portability/normalize.py b/build/lib/app/services/domains/portability/normalize.py
new file mode 100644
index 0000000..60dd619
--- /dev/null
+++ b/build/lib/app/services/domains/portability/normalize.py
@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import hashlib
+from typing import Any
+
+from app.services.domains.ingestion.application import normalize_title
+from app.services.domains.portability.constants import (
+    MAX_IMPORT_PUBLICATIONS,
+    MAX_IMPORT_SCHOLARS,
+    SHA256_RE,
+    WORD_RE,
+)
+from app.services.domains.portability.types import ImportExportError
+
+
+def _normalize_optional_text(value: Any) -> str | None:
+    if value is None:
+        return None
+    normalized = str(value).strip()
+    return normalized or None
+
+
+def _normalize_optional_year(value: Any) -> int | None:
+    if value is None:
+        return None
+    try:
+        year = int(value)
+    except (TypeError, ValueError):
+        return None
+    if year < 1500 or year > 3000:
+        return None
+    return year
+
+
+def _normalize_citation_count(value: Any) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return 0
+    return max(0, parsed)
+
+
+def _first_author_last_name(authors_text: str | None) -> str:
+    if not authors_text:
+        return ""
+    first_author = authors_text.split(",", maxsplit=1)[0].strip().lower()
+    words = WORD_RE.findall(first_author)
+    if not words:
+        return ""
+    return words[-1]
+
+
+def _first_venue_word(venue_text: str | None) -> str:
+    if not venue_text:
+        return ""
+    words = WORD_RE.findall(venue_text.lower())
+    if not words:
+        return ""
+    return words[0]
+
+
+def _build_fingerprint(
+    *,
+    title: str,
+    year: int | None,
+    author_text: str | None,
+    venue_text: str | None,
+) -> str:
+    canonical = "|".join(
+        [
+            normalize_title(title),
+            str(year) if year is not None else "",
+            _first_author_last_name(author_text),
+            _first_venue_word(venue_text),
+        ]
+    )
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def _resolve_fingerprint(
+    *,
+    title: str,
+    year: int | None,
+    author_text: str | None,
+    venue_text: str | None,
+    provided_fingerprint: Any,
+) -> str:
+    normalized = _normalize_optional_text(provided_fingerprint)
+    if normalized and SHA256_RE.fullmatch(normalized.lower()):
+        return normalized.lower()
+    return _build_fingerprint(
+        title=title,
+        year=year,
+        author_text=author_text,
+        venue_text=venue_text,
+    )
+
+
+def _validate_import_sizes(
+    *,
+    scholars: list[dict[str, Any]],
+    publications: list[dict[str, Any]],
+) -> None:
+    if len(scholars) > MAX_IMPORT_SCHOLARS:
+        raise ImportExportError(f"Import exceeds max scholars ({MAX_IMPORT_SCHOLARS}).")
+    if len(publications) > MAX_IMPORT_PUBLICATIONS:
+        raise ImportExportError(
+            f"Import exceeds max publications ({MAX_IMPORT_PUBLICATIONS})."
+        )
diff --git a/build/lib/app/services/domains/portability/publication_import.py b/build/lib/app/services/domains/portability/publication_import.py
new file mode 100644
index 0000000..7654586
--- /dev/null
+++ b/build/lib/app/services/domains/portability/publication_import.py
@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import Publication, ScholarProfile, ScholarPublication
+from app.services.domains.ingestion.application import build_publication_url, normalize_title
+from app.services.domains.doi.normalize import normalize_doi
+from app.services.domains.portability.normalize import (
+    _normalize_citation_count,
+    _normalize_optional_text,
+    _normalize_optional_year,
+    _resolve_fingerprint,
+)
+from app.services.domains.portability.types import ImportedPublicationInput
+
+
+async def _find_publication_by_cluster(
+    db_session: AsyncSession,
+    *,
+    cluster_id: str,
+) -> Publication | None:
+    result = await db_session.execute(
+        select(Publication).where(Publication.cluster_id == cluster_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def _find_publication_by_fingerprint(
+    db_session: AsyncSession,
+    *,
+    fingerprint_sha256: str,
+) -> Publication | None:
+    result = await db_session.execute(
+        select(Publication).where(Publication.fingerprint_sha256 == fingerprint_sha256)
+    )
+    return result.scalar_one_or_none()
+
+
+async def _find_linked_publication_by_title(
+    db_session: AsyncSession,
+    *,
+    scholar_profile_id: int,
+    title: str,
+) -> Publication | None:
+    normalized_title = normalize_title(title)
+    result = await db_session.execute(
+        select(Publication)
+        .join(
+            ScholarPublication,
+            ScholarPublication.publication_id == Publication.id,
+        )
+        .where(
+            ScholarPublication.scholar_profile_id == scholar_profile_id,
+            Publication.title_normalized == normalized_title,
+        )
+        .order_by(Publication.id.asc())
+        .limit(1)
+    )
+    return result.scalar_one_or_none()
+
+
+def _apply_imported_publication_values(
+    *,
+    publication: Publication,
+    title: str,
+    year: int | None,
+    citation_count: int,
+    author_text: str | None,
+    venue_text: str | None,
+    pub_url: str | None,
+    pdf_url: str | None,
+    cluster_id: str | None,
+) -> bool:
+    updated = False
+    if cluster_id and publication.cluster_id != cluster_id:
+        publication.cluster_id = cluster_id
+        updated = True
+    if publication.title_raw != title:
+        publication.title_raw = title
+        publication.title_normalized = normalize_title(title)
+        updated = True
+    if publication.year != year:
+        publication.year = year
+        updated = True
+    if int(publication.citation_count or 0) != citation_count:
+        publication.citation_count = citation_count
+        updated = True
+    if publication.author_text != author_text:
+        publication.author_text = author_text
+        updated = True
+    if publication.venue_text != venue_text:
+        publication.venue_text = venue_text
+        updated = True
+    if pub_url and publication.pub_url != pub_url:
+        publication.pub_url = pub_url
+        updated = True
+    if pdf_url and publication.pdf_url != pdf_url:
+        publication.pdf_url = pdf_url
+        updated = True
+    return updated
+
+
+def _new_publication(
+    *,
+    cluster_id: str | None,
+    fingerprint_sha256: str,
+    title: str,
+    year: int | None,
+    citation_count: int,
+    author_text: str | None,
+    venue_text: str | None,
+    pub_url: str | None,
+    pdf_url: str | None,
+) -> Publication:
+    return Publication(
+        cluster_id=cluster_id,
+        fingerprint_sha256=fingerprint_sha256,
+        title_raw=title,
+        title_normalized=normalize_title(title),
+        year=year,
+        citation_count=citation_count,
+        author_text=author_text,
+        venue_text=venue_text,
+        pub_url=pub_url,
+        pdf_url=pdf_url,
+    )
+
+
+async def _resolve_publication_for_import(
+    db_session: AsyncSession,
+    *,
+    scholar_profile_id: int,
+    title: str,
+    cluster_id: str | None,
+    fingerprint_sha256: str,
+    cluster_cache: dict[str, Publication | None],
+    fingerprint_cache: dict[str, Publication | None],
+) -> Publication | None:
+    if cluster_id:
+        if cluster_id not in cluster_cache:
+            cluster_cache[cluster_id] = await _find_publication_by_cluster(
+                db_session,
+                cluster_id=cluster_id,
+            )
+        if cluster_cache[cluster_id] is not None:
+            return cluster_cache[cluster_id]
+    if fingerprint_sha256 not in fingerprint_cache:
+        fingerprint_cache[fingerprint_sha256] = await _find_publication_by_fingerprint(
+            db_session,
+            fingerprint_sha256=fingerprint_sha256,
+        )
+    if fingerprint_cache[fingerprint_sha256] is not None:
+        return fingerprint_cache[fingerprint_sha256]
+    return await _find_linked_publication_by_title(
+        db_session,
+        scholar_profile_id=scholar_profile_id,
+        title=title,
+    )
+
+
+async def _upsert_scholar_publication_link(
+    db_session: AsyncSession,
+    *,
+    scholar_profile_id: int,
+    publication_id: int,
+    is_read: bool,
+) -> tuple[bool, bool]:
+    result = await db_session.execute(
+        select(ScholarPublication).where(
+            ScholarPublication.scholar_profile_id == scholar_profile_id,
+            ScholarPublication.publication_id == publication_id,
+        )
+    )
+    link = result.scalar_one_or_none()
+    if link is None:
+        db_session.add(
+            ScholarPublication(
+                scholar_profile_id=scholar_profile_id,
+                publication_id=publication_id,
+                is_read=bool(is_read),
+            )
+        )
+        return True, False
+    if bool(link.is_read) == bool(is_read):
+        return False, False
+    link.is_read = bool(is_read)
+    return False, True
+
+
+def _initialize_import_counters(counters: dict[str, int]) -> None:
+    counters.update(
+        {
+            "publications_created": 0,
+            "publications_updated": 0,
+            "links_created": 0,
+            "links_updated": 0,
+        }
+    )
+
+
+def _build_imported_publication_input(
+    *,
+    item: dict[str, Any],
+    scholar_map: dict[str, ScholarProfile],
+) -> ImportedPublicationInput | None:
+    scholar_id = _normalize_optional_text(item.get("scholar_id"))
+    title = _normalize_optional_text(item.get("title"))
+    if not scholar_id or not title:
+        return None
+
+    profile = scholar_map.get(scholar_id)
+    if profile is None:
+        return None
+
+    year = _normalize_optional_year(item.get("year"))
+    author_text = _normalize_optional_text(item.get("author_text"))
+    venue_text = _normalize_optional_text(item.get("venue_text"))
+    return ImportedPublicationInput(
+        profile=profile,
+        title=title,
+        year=year,
+        citation_count=_normalize_citation_count(item.get("citation_count")),
+        author_text=author_text,
+        venue_text=venue_text,
+        cluster_id=_normalize_optional_text(item.get("cluster_id")),
+        pub_url=build_publication_url(_normalize_optional_text(item.get("pub_url"))),
+        doi=normalize_doi(_normalize_optional_text(item.get("doi"))),
+        pdf_url=build_publication_url(_normalize_optional_text(item.get("pdf_url"))),
+        fingerprint=_resolve_fingerprint(
+            title=title,
+            year=year,
+            author_text=author_text,
+            venue_text=venue_text,
+            provided_fingerprint=item.get("fingerprint_sha256"),
+        ),
+        is_read=bool(item.get("is_read", False)),
+    )
+
+
+def _update_link_counters(
+    *,
+    counters: dict[str, int],
+    link_created: bool,
+    link_updated: bool,
+) -> None:
+    if link_created:
+        counters["links_created"] += 1
+    if link_updated:
+        counters["links_updated"] += 1
+
+
+def _cache_resolved_publication(
+    *,
+    publication: Publication,
+    cluster_id: str | None,
+    fingerprint_sha256: str,
+    cluster_cache: dict[str, Publication | None],
+    fingerprint_cache: dict[str, Publication | None],
+) -> None:
+    if cluster_id:
+        cluster_cache[cluster_id] = publication
+    fingerprint_cache[fingerprint_sha256] = publication
+
+
+async def _create_import_publication(
+    db_session: AsyncSession,
+    *,
+    payload: ImportedPublicationInput,
+) -> Publication:
+    publication = _new_publication(
+        cluster_id=payload.cluster_id,
+        fingerprint_sha256=payload.fingerprint,
+        title=payload.title,
+        year=payload.year,
+        citation_count=payload.citation_count,
+        author_text=payload.author_text,
+        venue_text=payload.venue_text,
+        pub_url=payload.pub_url,
+        pdf_url=payload.pdf_url,
+    )
+    db_session.add(publication)
+    await db_session.flush()
+    return publication
+
+
+def _update_import_publication(
+    *,
+    publication: Publication,
+    payload: ImportedPublicationInput,
+) -> bool:
+    return _apply_imported_publication_values(
+        publication=publication,
+        title=payload.title,
+        year=payload.year,
+        citation_count=payload.citation_count,
+        author_text=payload.author_text,
+        venue_text=payload.venue_text,
+        pub_url=payload.pub_url,
+        pdf_url=payload.pdf_url,
+        cluster_id=payload.cluster_id,
+    )
+
+
+async def _upsert_publication_entity(
+    db_session: AsyncSession,
+    *,
+    payload: ImportedPublicationInput,
+    cluster_cache: dict[str, Publication | None],
+    fingerprint_cache: dict[str, Publication | None],
+) -> tuple[Publication, bool, bool]:
+    publication = await _resolve_publication_for_import(
+        db_session,
+        scholar_profile_id=int(payload.profile.id),
+        title=payload.title,
+        cluster_id=payload.cluster_id,
+        fingerprint_sha256=payload.fingerprint,
+        cluster_cache=cluster_cache,
+        fingerprint_cache=fingerprint_cache,
+    )
+    created = False
+    updated = False
+    if publication is None:
+        publication = await _create_import_publication(db_session, payload=payload)
+        created = True
+    else:
+        updated = _update_import_publication(publication=publication, payload=payload)
+
+    _cache_resolved_publication(
+        publication=publication,
+        cluster_id=payload.cluster_id,
+        fingerprint_sha256=payload.fingerprint,
+        cluster_cache=cluster_cache,
+        fingerprint_cache=fingerprint_cache,
+    )
+    return publication, created, updated
+
+
+async def _upsert_imported_publication(
+    db_session: AsyncSession,
+    *,
+    payload: ImportedPublicationInput,
+    cluster_cache: dict[str, Publication | None],
+    fingerprint_cache: dict[str, Publication | None],
+    counters: dict[str, int],
+) -> None:
+    publication, created, updated = await _upsert_publication_entity(
+        db_session,
+        payload=payload,
+        cluster_cache=cluster_cache,
+        fingerprint_cache=fingerprint_cache,
+    )
+    if created:
+        counters["publications_created"] += 1
+    if updated:
+        counters["publications_updated"] += 1
+
+    link_created, link_updated = await _upsert_scholar_publication_link(
+        db_session,
+        scholar_profile_id=int(payload.profile.id),
+        publication_id=int(publication.id),
+        is_read=payload.is_read,
+    )
+    _update_link_counters(
+        counters=counters,
+        link_created=link_created,
+        link_updated=link_updated,
+    )
diff --git a/build/lib/app/services/domains/portability/scholar_import.py b/build/lib/app/services/domains/portability/scholar_import.py
new file mode 100644
index 0000000..74e6ec1
--- /dev/null
+++ b/build/lib/app/services/domains/portability/scholar_import.py
@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import ScholarProfile
+from app.services.domains.portability.normalize import _normalize_optional_text
+from app.services.domains.scholars import application as scholar_service
+
+
+async def _load_user_scholar_map(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+) -> dict[str, ScholarProfile]:
+    result = await db_session.execute(
+        select(ScholarProfile).where(ScholarProfile.user_id == user_id)
+    )
+    profiles = list(result.scalars().all())
+    return {profile.scholar_id: profile for profile in profiles}
+
+
+def _apply_imported_scholar_values(
+    *,
+    profile: ScholarProfile,
+    display_name: str | None,
+    profile_image_override_url: str | None,
+    is_enabled: bool,
+) -> bool:
+    updated = False
+    if display_name and profile.display_name != display_name:
+        profile.display_name = display_name
+        updated = True
+    if profile.profile_image_override_url != profile_image_override_url:
+        profile.profile_image_override_url = profile_image_override_url
+        updated = True
+    if bool(profile.is_enabled) != bool(is_enabled):
+        profile.is_enabled = bool(is_enabled)
+        updated = True
+    return updated
+
+
+def _new_scholar_profile(
+    *,
+    user_id: int,
+    scholar_id: str,
+    display_name: str | None,
+    profile_image_override_url: str | None,
+    is_enabled: bool,
+) -> ScholarProfile:
+    return ScholarProfile(
+        user_id=user_id,
+        scholar_id=scholar_id,
+        display_name=display_name,
+        profile_image_override_url=profile_image_override_url,
+        is_enabled=bool(is_enabled),
+    )
+
+
+async def _upsert_imported_scholars(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholars: list[dict[str, Any]],
+) -> tuple[dict[str, ScholarProfile], dict[str, int]]:
+    scholar_map = await _load_user_scholar_map(db_session, user_id=user_id)
+    counters = {"scholars_created": 0, "scholars_updated": 0, "skipped_records": 0}
+    for item in scholars:
+        try:
+            scholar_id = scholar_service.validate_scholar_id(str(item["scholar_id"]))
+            display_name = scholar_service.normalize_display_name(
+                str(item.get("display_name") or "")
+            )
+            override_url = scholar_service.normalize_profile_image_url(
+                _normalize_optional_text(item.get("profile_image_override_url"))
+            )
+        except (KeyError, scholar_service.ScholarServiceError):
+            counters["skipped_records"] += 1
+            continue
+
+        is_enabled = bool(item.get("is_enabled", True))
+        existing = scholar_map.get(scholar_id)
+        if existing is None:
+            profile = _new_scholar_profile(
+                user_id=user_id,
+                scholar_id=scholar_id,
+                display_name=display_name,
+                profile_image_override_url=override_url,
+                is_enabled=is_enabled,
+            )
+            db_session.add(profile)
+            scholar_map[scholar_id] = profile
+            counters["scholars_created"] += 1
+            continue
+
+        if _apply_imported_scholar_values(
+            profile=existing,
+            display_name=display_name,
+            profile_image_override_url=override_url,
+            is_enabled=is_enabled,
+        ):
+            counters["scholars_updated"] += 1
+
+    await db_session.flush()
+    return scholar_map, counters
diff --git a/build/lib/app/services/domains/portability/types.py b/build/lib/app/services/domains/portability/types.py
new file mode 100644
index 0000000..2a7f6e8
--- /dev/null
+++ b/build/lib/app/services/domains/portability/types.py
@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from app.db.models import ScholarProfile
+
+
+class ImportExportError(ValueError):
+    """Raised when import/export payload constraints are violated."""
+
+
+@dataclass(frozen=True)
+class ImportedPublicationInput:
+    profile: ScholarProfile
+    title: str
+    year: int | None
+    citation_count: int
+    author_text: str | None
+    venue_text: str | None
+    cluster_id: str | None
+    pub_url: str | None
+    doi: str | None
+    pdf_url: str | None
+    fingerprint: str
+    is_read: bool
diff --git a/build/lib/app/services/domains/publication_identifiers/__init__.py b/build/lib/app/services/domains/publication_identifiers/__init__.py
new file mode 100644
index 0000000..3a35c66
--- /dev/null
+++ b/build/lib/app/services/domains/publication_identifiers/__init__.py
@@ -0,0 +1,17 @@
+from app.services.domains.publication_identifiers.application import (
+    DisplayIdentifier,
+    derive_display_identifier_from_values,
+    overlay_pdf_queue_items_with_display_identifiers,
+    overlay_publication_items_with_display_identifiers,
+    sync_identifiers_for_publication_fields,
+    sync_identifiers_for_publication_resolution,
+)
+
+__all__ = [
+    "DisplayIdentifier",
+    "derive_display_identifier_from_values",
+    "overlay_pdf_queue_items_with_display_identifiers",
+    "overlay_publication_items_with_display_identifiers",
+    "sync_identifiers_for_publication_fields",
+    "sync_identifiers_for_publication_resolution",
+]
diff --git a/build/lib/app/services/domains/publication_identifiers/application.py b/build/lib/app/services/domains/publication_identifiers/application.py
new file mode 100644
index 0000000..ca57d57
--- /dev/null
+++ b/build/lib/app/services/domains/publication_identifiers/application.py
@@ -0,0 +1,433 @@
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import TYPE_CHECKING
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import Publication, PublicationIdentifier
+from app.services.domains.doi.normalize import normalize_doi
+from app.services.domains.publication_identifiers.normalize import (
+    normalize_arxiv_id,
+    normalize_pmcid,
+    normalize_pmid,
+)
+from app.services.domains.publication_identifiers.types import (
+    DisplayIdentifier,
+    IdentifierCandidate,
+    IdentifierKind,
+)
+
+if TYPE_CHECKING:
+    from app.services.domains.publications.pdf_queue import PdfQueueListItem
+    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+
+CONFIDENCE_HIGH = 0.98
+CONFIDENCE_MEDIUM = 0.9
+CONFIDENCE_LOW = 0.6
+CONFIDENCE_FALLBACK = 0.4
+PRIORITY_DOI = 400
+PRIORITY_ARXIV = 300
+PRIORITY_PMCID = 200
+PRIORITY_PMID = 100
+
+
+def derive_display_identifier_from_values(
+    *,
+    doi: str | None,
+    pub_url: str | None = None,
+    pdf_url: str | None = None,
+) -> DisplayIdentifier | None:
+    candidates = _fallback_candidates_from_values(doi=doi, pub_url=pub_url, pdf_url=pdf_url)
+    return _best_display_identifier(candidates)
+
+
+def _fallback_candidates_from_values(
+    *,
+    doi: str | None,
+    pub_url: str | None,
+    pdf_url: str | None,
+) -> list[IdentifierCandidate]:
+    values = [value for value in [pub_url, pdf_url] if value]
+    candidates = []
+    if doi:
+        normalized_doi = normalize_doi(doi)
+        if normalized_doi:
+            candidates.append(_candidate(IdentifierKind.DOI, doi, normalized_doi, "legacy_doi", CONFIDENCE_HIGH, pub_url))
+    candidates.extend(_url_identifier_candidates(values=values, source="legacy_urls"))
+    return _dedup_candidates(candidates)
+
+
+def _url_identifier_candidates(*, values: list[str], source: str) -> list[IdentifierCandidate]:
+    candidates: list[IdentifierCandidate] = []
+    for value in values:
+        candidates.extend(_url_candidates_for_value(value=value, source=source))
+    return candidates
+
+
+def _url_candidates_for_value(*, value: str, source: str) -> list[IdentifierCandidate]:
+    candidates: list[IdentifierCandidate] = []
+    arxiv = normalize_arxiv_id(value)
+    if arxiv:
+        candidates.append(_candidate(IdentifierKind.ARXIV, value, arxiv, source, CONFIDENCE_MEDIUM, value))
+    pmcid = normalize_pmcid(value)
+    if pmcid:
+        candidates.append(_candidate(IdentifierKind.PMCID, value, pmcid, source, CONFIDENCE_LOW, value))
+    pmid = normalize_pmid(value)
+    if pmid:
+        candidates.append(_candidate(IdentifierKind.PMID, value, pmid, source, CONFIDENCE_FALLBACK, value))
+    return candidates
+
+
+def _candidate(
+    kind: IdentifierKind,
+    value_raw: str,
+    value_normalized: str,
+    source: str,
+    confidence_score: float,
+    evidence_url: str | None,
+) -> IdentifierCandidate:
+    return IdentifierCandidate(
+        kind=kind,
+        value_raw=value_raw,
+        value_normalized=value_normalized,
+        source=source,
+        confidence_score=float(confidence_score),
+        evidence_url=evidence_url,
+    )
+
+
+def _dedup_candidates(candidates: list[IdentifierCandidate]) -> list[IdentifierCandidate]:
+    deduped: dict[tuple[str, str], IdentifierCandidate] = {}
+    for candidate in candidates:
+        key = (candidate.kind.value, candidate.value_normalized)
+        current = deduped.get(key)
+        if current is None or candidate.confidence_score > current.confidence_score:
+            deduped[key] = candidate
+    return list(deduped.values())
+
+
+async def sync_identifiers_for_publication_fields(
+    db_session: AsyncSession,
+    *,
+    publication: Publication,
+) -> None:
+    candidates = _publication_field_candidates(publication)
+    await _upsert_publication_candidates(db_session, publication_id=int(publication.id), candidates=candidates)
+
+
+async def discover_and_sync_identifiers_for_publication(
+    db_session: AsyncSession,
+    *,
+    publication: Publication,
+    scholar_label: str,
+) -> None:
+    await sync_identifiers_for_publication_fields(db_session, publication=publication)
+    
+    existing_doi = await _existing_identifier_by_kind(
+        db_session,
+        publication_id=int(publication.id),
+        kind=IdentifierKind.DOI.value,
+    )
+    if existing_doi is not None:
+        return
+
+    from app.services.domains.crossref import application as crossref_service
+    from app.services.domains.publications.types import UnreadPublicationItem
+    
+    item = UnreadPublicationItem(
+        publication_id=int(publication.id),
+        scholar_profile_id=0,
+        scholar_label=scholar_label,
+        title=str(publication.title_raw or ""),
+        year=publication.year,
+        citation_count=publication.citation_count,
+        venue_text=publication.venue_text,
+        pub_url=publication.pub_url,
+        pdf_url=publication.pdf_url,
+    )
+    
+    discovered_doi = await crossref_service.discover_doi_for_publication(item=item)
+    if discovered_doi:
+        normalized_doi = normalize_doi(discovered_doi)
+        if normalized_doi:
+            candidate = _candidate(
+                IdentifierKind.DOI,
+                discovered_doi,
+                normalized_doi,
+                "crossref_api",
+                CONFIDENCE_MEDIUM,
+                None,
+            )
+            await _upsert_publication_candidate(db_session, publication_id=int(publication.id), candidate=candidate)
+
+    existing_arxiv = await _existing_identifier_by_kind(
+        db_session,
+        publication_id=int(publication.id),
+        kind=IdentifierKind.ARXIV.value,
+    )
+    if existing_arxiv is None:
+        from app.services.domains.arxiv import application as arxiv_service
+        discovered_arxiv = await arxiv_service.discover_arxiv_id_for_publication(item=item)
+        if discovered_arxiv:
+            normalized_arxiv = normalize_arxiv_id(discovered_arxiv)
+            if normalized_arxiv:
+                candidate = _candidate(
+                    IdentifierKind.ARXIV,
+                    discovered_arxiv,
+                    normalized_arxiv,
+                    "arxiv_api",
+                    CONFIDENCE_MEDIUM,
+                    None,
+                )
+                await _upsert_publication_candidate(db_session, publication_id=int(publication.id), candidate=candidate)
+
+
+def _publication_field_candidates(publication: Publication) -> list[IdentifierCandidate]:
+    return _fallback_candidates_from_values(
+        doi=None,
+        pub_url=publication.pub_url,
+        pdf_url=publication.pdf_url,
+    )
+
+
+async def sync_identifiers_for_publication_resolution(
+    db_session: AsyncSession,
+    *,
+    publication: Publication,
+    source: str | None,
+) -> None:
+    candidates = _publication_field_candidates(publication)
+    rewritten = [_candidate_with_source(candidate, source=source) for candidate in candidates]
+    await _upsert_publication_candidates(db_session, publication_id=int(publication.id), candidates=rewritten)
+
+
+def _candidate_with_source(candidate: IdentifierCandidate, *, source: str | None) -> IdentifierCandidate:
+    if not source:
+        return candidate
+    return IdentifierCandidate(
+        kind=candidate.kind,
+        value_raw=candidate.value_raw,
+        value_normalized=candidate.value_normalized,
+        source=source,
+        confidence_score=candidate.confidence_score,
+        evidence_url=candidate.evidence_url,
+    )
+
+
+async def _upsert_publication_candidates(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    candidates: list[IdentifierCandidate],
+) -> None:
+    for candidate in _dedup_candidates(candidates):
+        await _upsert_publication_candidate(db_session, publication_id=publication_id, candidate=candidate)
+
+
+async def _upsert_publication_candidate(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    candidate: IdentifierCandidate,
+) -> None:
+    existing = await _existing_identifier(
+        db_session,
+        publication_id=publication_id,
+        kind=candidate.kind.value,
+        value_normalized=candidate.value_normalized,
+    )
+    if existing is None:
+        db_session.add(_new_identifier_row(publication_id=publication_id, candidate=candidate))
+        return
+    _merge_identifier_row(existing, candidate=candidate)
+
+
+async def _existing_identifier(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    kind: str,
+    value_normalized: str,
+) -> PublicationIdentifier | None:
+    result = await db_session.execute(
+        select(PublicationIdentifier).where(
+            PublicationIdentifier.publication_id == publication_id,
+            PublicationIdentifier.kind == kind,
+            PublicationIdentifier.value_normalized == value_normalized,
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+async def _existing_identifier_by_kind(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    kind: str,
+) -> PublicationIdentifier | None:
+    result = await db_session.execute(
+        select(PublicationIdentifier).where(
+            PublicationIdentifier.publication_id == publication_id,
+            PublicationIdentifier.kind == kind,
+        ).order_by(PublicationIdentifier.confidence_score.desc()).limit(1)
+    )
+    return result.scalar_one_or_none()
+
+
+def _new_identifier_row(
+    *,
+    publication_id: int,
+    candidate: IdentifierCandidate,
+) -> PublicationIdentifier:
+    return PublicationIdentifier(
+        publication_id=publication_id,
+        kind=candidate.kind.value,
+        value_raw=candidate.value_raw,
+        value_normalized=candidate.value_normalized,
+        source=candidate.source,
+        confidence_score=candidate.confidence_score,
+        evidence_url=candidate.evidence_url,
+    )
+
+
+def _merge_identifier_row(existing: PublicationIdentifier, *, candidate: IdentifierCandidate) -> None:
+    if candidate.confidence_score >= float(existing.confidence_score):
+        existing.value_raw = candidate.value_raw
+        existing.source = candidate.source
+        existing.confidence_score = candidate.confidence_score
+        if candidate.evidence_url:
+            existing.evidence_url = candidate.evidence_url
+
+
+async def overlay_publication_items_with_display_identifiers(
+    db_session: AsyncSession,
+    *,
+    items: list[PublicationListItem],
+) -> list[PublicationListItem]:
+    if not items:
+        return []
+    mapping = await _display_identifier_map(db_session, publication_ids=[item.publication_id for item in items])
+    return [_overlay_publication_item(item, mapping.get(item.publication_id)) for item in items]
+
+
+def _overlay_publication_item(
+    item: PublicationListItem,
+    display_identifier: DisplayIdentifier | None,
+) -> PublicationListItem:
+    fallback = display_identifier or derive_display_identifier_from_values(doi=None, pub_url=item.pub_url, pdf_url=item.pdf_url)
+    return replace(item, display_identifier=fallback)
+
+
+async def overlay_pdf_queue_items_with_display_identifiers(
+    db_session: AsyncSession,
+    *,
+    items: list[PdfQueueListItem],
+) -> list[PdfQueueListItem]:
+    if not items:
+        return []
+    mapping = await _display_identifier_map(db_session, publication_ids=[item.publication_id for item in items])
+    return [_overlay_queue_item(item, mapping.get(item.publication_id)) for item in items]
+
+
+def _overlay_queue_item(
+    item: PdfQueueListItem,
+    display_identifier: DisplayIdentifier | None,
+) -> PdfQueueListItem:
+    fallback = display_identifier or derive_display_identifier_from_values(doi=None, pdf_url=item.pdf_url)
+    return replace(item, display_identifier=fallback)
+
+
+async def _display_identifier_map(
+    db_session: AsyncSession,
+    *,
+    publication_ids: list[int],
+) -> dict[int, DisplayIdentifier]:
+    normalized_ids = sorted({int(value) for value in publication_ids if int(value) > 0})
+    if not normalized_ids:
+        return {}
+    result = await db_session.execute(
+        select(PublicationIdentifier).where(PublicationIdentifier.publication_id.in_(normalized_ids))
+    )
+    rows = list(result.scalars().all())
+    return _best_display_identifier_map(rows)
+
+
+def _best_display_identifier_map(rows: list[PublicationIdentifier]) -> dict[int, DisplayIdentifier]:
+    grouped: dict[int, list[IdentifierCandidate]] = {}
+    for row in rows:
+        grouped.setdefault(int(row.publication_id), []).append(_candidate_from_row(row))
+    return {
+        publication_id: display
+        for publication_id, display in (
+            (publication_id, _best_display_identifier(candidates))
+            for publication_id, candidates in grouped.items()
+        )
+        if display is not None
+    }
+
+
+def _candidate_from_row(row: PublicationIdentifier) -> IdentifierCandidate:
+    return IdentifierCandidate(
+        kind=IdentifierKind(str(row.kind)),
+        value_raw=str(row.value_raw),
+        value_normalized=str(row.value_normalized),
+        source=str(row.source),
+        confidence_score=float(row.confidence_score),
+        evidence_url=row.evidence_url,
+    )
+
+
+def _best_display_identifier(candidates: list[IdentifierCandidate]) -> DisplayIdentifier | None:
+    if not candidates:
+        return None
+    ordered = sorted(candidates, key=_display_sort_key, reverse=True)
+    return _display_identifier_from_candidate(ordered[0])
+
+
+def _display_sort_key(candidate: IdentifierCandidate) -> tuple[int, float]:
+    return (_kind_priority(candidate.kind), float(candidate.confidence_score))
+
+
+def _kind_priority(kind: IdentifierKind) -> int:
+    if kind == IdentifierKind.DOI:
+        return PRIORITY_DOI
+    if kind == IdentifierKind.ARXIV:
+        return PRIORITY_ARXIV
+    if kind == IdentifierKind.PMCID:
+        return PRIORITY_PMCID
+    return PRIORITY_PMID
+
+
+def _display_identifier_from_candidate(candidate: IdentifierCandidate) -> DisplayIdentifier:
+    value = candidate.value_normalized
+    return DisplayIdentifier(
+        kind=candidate.kind.value,
+        value=value,
+        label=_display_label(candidate.kind, value),
+        url=_identifier_url(candidate.kind, value),
+        confidence_score=float(candidate.confidence_score),
+    )
+
+
+def _display_label(kind: IdentifierKind, value: str) -> str:
+    if kind == IdentifierKind.DOI:
+        return f"DOI: {value}"
+    if kind == IdentifierKind.ARXIV:
+        return f"arXiv: {value}"
+    if kind == IdentifierKind.PMCID:
+        return f"PMCID: {value}"
+    return f"PMID: {value}"
+
+
+def _identifier_url(kind: IdentifierKind, value: str) -> str | None:
+    if kind == IdentifierKind.DOI:
+        return f"https://doi.org/{value}"
+    if kind == IdentifierKind.ARXIV:
+        return f"https://arxiv.org/abs/{value}"
+    if kind == IdentifierKind.PMCID:
+        return f"https://pmc.ncbi.nlm.nih.gov/articles/{value}/"
+    if kind == IdentifierKind.PMID:
+        return f"https://pubmed.ncbi.nlm.nih.gov/{value}/"
+    return None
diff --git a/build/lib/app/services/domains/publication_identifiers/normalize.py b/build/lib/app/services/domains/publication_identifiers/normalize.py
new file mode 100644
index 0000000..9f7484a
--- /dev/null
+++ b/build/lib/app/services/domains/publication_identifiers/normalize.py
@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import re
+from urllib.parse import urlparse
+
+from app.services.domains.doi.normalize import normalize_doi
+from app.services.domains.publication_identifiers.types import IdentifierKind
+
+ARXIV_ABS_RE = re.compile(r"\barxiv:\s*([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?\b", re.I)
+ARXIV_PATH_RE = re.compile(r"^/(?:abs|pdf|html|ps|format)/([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?(?:\.pdf)?/?$", re.I)
+PMCID_RE = re.compile(r"\b(PMC\d+)\b", re.I)
+PUBMED_PATH_RE = re.compile(r"^/(\d+)/?$")
+
+
+def normalize_identifier(kind: IdentifierKind, value: str | None) -> str | None:
+    if kind == IdentifierKind.DOI:
+        return normalize_doi(value)
+    if kind == IdentifierKind.ARXIV:
+        return normalize_arxiv_id(value)
+    if kind == IdentifierKind.PMCID:
+        return normalize_pmcid(value)
+    if kind == IdentifierKind.PMID:
+        return normalize_pmid(value)
+    return None
+
+
+def normalize_arxiv_id(value: str | None) -> str | None:
+    text = (value or "").strip()
+    if not text:
+        return None
+    parsed = urlparse(text)
+    if parsed.scheme in {"http", "https"} and "arxiv.org" in parsed.netloc.lower():
+        return _arxiv_from_path(parsed.path)
+    match = ARXIV_ABS_RE.search(text)
+    if not match:
+        return None
+    version = (match.group(2) or "").lower()
+    return f"{match.group(1).lower()}{version}"
+
+
+def _arxiv_from_path(path: str) -> str | None:
+    match = ARXIV_PATH_RE.match(path or "")
+    if not match:
+        return None
+    version = (match.group(2) or "").lower()
+    return f"{match.group(1).lower()}{version}"
+
+
+def normalize_pmcid(value: str | None) -> str | None:
+    text = (value or "").strip()
+    if not text:
+        return None
+    parsed = urlparse(text)
+    if parsed.scheme in {"http", "https"} and "ncbi.nlm.nih.gov" in parsed.netloc.lower():
+        return _first_match(PMCID_RE, parsed.path)
+    return _first_match(PMCID_RE, text)
+
+
+def normalize_pmid(value: str | None) -> str | None:
+    text = (value or "").strip()
+    if not text:
+        return None
+    parsed = urlparse(text)
+    if parsed.scheme in {"http", "https"} and "pubmed.ncbi.nlm.nih.gov" in parsed.netloc.lower():
+        match = PUBMED_PATH_RE.match(parsed.path or "")
+        if not match:
+            return None
+        return match.group(1)
+    return None
+
+
+def _first_match(pattern: re.Pattern[str], value: str) -> str | None:
+    match = pattern.search(value)
+    if not match:
+        return None
+    return match.group(1).upper()
diff --git a/build/lib/app/services/domains/publication_identifiers/types.py b/build/lib/app/services/domains/publication_identifiers/types.py
new file mode 100644
index 0000000..34b20d0
--- /dev/null
+++ b/build/lib/app/services/domains/publication_identifiers/types.py
@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class IdentifierKind(StrEnum):
+    DOI = "doi"
+    ARXIV = "arxiv"
+    PMCID = "pmcid"
+    PMID = "pmid"
+
+
+@dataclass(frozen=True)
+class DisplayIdentifier:
+    kind: str
+    value: str
+    label: str
+    url: str | None
+    confidence_score: float
+
+
+@dataclass(frozen=True)
+class IdentifierCandidate:
+    kind: IdentifierKind
+    value_raw: str
+    value_normalized: str
+    source: str
+    confidence_score: float
+    evidence_url: str | None
diff --git a/build/lib/app/services/domains/publications/__init__.py b/build/lib/app/services/domains/publications/__init__.py
new file mode 100644
index 0000000..371b02c
--- /dev/null
+++ b/build/lib/app/services/domains/publications/__init__.py
@@ -0,0 +1 @@
+from app.services.domains.publications.application import *
diff --git a/build/lib/app/services/domains/publications/application.py b/build/lib/app/services/domains/publications/application.py
new file mode 100644
index 0000000..b1161fb
--- /dev/null
+++ b/build/lib/app/services/domains/publications/application.py
@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from app.services.domains.publications.counts import (
+    count_for_user,
+    count_favorite_for_user,
+    count_latest_for_user,
+    count_unread_for_user,
+)
+from app.services.domains.publications.listing import (
+    list_for_user,
+    retry_pdf_for_user,
+    list_unread_for_user,
+)
+from app.services.domains.publications.enrichment import (
+    hydrate_pdf_enrichment_state,
+    schedule_missing_pdf_enrichment_for_user,
+    schedule_retry_pdf_enrichment_for_row,
+)
+from app.services.domains.publications.modes import (
+    MODE_ALL,
+    MODE_LATEST,
+    MODE_NEW,
+    MODE_UNREAD,
+    resolve_publication_view_mode,
+)
+from app.services.domains.publications.queries import (
+    get_latest_completed_run_id_for_user,
+    get_publication_item_for_user,
+    publications_query,
+)
+from app.services.domains.publications.read_state import (
+    mark_all_unread_as_read_for_user,
+    mark_selected_as_read_for_user,
+    set_publication_favorite_for_user,
+)
+from app.services.domains.publications.pdf_queue import (
+    count_pdf_queue_items,
+    enqueue_all_missing_pdf_jobs,
+    enqueue_retry_pdf_job_for_publication_id,
+    list_pdf_queue_page,
+    list_pdf_queue_items,
+)
+from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+
+__all__ = [
+    "MODE_ALL",
+    "MODE_UNREAD",
+    "MODE_LATEST",
+    "MODE_NEW",
+    "PublicationListItem",
+    "UnreadPublicationItem",
+    "resolve_publication_view_mode",
+    "get_latest_completed_run_id_for_user",
+    "publications_query",
+    "get_publication_item_for_user",
+    "list_for_user",
+    "list_unread_for_user",
+    "retry_pdf_for_user",
+    "hydrate_pdf_enrichment_state",
+    "schedule_retry_pdf_enrichment_for_row",
+    "list_pdf_queue_items",
+    "list_pdf_queue_page",
+    "count_pdf_queue_items",
+    "enqueue_all_missing_pdf_jobs",
+    "enqueue_retry_pdf_job_for_publication_id",
+    "schedule_missing_pdf_enrichment_for_user",
+    "count_for_user",
+    "count_favorite_for_user",
+    "count_unread_for_user",
+    "count_latest_for_user",
+    "mark_all_unread_as_read_for_user",
+    "mark_selected_as_read_for_user",
+    "set_publication_favorite_for_user",
+]
diff --git a/build/lib/app/services/domains/publications/counts.py b/build/lib/app/services/domains/publications/counts.py
new file mode 100644
index 0000000..8f65172
--- /dev/null
+++ b/build/lib/app/services/domains/publications/counts.py
@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import ScholarProfile, ScholarPublication
+from app.services.domains.publications.modes import (
+    MODE_ALL,
+    MODE_LATEST,
+    MODE_UNREAD,
+    resolve_publication_view_mode,
+)
+from app.services.domains.publications.queries import get_latest_completed_run_id_for_user
+
+
+async def count_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    mode: str = MODE_ALL,
+    scholar_profile_id: int | None = None,
+    favorite_only: bool = False,
+) -> int:
+    resolved_mode = resolve_publication_view_mode(mode)
+    latest_run_id = await get_latest_completed_run_id_for_user(db_session, user_id=user_id)
+    stmt = (
+        select(func.count())
+        .select_from(ScholarPublication)
+        .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
+        .where(ScholarProfile.user_id == user_id)
+    )
+    if scholar_profile_id is not None:
+        stmt = stmt.where(ScholarProfile.id == scholar_profile_id)
+    if favorite_only:
+        stmt = stmt.where(ScholarPublication.is_favorite.is_(True))
+    if resolved_mode == MODE_UNREAD:
+        stmt = stmt.where(ScholarPublication.is_read.is_(False))
+    if resolved_mode == MODE_LATEST:
+        if latest_run_id is None:
+            return 0
+        stmt = stmt.where(ScholarPublication.first_seen_run_id == latest_run_id)
+    result = await db_session.execute(stmt)
+    return int(result.scalar_one() or 0)
+
+
+async def count_unread_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int | None = None,
+    favorite_only: bool = False,
+) -> int:
+    return await count_for_user(
+        db_session,
+        user_id=user_id,
+        mode=MODE_UNREAD,
+        scholar_profile_id=scholar_profile_id,
+        favorite_only=favorite_only,
+    )
+
+
+async def count_latest_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int | None = None,
+    favorite_only: bool = False,
+) -> int:
+    return await count_for_user(
+        db_session,
+        user_id=user_id,
+        mode=MODE_LATEST,
+        scholar_profile_id=scholar_profile_id,
+        favorite_only=favorite_only,
+    )
+
+
+async def count_favorite_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int | None = None,
+) -> int:
+    return await count_for_user(
+        db_session,
+        user_id=user_id,
+        mode=MODE_ALL,
+        scholar_profile_id=scholar_profile_id,
+        favorite_only=True,
+    )
diff --git a/build/lib/app/services/domains/publications/enrichment.py b/build/lib/app/services/domains/publications/enrichment.py
new file mode 100644
index 0000000..381107a
--- /dev/null
+++ b/build/lib/app/services/domains/publications/enrichment.py
@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import logging
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.services.domains.publications.pdf_queue import (
+    enqueue_missing_pdf_jobs,
+    enqueue_retry_pdf_job,
+    overlay_pdf_job_state,
+)
+from app.services.domains.publications.types import PublicationListItem
+
+logger = logging.getLogger(__name__)
+
+
+async def schedule_missing_pdf_enrichment_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    request_email: str | None,
+    items: list[PublicationListItem],
+    max_items: int,
+) -> int:
+    queued_ids = await enqueue_missing_pdf_jobs(
+        db_session,
+        user_id=user_id,
+        request_email=request_email,
+        rows=items,
+        max_items=max_items,
+    )
+    logger.info(
+        "publications.enrichment.scheduled",
+        extra={
+            "event": "publications.enrichment.scheduled",
+            "user_id": user_id,
+            "publication_count": len(queued_ids),
+        },
+    )
+    return len(queued_ids)
+
+
+async def schedule_retry_pdf_enrichment_for_row(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    request_email: str | None,
+    item: PublicationListItem,
+) -> bool:
+    queued = await enqueue_retry_pdf_job(
+        db_session,
+        user_id=user_id,
+        request_email=request_email,
+        row=item,
+    )
+    logger.info(
+        "publications.enrichment.retry_scheduled",
+        extra={
+            "event": "publications.enrichment.retry_scheduled",
+            "user_id": user_id,
+            "publication_id": item.publication_id,
+            "queued": queued,
+        },
+    )
+    return queued
+
+
+async def hydrate_pdf_enrichment_state(
+    db_session: AsyncSession,
+    *,
+    items: list[PublicationListItem],
+) -> list[PublicationListItem]:
+    return await overlay_pdf_job_state(db_session, rows=items)
diff --git a/build/lib/app/services/domains/publications/listing.py b/build/lib/app/services/domains/publications/listing.py
new file mode 100644
index 0000000..0d09d4c
--- /dev/null
+++ b/build/lib/app/services/domains/publications/listing.py
@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.services.domains.publication_identifiers import application as identifier_service
+from app.services.domains.publications.modes import (
+    MODE_ALL,
+    MODE_UNREAD,
+    resolve_publication_view_mode,
+)
+from app.services.domains.publications.queries import (
+    get_latest_completed_run_id_for_user,
+    get_publication_item_for_user,
+    publication_list_item_from_row,
+    publications_query,
+    unread_item_from_row,
+)
+from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+
+
+async def list_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    mode: str = MODE_ALL,
+    scholar_profile_id: int | None = None,
+    favorite_only: bool = False,
+    limit: int = 300,
+    offset: int = 0,
+) -> list[PublicationListItem]:
+    resolved_mode = resolve_publication_view_mode(mode)
+    latest_run_id = await get_latest_completed_run_id_for_user(db_session, user_id=user_id)
+    result = await db_session.execute(
+        publications_query(
+            user_id=user_id,
+            mode=resolved_mode,
+            latest_run_id=latest_run_id,
+            scholar_profile_id=scholar_profile_id,
+            favorite_only=favorite_only,
+            limit=limit,
+            offset=offset,
+        )
+    )
+    rows = [
+        publication_list_item_from_row(row, latest_run_id=latest_run_id)
+        for row in result.all()
+    ]
+    return await identifier_service.overlay_publication_items_with_display_identifiers(
+        db_session,
+        items=rows,
+    )
+
+
+async def retry_pdf_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int,
+    publication_id: int,
+) -> PublicationListItem | None:
+    item = await get_publication_item_for_user(
+        db_session,
+        user_id=user_id,
+        scholar_profile_id=scholar_profile_id,
+        publication_id=publication_id,
+    )
+    if item is None:
+        return None
+    hydrated = await identifier_service.overlay_publication_items_with_display_identifiers(
+        db_session,
+        items=[item],
+    )
+    return hydrated[0] if hydrated else item
+
+
+async def list_unread_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    limit: int = 100,
+) -> list[UnreadPublicationItem]:
+    result = await db_session.execute(
+        publications_query(
+            user_id=user_id,
+            mode=MODE_UNREAD,
+            latest_run_id=None,
+            scholar_profile_id=None,
+            favorite_only=False,
+            limit=limit,
+            offset=0,
+        )
+    )
+    return [unread_item_from_row(row) for row in result.all()]
diff --git a/build/lib/app/services/domains/publications/modes.py b/build/lib/app/services/domains/publications/modes.py
new file mode 100644
index 0000000..2975169
--- /dev/null
+++ b/build/lib/app/services/domains/publications/modes.py
@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+MODE_ALL = "all"
+MODE_UNREAD = "unread"
+MODE_LATEST = "latest"
+MODE_NEW = "new"  # compatibility alias for MODE_LATEST
+
+
+def resolve_publication_view_mode(value: str | None) -> str:
+    if value == MODE_UNREAD:
+        return MODE_UNREAD
+    if value in {MODE_LATEST, MODE_NEW}:
+        return MODE_LATEST
+    return MODE_ALL
diff --git a/build/lib/app/services/domains/publications/pdf_queue.py b/build/lib/app/services/domains/publications/pdf_queue.py
new file mode 100644
index 0000000..18ac8d9
--- /dev/null
+++ b/build/lib/app/services/domains/publications/pdf_queue.py
@@ -0,0 +1,915 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from datetime import datetime, timezone
+import logging
+
+from sqlalchemy import Select, func, literal, or_, select, union_all
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import (
+    Publication,
+    PublicationPdfJob,
+    PublicationPdfJobEvent,
+    ScholarProfile,
+    ScholarPublication,
+    User,
+)
+from app.db.session import get_session_factory
+from app.services.domains.publication_identifiers import application as identifier_service
+from app.services.domains.publication_identifiers.types import DisplayIdentifier
+from app.services.domains.publications.pdf_resolution_pipeline import (
+    resolve_publication_pdf_outcome_for_row,
+)
+from app.services.domains.publications.types import PublicationListItem
+from app.services.domains.unpaywall.application import (
+    FAILURE_RESOLUTION_EXCEPTION,
+    OaResolutionOutcome,
+)
+from app.settings import settings
+
+PDF_STATUS_UNTRACKED = "untracked"
+PDF_STATUS_QUEUED = "queued"
+PDF_STATUS_RUNNING = "running"
+PDF_STATUS_RESOLVED = "resolved"
+PDF_STATUS_FAILED = "failed"
+
+PDF_EVENT_QUEUED = "queued"
+PDF_EVENT_ATTEMPT_STARTED = "attempt_started"
+PDF_EVENT_RESOLVED = "resolved"
+PDF_EVENT_FAILED = "failed"
+
+logger = logging.getLogger(__name__)
+_scheduled_tasks: set[asyncio.Task[None]] = set()
+
+
+@dataclass(frozen=True)
+class PdfQueueListItem:
+    publication_id: int
+    title: str
+    pdf_url: str | None
+    status: str
+    attempt_count: int
+    last_failure_reason: str | None
+    last_failure_detail: str | None
+    last_source: str | None
+    requested_by_user_id: int | None
+    requested_by_email: str | None
+    queued_at: datetime | None
+    last_attempt_at: datetime | None
+    resolved_at: datetime | None
+    updated_at: datetime
+    display_identifier: DisplayIdentifier | None = None
+
+
+@dataclass(frozen=True)
+class PdfRequeueResult:
+    publication_exists: bool
+    queued: bool
+
+
+@dataclass(frozen=True)
+class PdfBulkQueueResult:
+    requested_count: int
+    queued_count: int
+
+
+@dataclass(frozen=True)
+class PdfQueuePage:
+    items: list[PdfQueueListItem]
+    total_count: int
+    limit: int
+    offset: int
+
+
+def _utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _publication_ids(rows: list[PublicationListItem]) -> list[int]:
+    return sorted({row.publication_id for row in rows})
+
+
+def _status_from_job(row: PublicationListItem, job: PublicationPdfJob | None) -> str:
+    if row.pdf_url:
+        return PDF_STATUS_RESOLVED
+    if job is None:
+        return PDF_STATUS_UNTRACKED
+    return job.status
+
+
+def _item_from_row_and_job(
+    row: PublicationListItem,
+    job: PublicationPdfJob | None,
+) -> PublicationListItem:
+    return PublicationListItem(
+        publication_id=row.publication_id,
+        scholar_profile_id=row.scholar_profile_id,
+        scholar_label=row.scholar_label,
+        title=row.title,
+        year=row.year,
+        citation_count=row.citation_count,
+        venue_text=row.venue_text,
+        pub_url=row.pub_url,
+        pdf_url=row.pdf_url,
+        is_read=row.is_read,
+        is_favorite=row.is_favorite,
+        first_seen_at=row.first_seen_at,
+        is_new_in_latest_run=row.is_new_in_latest_run,
+        pdf_status=_status_from_job(row, job),
+        pdf_attempt_count=int(job.attempt_count) if job is not None else 0,
+        pdf_failure_reason=job.last_failure_reason if job is not None else None,
+        pdf_failure_detail=job.last_failure_detail if job is not None else None,
+        display_identifier=row.display_identifier,
+    )
+
+
+def _queueable_rows(
+    rows: list[PublicationListItem],
+    *,
+    max_items: int,
+) -> list[PublicationListItem]:
+    bounded = max(0, int(max_items))
+    if bounded == 0:
+        return []
+    candidates = [row for row in rows if not row.pdf_url]
+    return candidates[:bounded]
+
+
+def _bounded_limit(limit: int, *, max_value: int = 500) -> int:
+    return max(1, min(int(limit), max_value))
+
+
+def _bounded_offset(offset: int) -> int:
+    return max(int(offset), 0)
+
+
+def _auto_retry_interval_seconds() -> int:
+    return max(int(settings.pdf_auto_retry_interval_seconds), 1)
+
+
+def _auto_retry_first_interval_seconds() -> int:
+    return max(int(settings.pdf_auto_retry_first_interval_seconds), 1)
+
+
+def _auto_retry_max_attempts() -> int:
+    return max(int(settings.pdf_auto_retry_max_attempts), 1)
+
+
+def _retry_interval_seconds_for_attempt_count(attempt_count: int) -> int:
+    if int(attempt_count) <= 1:
+        return _auto_retry_first_interval_seconds()
+    return _auto_retry_interval_seconds()
+
+
+def _cooldown_active(
+    *,
+    last_attempt_at: datetime | None,
+    attempt_count: int,
+) -> bool:
+    if last_attempt_at is None:
+        return False
+    elapsed = (_utcnow() - last_attempt_at).total_seconds()
+    return elapsed < _retry_interval_seconds_for_attempt_count(int(attempt_count))
+
+
+def _can_enqueue_job(
+    job: PublicationPdfJob | None,
+    *,
+    force_retry: bool,
+) -> bool:
+    if job is None:
+        return True
+    if job.status in {PDF_STATUS_QUEUED, PDF_STATUS_RUNNING}:
+        return False
+    if force_retry:
+        return job.status in {PDF_STATUS_FAILED, PDF_STATUS_RESOLVED, PDF_STATUS_UNTRACKED}
+    if job.status == PDF_STATUS_RESOLVED:
+        return False
+    if int(job.attempt_count) >= _auto_retry_max_attempts():
+        return False
+    if _cooldown_active(
+        last_attempt_at=job.last_attempt_at,
+        attempt_count=int(job.attempt_count),
+    ):
+        return False
+    return True
+
+
+def _event_row(
+    *,
+    publication_id: int,
+    user_id: int | None,
+    event_type: str,
+    status: str | None,
+    source: str | None = None,
+    failure_reason: str | None = None,
+    message: str | None = None,
+) -> PublicationPdfJobEvent:
+    return PublicationPdfJobEvent(
+        publication_id=publication_id,
+        user_id=user_id,
+        event_type=event_type,
+        status=status,
+        source=source,
+        failure_reason=failure_reason,
+        message=message,
+    )
+
+
+def _queued_job(
+    *,
+    publication_id: int,
+    user_id: int,
+) -> PublicationPdfJob:
+    now = _utcnow()
+    return PublicationPdfJob(
+        publication_id=publication_id,
+        status=PDF_STATUS_QUEUED,
+        queued_at=now,
+        last_requested_by_user_id=user_id,
+    )
+
+
+def _mark_job_queued(job: PublicationPdfJob, *, user_id: int) -> None:
+    now = _utcnow()
+    job.status = PDF_STATUS_QUEUED
+    job.queued_at = now
+    job.last_requested_by_user_id = user_id
+    job.last_failure_reason = None
+    job.last_failure_detail = None
+    job.last_source = None
+
+
+def _state_map(jobs: list[PublicationPdfJob]) -> dict[int, PublicationPdfJob]:
+    return {int(job.publication_id): job for job in jobs}
+
+
+async def _jobs_for_publication_ids(
+    db_session: AsyncSession,
+    *,
+    publication_ids: list[int],
+) -> dict[int, PublicationPdfJob]:
+    if not publication_ids:
+        return {}
+    result = await db_session.execute(
+        select(PublicationPdfJob).where(PublicationPdfJob.publication_id.in_(publication_ids))
+    )
+    return _state_map(list(result.scalars()))
+
+
+async def overlay_pdf_job_state(
+    db_session: AsyncSession,
+    *,
+    rows: list[PublicationListItem],
+) -> list[PublicationListItem]:
+    if not rows:
+        return []
+    jobs = await _jobs_for_publication_ids(
+        db_session,
+        publication_ids=_publication_ids(rows),
+    )
+    return [_item_from_row_and_job(row, jobs.get(row.publication_id)) for row in rows]
+
+
+async def _enqueue_rows(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    rows: list[PublicationListItem],
+    force_retry: bool,
+) -> list[PublicationListItem]:
+    if not rows:
+        return []
+    queued: list[PublicationListItem] = []
+    jobs = await _jobs_for_publication_ids(
+        db_session,
+        publication_ids=_publication_ids(rows),
+    )
+    for row in rows:
+        job = jobs.get(row.publication_id)
+        if not _can_enqueue_job(job, force_retry=force_retry):
+            continue
+        if job is None:
+            job = _queued_job(publication_id=row.publication_id, user_id=user_id)
+            jobs[row.publication_id] = job
+            db_session.add(job)
+        else:
+            _mark_job_queued(job, user_id=user_id)
+        db_session.add(
+            _event_row(
+                publication_id=row.publication_id,
+                user_id=user_id,
+                event_type=PDF_EVENT_QUEUED,
+                status=PDF_STATUS_QUEUED,
+            )
+        )
+        queued.append(row)
+    if queued:
+        await db_session.commit()
+    return queued
+
+
+def _register_task(task: asyncio.Task[None]) -> None:
+    _scheduled_tasks.add(task)
+
+
+def _drop_finished_task(task: asyncio.Task[None]) -> None:
+    _scheduled_tasks.discard(task)
+    try:
+        task.result()
+    except Exception:
+        logger.exception(
+            "publications.pdf_queue.task_failed",
+            extra={"event": "publications.pdf_queue.task_failed"},
+        )
+
+
+async def _mark_attempt_started(
+    *,
+    publication_id: int,
+    user_id: int,
+) -> None:
+    session_factory = get_session_factory()
+    async with session_factory() as db_session:
+        job = await db_session.get(PublicationPdfJob, publication_id)
+        if job is None:
+            job = _queued_job(publication_id=publication_id, user_id=user_id)
+            db_session.add(job)
+        job.status = PDF_STATUS_RUNNING
+        job.last_attempt_at = _utcnow()
+        job.attempt_count = int(job.attempt_count) + 1
+        db_session.add(
+            _event_row(
+                publication_id=publication_id,
+                user_id=user_id,
+                event_type=PDF_EVENT_ATTEMPT_STARTED,
+                status=PDF_STATUS_RUNNING,
+            )
+        )
+        await db_session.commit()
+
+
+def _failed_outcome(
+    *,
+    row: PublicationListItem,
+) -> OaResolutionOutcome:
+    return OaResolutionOutcome(
+        publication_id=row.publication_id,
+        doi=None,
+        pdf_url=None,
+        failure_reason=FAILURE_RESOLUTION_EXCEPTION,
+        source=None,
+        used_crossref=False,
+    )
+
+
+async def _fetch_outcome_for_row(
+    *,
+    row: PublicationListItem,
+    request_email: str | None,
+) -> OaResolutionOutcome:
+    pipeline_result = await resolve_publication_pdf_outcome_for_row(
+        row=row,
+        request_email=request_email,
+    )
+    outcome = pipeline_result.outcome
+    if outcome is not None:
+        return outcome
+    return _failed_outcome(row=row)
+
+
+def _apply_publication_update(
+    publication: Publication,
+    *,
+    pdf_url: str | None,
+) -> None:
+    if pdf_url and publication.pdf_url != pdf_url:
+        publication.pdf_url = pdf_url
+
+
+def _apply_job_outcome(job: PublicationPdfJob, *, outcome: OaResolutionOutcome) -> None:
+    job.last_source = outcome.source
+    if outcome.pdf_url:
+        job.status = PDF_STATUS_RESOLVED
+        job.resolved_at = _utcnow()
+        job.last_failure_reason = None
+        job.last_failure_detail = None
+        return
+    job.status = PDF_STATUS_FAILED
+    job.last_failure_reason = outcome.failure_reason
+    job.last_failure_detail = outcome.failure_reason
+
+
+def _result_event(outcome: OaResolutionOutcome) -> tuple[str, str]:
+    if outcome.pdf_url:
+        return PDF_EVENT_RESOLVED, PDF_STATUS_RESOLVED
+    return PDF_EVENT_FAILED, PDF_STATUS_FAILED
+
+
+async def _persist_outcome(
+    *,
+    publication_id: int,
+    user_id: int,
+    outcome: OaResolutionOutcome,
+) -> None:
+    session_factory = get_session_factory()
+    async with session_factory() as db_session:
+        publication = await db_session.get(Publication, publication_id)
+        job = await db_session.get(PublicationPdfJob, publication_id)
+        if publication is None or job is None:
+            return
+        _apply_publication_update(publication, pdf_url=outcome.pdf_url)
+        await identifier_service.sync_identifiers_for_publication_resolution(
+            db_session,
+            publication=publication,
+            source=outcome.source,
+        )
+        _apply_job_outcome(job, outcome=outcome)
+        event_type, status = _result_event(outcome)
+        db_session.add(
+            _event_row(
+                publication_id=publication_id,
+                user_id=user_id,
+                event_type=event_type,
+                status=status,
+                source=outcome.source,
+                failure_reason=outcome.failure_reason,
+                message=outcome.failure_reason,
+            )
+        )
+        await db_session.commit()
+
+
+async def _resolve_publication_row(
+    *,
+    user_id: int,
+    request_email: str | None,
+    row: PublicationListItem,
+) -> None:
+    await _mark_attempt_started(publication_id=row.publication_id, user_id=user_id)
+    try:
+        outcome = await _fetch_outcome_for_row(row=row, request_email=request_email)
+    except Exception as exc:  # pragma: no cover - defensive network boundary
+        logger.warning(
+            "publications.pdf_queue.resolve_failed",
+            extra={
+                "event": "publications.pdf_queue.resolve_failed",
+                "publication_id": row.publication_id,
+                "error": str(exc),
+            },
+        )
+        outcome = _failed_outcome(row=row)
+    await _persist_outcome(
+        publication_id=row.publication_id,
+        user_id=user_id,
+        outcome=outcome,
+    )
+
+
+async def _run_resolution_task(
+    *,
+    user_id: int,
+    request_email: str | None,
+    rows: list[PublicationListItem],
+) -> None:
+    for row in rows:
+        await _resolve_publication_row(
+            user_id=user_id,
+            request_email=request_email,
+            row=row,
+        )
+
+
+def _schedule_rows(
+    *,
+    user_id: int,
+    request_email: str | None,
+    rows: list[PublicationListItem],
+) -> None:
+    if not rows:
+        return
+    task = asyncio.create_task(
+        _run_resolution_task(
+            user_id=user_id,
+            request_email=request_email,
+            rows=rows,
+        )
+    )
+    _register_task(task)
+    task.add_done_callback(_drop_finished_task)
+
+
+async def enqueue_missing_pdf_jobs(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    request_email: str | None,
+    rows: list[PublicationListItem],
+    max_items: int,
+) -> list[int]:
+    queueable = _queueable_rows(rows, max_items=max_items)
+    queued_rows = await _enqueue_rows(
+        db_session,
+        user_id=user_id,
+        rows=queueable,
+        force_retry=False,
+    )
+    _schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
+    return [row.publication_id for row in queued_rows]
+
+
+async def enqueue_retry_pdf_job(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    request_email: str | None,
+    row: PublicationListItem,
+) -> bool:
+    queued_rows = await _enqueue_rows(
+        db_session,
+        user_id=user_id,
+        rows=[row],
+        force_retry=True,
+    )
+    _schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
+    return bool(queued_rows)
+
+
+def _retry_item_label(display_name: str | None, scholar_id: str | None) -> str:
+    return str(display_name or scholar_id or "unknown")
+
+
+def _retry_item_from_publication(
+    publication: Publication,
+    *,
+    link_row: tuple | None,
+) -> PublicationListItem:
+    if link_row is None:
+        scholar_profile_id = 0
+        scholar_label = "unknown"
+        is_read = True
+        first_seen_at = publication.created_at or _utcnow()
+    else:
+        scholar_profile_id = int(link_row[0])
+        scholar_label = _retry_item_label(link_row[1], link_row[2])
+        is_read = bool(link_row[3])
+        first_seen_at = link_row[4] or publication.created_at or _utcnow()
+    return PublicationListItem(
+        publication_id=int(publication.id),
+        scholar_profile_id=scholar_profile_id,
+        scholar_label=scholar_label,
+        title=publication.title_raw,
+        year=publication.year,
+        citation_count=int(publication.citation_count or 0),
+        venue_text=publication.venue_text,
+        pub_url=publication.pub_url,
+        pdf_url=publication.pdf_url,
+        is_read=is_read,
+        first_seen_at=first_seen_at,
+        is_new_in_latest_run=False,
+    )
+
+
+async def _retry_item_for_publication_id(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+) -> PublicationListItem | None:
+    publication = await db_session.get(Publication, publication_id)
+    if publication is None:
+        return None
+    result = await db_session.execute(
+        select(
+            ScholarProfile.id,
+            ScholarProfile.display_name,
+            ScholarProfile.scholar_id,
+            ScholarPublication.is_read,
+            ScholarPublication.created_at,
+        )
+        .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
+        .where(ScholarPublication.publication_id == publication_id)
+        .order_by(ScholarPublication.created_at.asc())
+        .limit(1)
+    )
+    return _retry_item_from_publication(publication, link_row=result.one_or_none())
+
+
+async def enqueue_retry_pdf_job_for_publication_id(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    request_email: str | None,
+    publication_id: int,
+) -> PdfRequeueResult:
+    row = await _retry_item_for_publication_id(
+        db_session,
+        publication_id=publication_id,
+    )
+    if row is None:
+        return PdfRequeueResult(publication_exists=False, queued=False)
+    queued = await enqueue_retry_pdf_job(
+        db_session,
+        user_id=user_id,
+        request_email=request_email,
+        row=row,
+    )
+    return PdfRequeueResult(publication_exists=True, queued=queued)
+
+
+def _queue_candidate_from_publication(publication: Publication) -> PublicationListItem:
+    return PublicationListItem(
+        publication_id=int(publication.id),
+        scholar_profile_id=0,
+        scholar_label="admin",
+        title=publication.title_raw,
+        year=publication.year,
+        citation_count=int(publication.citation_count or 0),
+        venue_text=publication.venue_text,
+        pub_url=publication.pub_url,
+        pdf_url=publication.pdf_url,
+        is_read=True,
+        first_seen_at=publication.created_at or _utcnow(),
+        is_new_in_latest_run=False,
+    )
+
+
+async def _missing_pdf_candidates(
+    db_session: AsyncSession,
+    *,
+    limit: int,
+) -> list[PublicationListItem]:
+    bounded_limit = max(1, min(int(limit), 5000))
+    result = await db_session.execute(
+        select(Publication)
+        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
+        .where(Publication.pdf_url.is_(None))
+        .where(
+            or_(
+                PublicationPdfJob.publication_id.is_(None),
+                PublicationPdfJob.status.notin_([PDF_STATUS_QUEUED, PDF_STATUS_RUNNING]),
+            )
+        )
+        .order_by(Publication.updated_at.desc(), Publication.id.desc())
+        .limit(bounded_limit)
+    )
+    return [
+        _queue_candidate_from_publication(publication)
+        for publication in result.scalars()
+    ]
+
+
+async def enqueue_all_missing_pdf_jobs(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    request_email: str | None,
+    limit: int = 1000,
+) -> PdfBulkQueueResult:
+    candidates = await _missing_pdf_candidates(db_session, limit=limit)
+    queued_rows = await _enqueue_rows(
+        db_session,
+        user_id=user_id,
+        rows=candidates,
+        force_retry=True,
+    )
+    _schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
+    return PdfBulkQueueResult(
+        requested_count=len(candidates),
+        queued_count=len(queued_rows),
+    )
+
+
+def _tracked_queue_select_base(*, status: str | None) -> Select[tuple]:
+    stmt = (
+        select(
+            PublicationPdfJob.publication_id,
+            Publication.title_raw,
+            Publication.pdf_url,
+            PublicationPdfJob.status,
+            PublicationPdfJob.attempt_count,
+            PublicationPdfJob.last_failure_reason,
+            PublicationPdfJob.last_failure_detail,
+            PublicationPdfJob.last_source,
+            PublicationPdfJob.last_requested_by_user_id,
+            User.email,
+            PublicationPdfJob.queued_at,
+            PublicationPdfJob.last_attempt_at,
+            PublicationPdfJob.resolved_at,
+            PublicationPdfJob.updated_at,
+        )
+        .join(Publication, Publication.id == PublicationPdfJob.publication_id)
+        .outerjoin(User, User.id == PublicationPdfJob.last_requested_by_user_id)
+    )
+    if status:
+        stmt = stmt.where(PublicationPdfJob.status == status)
+    return stmt
+
+
+def _tracked_queue_select(*, limit: int, offset: int, status: str | None) -> Select[tuple]:
+    return (
+        _tracked_queue_select_base(status=status)
+        .order_by(PublicationPdfJob.updated_at.desc())
+        .limit(_bounded_limit(limit))
+        .offset(_bounded_offset(offset))
+    )
+
+
+def _untracked_queue_select_base() -> Select[tuple]:
+    return (
+        select(
+            Publication.id,
+            Publication.title_raw,
+            Publication.pdf_url,
+            literal(PDF_STATUS_UNTRACKED),
+            literal(0),
+            literal(None),
+            literal(None),
+            literal(None),
+            literal(None),
+            literal(None),
+            literal(None),
+            literal(None),
+            literal(None),
+            Publication.updated_at,
+        )
+        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
+        .where(Publication.pdf_url.is_(None))
+        .where(PublicationPdfJob.publication_id.is_(None))
+    )
+
+
+def _untracked_queue_select(*, limit: int, offset: int) -> Select[tuple]:
+    return (
+        _untracked_queue_select_base()
+        .order_by(Publication.updated_at.desc(), Publication.id.desc())
+        .limit(_bounded_limit(limit))
+        .offset(_bounded_offset(offset))
+    )
+
+
+def _all_queue_select(*, limit: int, offset: int) -> Select[tuple]:
+    union_stmt = union_all(
+        _tracked_queue_select_base(status=None),
+        _untracked_queue_select_base(),
+    ).subquery()
+    return (
+        select(union_stmt)
+        .order_by(union_stmt.c.updated_at.desc())
+        .limit(_bounded_limit(limit))
+        .offset(_bounded_offset(offset))
+    )
+
+
+def _tracked_queue_count_select(*, status: str | None) -> Select[tuple]:
+    stmt = select(func.count()).select_from(PublicationPdfJob)
+    if status:
+        stmt = stmt.where(PublicationPdfJob.status == status)
+    return stmt
+
+
+def _untracked_queue_count_select() -> Select[tuple]:
+    return (
+        select(func.count())
+        .select_from(Publication)
+        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
+        .where(Publication.pdf_url.is_(None))
+        .where(PublicationPdfJob.publication_id.is_(None))
+    )
+
+
+def _queue_item_from_row(row: tuple) -> PdfQueueListItem:
+    return PdfQueueListItem(
+        publication_id=int(row[0]),
+        title=str(row[1] or ""),
+        pdf_url=row[2],
+        status=str(row[3] or PDF_STATUS_UNTRACKED),
+        attempt_count=int(row[4] or 0),
+        last_failure_reason=row[5],
+        last_failure_detail=row[6],
+        last_source=row[7],
+        requested_by_user_id=int(row[8]) if row[8] is not None else None,
+        requested_by_email=row[9],
+        queued_at=row[10],
+        last_attempt_at=row[11],
+        resolved_at=row[12],
+        updated_at=row[13],
+    )
+
+
+async def _hydrated_queue_items(
+    db_session: AsyncSession,
+    *,
+    rows: list[tuple],
+) -> list[PdfQueueListItem]:
+    items = [_queue_item_from_row(row) for row in rows]
+    return await identifier_service.overlay_pdf_queue_items_with_display_identifiers(
+        db_session,
+        items=items,
+    )
+
+
+async def list_pdf_queue_items(
+    db_session: AsyncSession,
+    *,
+    limit: int = 100,
+    offset: int = 0,
+    status: str | None = None,
+) -> list[PdfQueueListItem]:
+    bounded_limit = _bounded_limit(limit)
+    bounded_offset = _bounded_offset(offset)
+    normalized_status = (status or "").strip().lower() or None
+    if normalized_status == PDF_STATUS_UNTRACKED:
+        result = await db_session.execute(
+            _untracked_queue_select(
+                limit=bounded_limit,
+                offset=bounded_offset,
+            )
+        )
+        return await _hydrated_queue_items(db_session, rows=list(result.all()))
+    if normalized_status is None:
+        result = await db_session.execute(
+            _all_queue_select(
+                limit=bounded_limit,
+                offset=bounded_offset,
+            )
+        )
+        return await _hydrated_queue_items(db_session, rows=list(result.all()))
+    result = await db_session.execute(
+        _tracked_queue_select(
+            limit=bounded_limit,
+            offset=bounded_offset,
+            status=normalized_status,
+        )
+    )
+    return await _hydrated_queue_items(db_session, rows=list(result.all()))
+
+
+async def count_pdf_queue_items(
+    db_session: AsyncSession,
+    *,
+    status: str | None = None,
+) -> int:
+    normalized_status = (status or "").strip().lower() or None
+    if normalized_status == PDF_STATUS_UNTRACKED:
+        result = await db_session.execute(_untracked_queue_count_select())
+        return int(result.scalar_one() or 0)
+    tracked_result = await db_session.execute(
+        _tracked_queue_count_select(status=normalized_status)
+    )
+    tracked_count = int(tracked_result.scalar_one() or 0)
+    if normalized_status is not None:
+        return tracked_count
+    untracked_result = await db_session.execute(_untracked_queue_count_select())
+    untracked_count = int(untracked_result.scalar_one() or 0)
+    return tracked_count + untracked_count
+
+
+async def list_pdf_queue_page(
+    db_session: AsyncSession,
+    *,
+    limit: int = 100,
+    offset: int = 0,
+    status: str | None = None,
+) -> PdfQueuePage:
+    bounded_limit = _bounded_limit(limit)
+    bounded_offset = _bounded_offset(offset)
+    items = await list_pdf_queue_items(
+        db_session,
+        limit=bounded_limit,
+        offset=bounded_offset,
+        status=status,
+    )
+    total_count = await count_pdf_queue_items(
+        db_session,
+        status=status,
+    )
+    return PdfQueuePage(
+        items=items,
+        total_count=total_count,
+        limit=bounded_limit,
+        offset=bounded_offset,
+    )
+
+
+async def drain_ready_jobs(
+    db_session: AsyncSession,
+    *,
+    limit: int,
+    max_attempts: int,
+) -> int:
+    result = await db_session.execute(
+        select(User.id).where(User.is_active.is_(True)).order_by(User.id.asc()).limit(1)
+    )
+    system_user_id = result.scalar_one_or_none()
+    if system_user_id is None:
+        return 0
+
+    bulk_result = await enqueue_all_missing_pdf_jobs(
+        db_session,
+        user_id=system_user_id,
+        request_email=settings.unpaywall_email,
+        limit=limit,
+    )
+    return bulk_result.queued_count
diff --git a/build/lib/app/services/domains/publications/pdf_resolution_pipeline.py b/build/lib/app/services/domains/publications/pdf_resolution_pipeline.py
new file mode 100644
index 0000000..9e07c0b
--- /dev/null
+++ b/build/lib/app/services/domains/publications/pdf_resolution_pipeline.py
@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import logging
+from typing import Any
+
+from app.services.domains.publications.types import PublicationListItem
+from app.services.domains.unpaywall.application import OaResolutionOutcome, resolve_publication_oa_outcomes
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class PipelineOutcome:
+    outcome: OaResolutionOutcome | None
+    scholar_candidates: Any | None  # Kept for backward compatibility with calling signatures
+
+
+async def resolve_publication_pdf_outcome_for_row(
+    *,
+    row: PublicationListItem,
+    request_email: str | None,
+) -> PipelineOutcome:
+    # 1. OpenAlex OA
+    openalex_outcome = await _openalex_outcome(row, request_email=request_email)
+    if openalex_outcome and openalex_outcome.pdf_url:
+        return PipelineOutcome(openalex_outcome, None)
+
+    # 2. arXiv
+    arxiv_outcome = await _arxiv_outcome(row, request_email=request_email)
+    if arxiv_outcome and arxiv_outcome.pdf_url:
+        return PipelineOutcome(arxiv_outcome, None)
+
+    # 3. Unpaywall (which falls back to Crossref)
+    oa_outcome = await _oa_outcome(row=row, request_email=request_email)
+    return PipelineOutcome(oa_outcome, None)
+
+
+async def _openalex_outcome(row: PublicationListItem, request_email: str | None) -> OaResolutionOutcome | None:
+    from app.services.domains.openalex.client import OpenAlexClient
+    from app.services.domains.openalex.matching import find_best_match
+
+    if not row.title:
+        return None
+
+    import re
+    safe_title = re.sub(r"[^\w\s]", " ", row.title)
+    safe_title = " ".join(safe_title.split())
+    if not safe_title:
+        return None
+
+    client = OpenAlexClient(api_key=settings.openalex_api_key, mailto=request_email or settings.crossref_api_mailto)
+    try:
+        openalex_works = await client.get_works_by_filter({"title.search": safe_title}, limit=5)
+        match = find_best_match(
+            target_title=row.title,
+            target_year=row.year,
+            target_authors=row.scholar_label,
+            candidates=openalex_works,
+        )
+        if match and match.oa_url:
+            return OaResolutionOutcome(
+                publication_id=row.publication_id,
+                doi=match.doi,
+                pdf_url=match.oa_url,
+                failure_reason=None,
+                source="openalex",
+                used_crossref=False,
+            )
+    except Exception as exc:
+        logger.warning(
+            "publications.pdf_resolution.openalex_failed",
+            extra={"event": "publications.pdf_resolution.openalex_failed", "error": str(exc)},
+        )
+    return None
+
+
+async def _arxiv_outcome(row: PublicationListItem, request_email: str | None) -> OaResolutionOutcome | None:
+    from app.services.domains.arxiv.application import discover_arxiv_id_for_publication
+
+    try:
+        arxiv_id = await discover_arxiv_id_for_publication(item=row, request_email=request_email)
+        if arxiv_id:
+            pdf_url = f"https://arxiv.org/pdf/{arxiv_id}.pdf"
+            return OaResolutionOutcome(
+                publication_id=row.publication_id,
+                doi=None,
+                pdf_url=pdf_url,
+                failure_reason=None,
+                source="arxiv",
+                used_crossref=False,
+            )
+    except Exception as exc:
+        logger.warning(
+            "publications.pdf_resolution.arxiv_failed",
+            extra={"event": "publications.pdf_resolution.arxiv_failed", "error": str(exc)},
+        )
+    return None
+
+
+async def _oa_outcome(
+    *,
+    row: PublicationListItem,
+    request_email: str | None,
+) -> OaResolutionOutcome | None:
+    outcomes = await resolve_publication_oa_outcomes([row], request_email=request_email)
+    return outcomes.get(row.publication_id)
diff --git a/build/lib/app/services/domains/publications/queries.py b/build/lib/app/services/domains/publications/queries.py
new file mode 100644
index 0000000..e7356f4
--- /dev/null
+++ b/build/lib/app/services/domains/publications/queries.py
@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+from sqlalchemy import Select, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import CrawlRun, Publication, RunStatus, ScholarProfile, ScholarPublication
+from app.services.domains.publications.modes import MODE_LATEST, MODE_UNREAD
+from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+
+
+def _normalized_citation_count(value: object) -> int:
+    try:
+        return int(value or 0)
+    except (TypeError, ValueError):
+        return 0
+
+
+async def get_latest_completed_run_id_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+) -> int | None:
+    result = await db_session.execute(
+        select(func.max(CrawlRun.id)).where(
+            CrawlRun.user_id == user_id,
+            CrawlRun.status != RunStatus.RUNNING,
+        )
+    )
+    latest_run_id = result.scalar_one_or_none()
+    return int(latest_run_id) if latest_run_id is not None else None
+
+
+def publications_query(
+    *,
+    user_id: int,
+    mode: str,
+    latest_run_id: int | None,
+    scholar_profile_id: int | None,
+    favorite_only: bool,
+    limit: int,
+    offset: int = 0,
+) -> Select[tuple]:
+    scholar_label = ScholarProfile.display_name
+    stmt = (
+        select(
+            Publication.id,
+            ScholarProfile.id,
+            scholar_label,
+            ScholarProfile.scholar_id,
+            Publication.title_raw,
+            Publication.year,
+            Publication.citation_count,
+            Publication.venue_text,
+            Publication.pub_url,
+            Publication.pdf_url,
+            ScholarPublication.is_read,
+            ScholarPublication.is_favorite,
+            ScholarPublication.first_seen_run_id,
+            ScholarPublication.created_at,
+        )
+        .join(ScholarPublication, ScholarPublication.publication_id == Publication.id)
+        .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
+        .where(ScholarProfile.user_id == user_id)
+        .order_by(ScholarPublication.created_at.desc(), Publication.id.desc())
+        .offset(max(int(offset), 0))
+        .limit(limit)
+    )
+    if scholar_profile_id is not None:
+        stmt = stmt.where(ScholarProfile.id == scholar_profile_id)
+    if favorite_only:
+        stmt = stmt.where(ScholarPublication.is_favorite.is_(True))
+    if mode == MODE_UNREAD:
+        stmt = stmt.where(ScholarPublication.is_read.is_(False))
+    if mode == MODE_LATEST:
+        if latest_run_id is None:
+            return stmt.where(False)
+        stmt = stmt.where(ScholarPublication.first_seen_run_id == latest_run_id)
+    return stmt
+
+
+def publication_query_for_user(
+    *,
+    user_id: int,
+    scholar_profile_id: int,
+    publication_id: int,
+) -> Select[tuple]:
+    return (
+        select(
+            Publication.id,
+            ScholarProfile.id,
+            ScholarProfile.display_name,
+            ScholarProfile.scholar_id,
+            Publication.title_raw,
+            Publication.year,
+            Publication.citation_count,
+            Publication.venue_text,
+            Publication.pub_url,
+            Publication.pdf_url,
+            ScholarPublication.is_read,
+            ScholarPublication.is_favorite,
+            ScholarPublication.first_seen_run_id,
+            ScholarPublication.created_at,
+        )
+        .join(ScholarPublication, ScholarPublication.publication_id == Publication.id)
+        .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
+        .where(
+            ScholarProfile.user_id == user_id,
+            ScholarProfile.id == scholar_profile_id,
+            Publication.id == publication_id,
+        )
+        .limit(1)
+    )
+
+
+async def get_publication_item_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int,
+    publication_id: int,
+) -> PublicationListItem | None:
+    latest_run_id = await get_latest_completed_run_id_for_user(db_session, user_id=user_id)
+    result = await db_session.execute(
+        publication_query_for_user(
+            user_id=user_id,
+            scholar_profile_id=scholar_profile_id,
+            publication_id=publication_id,
+        )
+    )
+    row = result.one_or_none()
+    if row is None:
+        return None
+    return publication_list_item_from_row(row, latest_run_id=latest_run_id)
+
+
+def publication_list_item_from_row(
+    row: tuple,
+    *,
+    latest_run_id: int | None,
+) -> PublicationListItem:
+    (
+        publication_id,
+        scholar_profile_id,
+        display_name,
+        scholar_id,
+        title_raw,
+        year,
+        citation_count,
+        venue_text,
+        pub_url,
+        pdf_url,
+        is_read,
+        is_favorite,
+        first_seen_run_id,
+        created_at,
+    ) = row
+    return PublicationListItem(
+        publication_id=int(publication_id),
+        scholar_profile_id=int(scholar_profile_id),
+        scholar_label=(display_name or scholar_id),
+        title=title_raw,
+        year=year,
+        citation_count=_normalized_citation_count(citation_count),
+        venue_text=venue_text,
+        pub_url=pub_url,
+        pdf_url=pdf_url,
+        is_read=bool(is_read),
+        is_favorite=bool(is_favorite),
+        first_seen_at=created_at,
+        is_new_in_latest_run=(
+            latest_run_id is not None and int(first_seen_run_id or 0) == latest_run_id
+        ),
+    )
+
+
+def unread_item_from_row(row: tuple) -> UnreadPublicationItem:
+    (
+        publication_id,
+        scholar_profile_id,
+        display_name,
+        scholar_id,
+        title_raw,
+        year,
+        citation_count,
+        venue_text,
+        pub_url,
+        pdf_url,
+        _is_read,
+        _is_favorite,
+        _first_seen_run_id,
+        _created_at,
+    ) = row
+    return UnreadPublicationItem(
+        publication_id=int(publication_id),
+        scholar_profile_id=int(scholar_profile_id),
+        scholar_label=(display_name or scholar_id),
+        title=title_raw,
+        year=year,
+        citation_count=_normalized_citation_count(citation_count),
+        venue_text=venue_text,
+        pub_url=pub_url,
+        pdf_url=pdf_url,
+    )
diff --git a/build/lib/app/services/domains/publications/read_state.py b/build/lib/app/services/domains/publications/read_state.py
new file mode 100644
index 0000000..41fc31a
--- /dev/null
+++ b/build/lib/app/services/domains/publications/read_state.py
@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from sqlalchemy import select, tuple_, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import ScholarProfile, ScholarPublication
+
+
+def _normalized_selection_pairs(selections: list[tuple[int, int]]) -> set[tuple[int, int]]:
+    pairs: set[tuple[int, int]] = set()
+    for scholar_profile_id, publication_id in selections:
+        normalized = (int(scholar_profile_id), int(publication_id))
+        if normalized[0] <= 0 or normalized[1] <= 0:
+            continue
+        pairs.add(normalized)
+    return pairs
+
+
+def _scoped_scholar_ids_query(*, user_id: int):
+    return (
+        select(ScholarProfile.id)
+        .where(ScholarProfile.user_id == user_id)
+        .scalar_subquery()
+    )
+
+
+async def mark_all_unread_as_read_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+) -> int:
+    scholar_ids = _scoped_scholar_ids_query(user_id=user_id)
+    stmt = (
+        update(ScholarPublication)
+        .where(
+            ScholarPublication.scholar_profile_id.in_(scholar_ids),
+            ScholarPublication.is_read.is_(False),
+        )
+        .values(is_read=True)
+    )
+    result = await db_session.execute(stmt)
+    await db_session.commit()
+    return int(result.rowcount or 0)
+
+
+async def mark_selected_as_read_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    selections: list[tuple[int, int]],
+) -> int:
+    normalized_pairs = _normalized_selection_pairs(selections)
+    if not normalized_pairs:
+        return 0
+
+    scholar_ids = _scoped_scholar_ids_query(user_id=user_id)
+    stmt = (
+        update(ScholarPublication)
+        .where(
+            ScholarPublication.scholar_profile_id.in_(scholar_ids),
+            tuple_(
+                ScholarPublication.scholar_profile_id,
+                ScholarPublication.publication_id,
+            ).in_(list(normalized_pairs)),
+            ScholarPublication.is_read.is_(False),
+        )
+        .values(is_read=True)
+    )
+    result = await db_session.execute(stmt)
+    await db_session.commit()
+    return int(result.rowcount or 0)
+
+
+async def set_publication_favorite_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int,
+    publication_id: int,
+    is_favorite: bool,
+) -> int:
+    scholar_ids = _scoped_scholar_ids_query(user_id=user_id)
+    stmt = (
+        update(ScholarPublication)
+        .where(
+            ScholarPublication.scholar_profile_id.in_(scholar_ids),
+            ScholarPublication.scholar_profile_id == int(scholar_profile_id),
+            ScholarPublication.publication_id == int(publication_id),
+        )
+        .values(is_favorite=bool(is_favorite))
+    )
+    result = await db_session.execute(stmt)
+    await db_session.commit()
+    return int(result.rowcount or 0)
diff --git a/build/lib/app/services/domains/publications/types.py b/build/lib/app/services/domains/publications/types.py
new file mode 100644
index 0000000..62d038b
--- /dev/null
+++ b/build/lib/app/services/domains/publications/types.py
@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+from app.services.domains.publication_identifiers.types import DisplayIdentifier
+
+
+@dataclass(frozen=True)
+class PublicationListItem:
+    publication_id: int
+    scholar_profile_id: int
+    scholar_label: str
+    title: str
+    year: int | None
+    citation_count: int
+    venue_text: str | None
+    pub_url: str | None
+    pdf_url: str | None
+    is_read: bool
+    first_seen_at: datetime
+    is_new_in_latest_run: bool
+    is_favorite: bool = False
+    pdf_status: str = "untracked"
+    pdf_attempt_count: int = 0
+    pdf_failure_reason: str | None = None
+    pdf_failure_detail: str | None = None
+    display_identifier: DisplayIdentifier | None = None
+
+
+@dataclass(frozen=True)
+class UnreadPublicationItem:
+    publication_id: int
+    scholar_profile_id: int
+    scholar_label: str
+    title: str
+    year: int | None
+    citation_count: int
+    venue_text: str | None
+    pub_url: str | None
+    pdf_url: str | None
diff --git a/build/lib/app/services/domains/runs/__init__.py b/build/lib/app/services/domains/runs/__init__.py
new file mode 100644
index 0000000..848f6e0
--- /dev/null
+++ b/build/lib/app/services/domains/runs/__init__.py
@@ -0,0 +1 @@
+from app.services.domains.runs.application import *
diff --git a/build/lib/app/services/domains/runs/application.py b/build/lib/app/services/domains/runs/application.py
new file mode 100644
index 0000000..0019446
--- /dev/null
+++ b/build/lib/app/services/domains/runs/application.py
@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from app.services.domains.runs.queue_service import (
+    clear_queue_item_for_user,
+    drop_queue_item_for_user,
+    get_queue_item_for_user,
+    list_queue_items_for_user,
+    queue_status_counts_for_user,
+    retry_queue_item_for_user,
+)
+from app.services.domains.runs.runs_service import (
+    get_manual_run_by_idempotency_key,
+    get_run_for_user,
+    list_recent_runs_for_user,
+    list_runs_for_user,
+)
+from app.services.domains.runs.summary import extract_run_summary
+from app.services.domains.runs.types import (
+    QUEUE_STATUS_DROPPED,
+    QUEUE_STATUS_QUEUED,
+    QUEUE_STATUS_RETRYING,
+    QueueClearResult,
+    QueueListItem,
+    QueueTransitionError,
+)
+
+__all__ = [
+    "QUEUE_STATUS_QUEUED",
+    "QUEUE_STATUS_RETRYING",
+    "QUEUE_STATUS_DROPPED",
+    "QueueListItem",
+    "QueueClearResult",
+    "QueueTransitionError",
+    "extract_run_summary",
+    "list_recent_runs_for_user",
+    "list_runs_for_user",
+    "get_run_for_user",
+    "get_manual_run_by_idempotency_key",
+    "list_queue_items_for_user",
+    "get_queue_item_for_user",
+    "retry_queue_item_for_user",
+    "drop_queue_item_for_user",
+    "clear_queue_item_for_user",
+    "queue_status_counts_for_user",
+]
diff --git a/build/lib/app/services/domains/runs/events.py b/build/lib/app/services/domains/runs/events.py
new file mode 100644
index 0000000..ef28069
--- /dev/null
+++ b/build/lib/app/services/domains/runs/events.py
@@ -0,0 +1,59 @@
+import asyncio
+import json
+import logging
+from typing import Any, AsyncGenerator, Dict, Set
+
+logger = logging.getLogger(__name__)
+
+class RunEventPublisher:
+    def __init__(self) -> None:
+        # Maps run_id to a set of subscriber queues
+        self._subscribers: Dict[int, Set[asyncio.Queue]] = {}
+
+    def subscribe(self, run_id: int) -> asyncio.Queue:
+        if run_id not in self._subscribers:
+            self._subscribers[run_id] = set()
+        queue: asyncio.Queue[Any] = asyncio.Queue()
+        self._subscribers[run_id].add(queue)
+        logger.debug(f"New subscriber for run {run_id}. Total: {len(self._subscribers[run_id])}")
+        return queue
+
+    def unsubscribe(self, run_id: int, queue: asyncio.Queue) -> None:
+        if run_id in self._subscribers:
+            self._subscribers[run_id].discard(queue)
+            if not self._subscribers[run_id]:
+                self._subscribers.pop(run_id, None)
+
+    async def publish(self, run_id: int, event_type: str, data: dict[str, Any]) -> None:
+        if run_id not in self._subscribers:
+            return
+        
+        message = {
+            "type": event_type,
+            "data": data
+        }
+        
+        # Fan-out to all active subscribers for this run
+        for queue in list(self._subscribers[run_id]):
+            try:
+                queue.put_nowait(message)
+            except asyncio.QueueFull:
+                logger.warning(f"Subscriber queue full for run {run_id}, dropping message")
+
+run_events = RunEventPublisher()
+
+async def event_generator(run_id: int) -> AsyncGenerator[str, None]:
+    queue = run_events.subscribe(run_id)
+    try:
+        while True:
+            # Wait for a new event
+            message = await queue.get()
+            # Server-Sent Events format: "event: <type>\ndata: <json>\n\n"
+            event_type = message["type"]
+            data_str = json.dumps(message["data"])
+            yield f"event: {event_type}\ndata: {data_str}\n\n"
+    except asyncio.CancelledError:
+        logger.debug(f"Client disconnected from SSE stream for run {run_id}")
+        raise
+    finally:
+        run_events.unsubscribe(run_id, queue)
diff --git a/build/lib/app/services/domains/runs/queue_queries.py b/build/lib/app/services/domains/runs/queue_queries.py
new file mode 100644
index 0000000..7d2e501
--- /dev/null
+++ b/build/lib/app/services/domains/runs/queue_queries.py
@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from sqlalchemy import and_, select
+
+from app.db.models import IngestionQueueItem, ScholarProfile
+from app.services.domains.runs.types import QueueListItem
+
+
+def queue_item_columns() -> tuple:
+    return (
+        IngestionQueueItem.id,
+        IngestionQueueItem.scholar_profile_id,
+        ScholarProfile.display_name,
+        ScholarProfile.scholar_id,
+        IngestionQueueItem.status,
+        IngestionQueueItem.reason,
+        IngestionQueueItem.dropped_reason,
+        IngestionQueueItem.attempt_count,
+        IngestionQueueItem.resume_cstart,
+        IngestionQueueItem.next_attempt_dt,
+        IngestionQueueItem.updated_at,
+        IngestionQueueItem.last_error,
+        IngestionQueueItem.last_run_id,
+    )
+
+
+def queue_item_select(*, user_id: int):
+    return (
+        select(*queue_item_columns())
+        .join(
+            ScholarProfile,
+            and_(
+                ScholarProfile.id == IngestionQueueItem.scholar_profile_id,
+                ScholarProfile.user_id == IngestionQueueItem.user_id,
+            ),
+        )
+        .where(IngestionQueueItem.user_id == user_id)
+    )
+
+
+def queue_list_item_from_row(row: tuple) -> QueueListItem:
+    (
+        item_id,
+        scholar_profile_id,
+        display_name,
+        scholar_id,
+        status,
+        reason,
+        dropped_reason,
+        attempt_count,
+        resume_cstart,
+        next_attempt_dt,
+        updated_at,
+        last_error,
+        last_run_id,
+    ) = row
+    return QueueListItem(
+        id=int(item_id),
+        scholar_profile_id=int(scholar_profile_id),
+        scholar_label=(display_name or scholar_id),
+        status=str(status),
+        reason=str(reason),
+        dropped_reason=dropped_reason,
+        attempt_count=int(attempt_count or 0),
+        resume_cstart=int(resume_cstart or 0),
+        next_attempt_dt=next_attempt_dt,
+        updated_at=updated_at,
+        last_error=last_error,
+        last_run_id=int(last_run_id) if last_run_id is not None else None,
+    )
diff --git a/build/lib/app/services/domains/runs/queue_service.py b/build/lib/app/services/domains/runs/queue_service.py
new file mode 100644
index 0000000..d69ce21
--- /dev/null
+++ b/build/lib/app/services/domains/runs/queue_service.py
@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from sqlalchemy import case, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import IngestionQueueItem
+from app.services.domains.ingestion import queue as queue_mutations
+from app.services.domains.runs.queue_queries import queue_item_select, queue_list_item_from_row
+from app.services.domains.runs.types import (
+    QUEUE_STATUS_DROPPED,
+    QUEUE_STATUS_QUEUED,
+    QUEUE_STATUS_RETRYING,
+    QueueClearResult,
+    QueueListItem,
+    QueueTransitionError,
+)
+
+
+async def list_queue_items_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    limit: int = 200,
+) -> list[QueueListItem]:
+    result = await db_session.execute(
+        queue_item_select(user_id=user_id)
+        .order_by(
+            case((IngestionQueueItem.status == QUEUE_STATUS_DROPPED, 1), else_=0).asc(),
+            IngestionQueueItem.next_attempt_dt.asc(),
+            IngestionQueueItem.id.asc(),
+        )
+        .limit(limit)
+    )
+    return [queue_list_item_from_row(row) for row in result.all()]
+
+
+async def get_queue_item_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    queue_item_id: int,
+) -> QueueListItem | None:
+    result = await db_session.execute(
+        queue_item_select(user_id=user_id)
+        .where(IngestionQueueItem.id == queue_item_id)
+        .limit(1)
+    )
+    row = result.one_or_none()
+    if row is None:
+        return None
+    return queue_list_item_from_row(row)
+
+
+async def retry_queue_item_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    queue_item_id: int,
+) -> QueueListItem | None:
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(
+            IngestionQueueItem.id == queue_item_id,
+            IngestionQueueItem.user_id == user_id,
+        )
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    if item.status == QUEUE_STATUS_QUEUED:
+        raise QueueTransitionError(
+            code="queue_item_already_queued",
+            message="Queue item is already queued.",
+            current_status=item.status,
+        )
+    if item.status == QUEUE_STATUS_RETRYING:
+        raise QueueTransitionError(
+            code="queue_item_retrying",
+            message="Queue item is currently retrying.",
+            current_status=item.status,
+        )
+
+    await queue_mutations.mark_queued_now(
+        db_session,
+        job_id=item.id,
+        reason="manual_retry",
+        reset_attempt_count=(item.status == QUEUE_STATUS_DROPPED),
+    )
+    await db_session.commit()
+    return await get_queue_item_for_user(
+        db_session,
+        user_id=user_id,
+        queue_item_id=queue_item_id,
+    )
+
+
+async def drop_queue_item_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    queue_item_id: int,
+) -> QueueListItem | None:
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(
+            IngestionQueueItem.id == queue_item_id,
+            IngestionQueueItem.user_id == user_id,
+        )
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    if item.status == QUEUE_STATUS_DROPPED:
+        raise QueueTransitionError(
+            code="queue_item_already_dropped",
+            message="Queue item is already dropped.",
+            current_status=item.status,
+        )
+
+    await queue_mutations.mark_dropped(
+        db_session,
+        job_id=int(item.id),
+        reason="manual_drop",
+    )
+    await db_session.commit()
+    return await get_queue_item_for_user(
+        db_session,
+        user_id=user_id,
+        queue_item_id=queue_item_id,
+    )
+
+
+async def clear_queue_item_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    queue_item_id: int,
+) -> QueueClearResult | None:
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(
+            IngestionQueueItem.id == queue_item_id,
+            IngestionQueueItem.user_id == user_id,
+        )
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    if item.status != QUEUE_STATUS_DROPPED:
+        raise QueueTransitionError(
+            code="queue_item_not_dropped",
+            message="Queue item can only be cleared after it is dropped.",
+            current_status=item.status,
+        )
+
+    item_id = int(item.id)
+    previous_status = str(item.status)
+    deleted = await queue_mutations.delete_job_by_id(db_session, job_id=item_id)
+    await db_session.commit()
+    if not deleted:
+        return None
+    return QueueClearResult(queue_item_id=item_id, previous_status=previous_status)
+
+
+async def queue_status_counts_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+) -> dict[str, int]:
+    result = await db_session.execute(
+        select(
+            IngestionQueueItem.status,
+            func.count(IngestionQueueItem.id),
+        )
+        .where(IngestionQueueItem.user_id == user_id)
+        .group_by(IngestionQueueItem.status)
+    )
+    counts: dict[str, int] = {
+        QUEUE_STATUS_QUEUED: 0,
+        QUEUE_STATUS_RETRYING: 0,
+        QUEUE_STATUS_DROPPED: 0,
+    }
+    for status, count in result.all():
+        counts[str(status)] = int(count or 0)
+    return counts
diff --git a/build/lib/app/services/domains/runs/runs_service.py b/build/lib/app/services/domains/runs/runs_service.py
new file mode 100644
index 0000000..1cb9aa2
--- /dev/null
+++ b/build/lib/app/services/domains/runs/runs_service.py
@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from sqlalchemy import or_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import CrawlRun, RunStatus, RunTriggerType
+
+
+async def list_recent_runs_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    limit: int = 20,
+) -> list[CrawlRun]:
+    result = await db_session.execute(
+        select(CrawlRun)
+        .where(CrawlRun.user_id == user_id)
+        .order_by(CrawlRun.start_dt.desc(), CrawlRun.id.desc())
+        .limit(limit)
+    )
+    return list(result.scalars().all())
+
+
+async def list_runs_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    limit: int = 100,
+    failed_only: bool = False,
+) -> list[CrawlRun]:
+    stmt = (
+        select(CrawlRun)
+        .where(CrawlRun.user_id == user_id)
+        .order_by(CrawlRun.start_dt.desc(), CrawlRun.id.desc())
+        .limit(limit)
+    )
+    if failed_only:
+        stmt = stmt.where(
+            CrawlRun.status.in_([RunStatus.FAILED, RunStatus.PARTIAL_FAILURE])
+        )
+    result = await db_session.execute(stmt)
+    return list(result.scalars().all())
+
+
+async def get_run_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    run_id: int,
+) -> CrawlRun | None:
+    result = await db_session.execute(
+        select(CrawlRun).where(
+            CrawlRun.user_id == user_id,
+            CrawlRun.id == run_id,
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_manual_run_by_idempotency_key(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    idempotency_key: str,
+) -> CrawlRun | None:
+    result = await db_session.execute(
+        select(CrawlRun)
+        .where(
+            CrawlRun.user_id == user_id,
+            CrawlRun.trigger_type == RunTriggerType.MANUAL,
+            or_(
+                CrawlRun.idempotency_key == idempotency_key,
+                CrawlRun.error_log["meta"]["idempotency_key"].astext == idempotency_key,
+            ),
+        )
+        .order_by(CrawlRun.start_dt.desc(), CrawlRun.id.desc())
+        .limit(1)
+    )
+    return result.scalar_one_or_none()
diff --git a/build/lib/app/services/domains/runs/summary.py b/build/lib/app/services/domains/runs/summary.py
new file mode 100644
index 0000000..9555558
--- /dev/null
+++ b/build/lib/app/services/domains/runs/summary.py
@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def _safe_int(value: object, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _summary_dict(error_log: object) -> dict[str, Any]:
+    if not isinstance(error_log, dict):
+        return {}
+    summary = error_log.get("summary")
+    if not isinstance(summary, dict):
+        return {}
+    return summary
+
+
+def _summary_int_dict(summary: dict[str, Any], key: str) -> dict[str, int]:
+    value = summary.get(key)
+    if not isinstance(value, dict):
+        return {}
+    return {
+        str(item_key): _safe_int(item_value, 0)
+        for item_key, item_value in value.items()
+        if isinstance(item_key, str)
+    }
+
+
+def _summary_bool_dict(summary: dict[str, Any], key: str) -> dict[str, bool]:
+    value = summary.get(key)
+    if not isinstance(value, dict):
+        return {}
+    return {
+        str(item_key): bool(item_value)
+        for item_key, item_value in value.items()
+        if isinstance(item_key, str)
+    }
+
+
+def _retry_counts(summary: dict[str, Any]) -> dict[str, int]:
+    retry_counts = summary.get("retry_counts")
+    if not isinstance(retry_counts, dict):
+        retry_counts = {}
+    return {
+        "retries_scheduled_count": _safe_int(
+            retry_counts.get("retries_scheduled_count", 0),
+            0,
+        ),
+        "scholars_with_retries_count": _safe_int(
+            retry_counts.get("scholars_with_retries_count", 0),
+            0,
+        ),
+        "retry_exhausted_count": _safe_int(
+            retry_counts.get("retry_exhausted_count", 0),
+            0,
+        ),
+    }
+
+
+def extract_run_summary(error_log: object) -> dict[str, Any]:
+    summary = _summary_dict(error_log)
+    return {
+        "succeeded_count": _safe_int(summary.get("succeeded_count", 0)),
+        "failed_count": _safe_int(summary.get("failed_count", 0)),
+        "partial_count": _safe_int(summary.get("partial_count", 0)),
+        "failed_state_counts": _summary_int_dict(summary, "failed_state_counts"),
+        "failed_reason_counts": _summary_int_dict(summary, "failed_reason_counts"),
+        "scrape_failure_counts": _summary_int_dict(summary, "scrape_failure_counts"),
+        "retry_counts": _retry_counts(summary),
+        "alert_thresholds": _summary_int_dict(summary, "alert_thresholds"),
+        "alert_flags": _summary_bool_dict(summary, "alert_flags"),
+    }
diff --git a/build/lib/app/services/domains/runs/types.py b/build/lib/app/services/domains/runs/types.py
new file mode 100644
index 0000000..2524269
--- /dev/null
+++ b/build/lib/app/services/domains/runs/types.py
@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+QUEUE_STATUS_QUEUED = "queued"
+QUEUE_STATUS_RETRYING = "retrying"
+QUEUE_STATUS_DROPPED = "dropped"
+
+
+@dataclass(frozen=True)
+class QueueListItem:
+    id: int
+    scholar_profile_id: int
+    scholar_label: str
+    status: str
+    reason: str
+    dropped_reason: str | None
+    attempt_count: int
+    resume_cstart: int
+    next_attempt_dt: datetime | None
+    updated_at: datetime
+    last_error: str | None
+    last_run_id: int | None
+
+
+@dataclass(frozen=True)
+class QueueClearResult:
+    queue_item_id: int
+    previous_status: str
+
+
+class QueueTransitionError(RuntimeError):
+    def __init__(self, *, code: str, message: str, current_status: str) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.current_status = current_status
diff --git a/build/lib/app/services/domains/scholar/__init__.py b/build/lib/app/services/domains/scholar/__init__.py
new file mode 100644
index 0000000..9d48db4
--- /dev/null
+++ b/build/lib/app/services/domains/scholar/__init__.py
@@ -0,0 +1 @@
+from __future__ import annotations
diff --git a/build/lib/app/services/domains/scholar/author_rows.py b/build/lib/app/services/domains/scholar/author_rows.py
new file mode 100644
index 0000000..8acd783
--- /dev/null
+++ b/build/lib/app/services/domains/scholar/author_rows.py
@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import re
+from html.parser import HTMLParser
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+from app.services.domains.scholar.parser_constants import AUTHOR_SEARCH_MARKER_KEYS
+from app.services.domains.scholar.parser_types import ScholarSearchCandidate
+from app.services.domains.scholar.parser_utils import (
+    attr_class,
+    attr_href,
+    attr_src,
+    build_absolute_scholar_url,
+    normalize_space,
+)
+
+
+def parse_scholar_id_from_href(href: str | None) -> str | None:
+    if not href:
+        return None
+    parsed = urlparse(href)
+    query = parse_qs(parsed.query)
+    user_values = query.get("user")
+    if not user_values:
+        return None
+    candidate = user_values[0].strip()
+    return candidate or None
+
+
+def _extract_verified_email_domain(value: str | None) -> str | None:
+    if not value:
+        return None
+    match = re.search(r"verified email at\s+(.+)$", value.strip(), re.I)
+    if not match:
+        return None
+    domain = normalize_space(match.group(1))
+    return domain or None
+
+
+class ScholarAuthorSearchParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.candidates: list[ScholarSearchCandidate] = []
+        self._candidate: dict[str, Any] | None = None
+
+    def _begin_candidate(self) -> None:
+        self._candidate = {
+            "depth": 1,
+            "name_href": None,
+            "name_parts": [],
+            "aff_depth": 0,
+            "aff_parts": [],
+            "name_depth": 0,
+            "eml_depth": 0,
+            "eml_parts": [],
+            "cby_depth": 0,
+            "cby_parts": [],
+            "interest_depth": 0,
+            "interest_parts": [],
+            "interests": [],
+            "image_src": None,
+        }
+
+    def _increment_capture_depths(self) -> None:
+        if self._candidate is None:
+            return
+        for key in ("name_depth", "aff_depth", "eml_depth", "cby_depth", "interest_depth"):
+            if self._candidate[key] > 0:
+                self._candidate[key] += 1
+
+    def _finalize_candidate(self) -> None:
+        if self._candidate is None:
+            return
+
+        name = normalize_space("".join(self._candidate["name_parts"]))
+        scholar_id = parse_scholar_id_from_href(self._candidate["name_href"])
+        if not name or not scholar_id:
+            return
+
+        affiliation = normalize_space("".join(self._candidate["aff_parts"])) or None
+        email_domain = _extract_verified_email_domain(
+            normalize_space("".join(self._candidate["eml_parts"])) or None
+        )
+        cited_by_text = normalize_space("".join(self._candidate["cby_parts"]))
+        cited_by_match = re.search(r"\d+", cited_by_text)
+        cited_by_count = int(cited_by_match.group(0)) if cited_by_match else None
+
+        seen_interests: set[str] = set()
+        interests: list[str] = []
+        for interest in self._candidate["interests"]:
+            normalized = normalize_space(interest)
+            if not normalized or normalized in seen_interests:
+                continue
+            seen_interests.add(normalized)
+            interests.append(normalized)
+
+        profile_url = build_absolute_scholar_url(self._candidate["name_href"])
+        if not profile_url:
+            profile_url = (
+                "https://scholar.google.com/citations"
+                f"?hl=en&user={scholar_id}"
+            )
+
+        self.candidates.append(
+            ScholarSearchCandidate(
+                scholar_id=scholar_id,
+                display_name=name,
+                affiliation=affiliation,
+                email_domain=email_domain,
+                cited_by_count=cited_by_count,
+                interests=interests,
+                profile_url=profile_url,
+                profile_image_url=build_absolute_scholar_url(self._candidate["image_src"]),
+            )
+        )
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        classes = attr_class(attrs)
+
+        if self._candidate is None:
+            if tag == "div" and "gsc_1usr" in classes:
+                self._begin_candidate()
+            return
+
+        self._candidate["depth"] += 1
+        self._increment_capture_depths()
+
+        if tag == "a" and "gs_ai_name" in classes:
+            self._candidate["name_depth"] = 1
+            self._candidate["name_href"] = attr_href(attrs)
+            return
+
+        if tag == "div" and "gs_ai_aff" in classes:
+            self._candidate["aff_depth"] = 1
+            return
+
+        if tag == "div" and "gs_ai_eml" in classes:
+            self._candidate["eml_depth"] = 1
+            return
+
+        if tag == "div" and "gs_ai_cby" in classes:
+            self._candidate["cby_depth"] = 1
+            return
+
+        if tag == "a" and "gs_ai_one_int" in classes:
+            self._candidate["interest_depth"] = 1
+            self._candidate["interest_parts"] = []
+            return
+
+        if tag == "img" and self._candidate["image_src"] is None:
+            self._candidate["image_src"] = attr_src(attrs)
+
+    def handle_data(self, data: str) -> None:
+        if self._candidate is None:
+            return
+        if self._candidate["name_depth"] > 0:
+            self._candidate["name_parts"].append(data)
+        if self._candidate["aff_depth"] > 0:
+            self._candidate["aff_parts"].append(data)
+        if self._candidate["eml_depth"] > 0:
+            self._candidate["eml_parts"].append(data)
+        if self._candidate["cby_depth"] > 0:
+            self._candidate["cby_parts"].append(data)
+        if self._candidate["interest_depth"] > 0:
+            self._candidate["interest_parts"].append(data)
+
+    def _decrement_capture_depth(self, key: str) -> bool:
+        if self._candidate is None:
+            return False
+        if self._candidate[key] <= 0:
+            return False
+        self._candidate[key] -= 1
+        return self._candidate[key] == 0
+
+    def handle_endtag(self, _tag: str) -> None:
+        if self._candidate is None:
+            return
+
+        interest_closed = self._decrement_capture_depth("interest_depth")
+        self._decrement_capture_depth("name_depth")
+        self._decrement_capture_depth("aff_depth")
+        self._decrement_capture_depth("eml_depth")
+        self._decrement_capture_depth("cby_depth")
+
+        if interest_closed:
+            interest_text = normalize_space("".join(self._candidate["interest_parts"]))
+            if interest_text:
+                self._candidate["interests"].append(interest_text)
+            self._candidate["interest_parts"] = []
+
+        self._candidate["depth"] -= 1
+        if self._candidate["depth"] > 0:
+            return
+
+        self._finalize_candidate()
+        self._candidate = None
+
+
+def count_author_search_markers(html: str) -> dict[str, int]:
+    lowered = html.lower()
+    return {key: lowered.count(key.lower()) for key in AUTHOR_SEARCH_MARKER_KEYS}
diff --git a/build/lib/app/services/domains/scholar/parser.py b/build/lib/app/services/domains/scholar/parser.py
new file mode 100644
index 0000000..060e825
--- /dev/null
+++ b/build/lib/app/services/domains/scholar/parser.py
@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from app.services.domains.scholar.author_rows import (
+    ScholarAuthorSearchParser,
+    count_author_search_markers,
+    parse_scholar_id_from_href,
+)
+from app.services.domains.scholar.parser_constants import SCRIPT_STYLE_RE
+from app.services.domains.scholar.parser_types import (
+    ParseState,
+    ParsedAuthorSearchPage,
+    ParsedProfilePage,
+    PublicationCandidate,
+    ScholarDomInvariantError,
+    ScholarMalformedDataError,
+    ScholarParserError,
+    ScholarSearchCandidate,
+)
+from app.services.domains.scholar.parser_utils import (
+    strip_tags,
+)
+from app.services.domains.scholar.profile_rows import (
+    ScholarRowParser,
+    count_markers,
+    extract_articles_range,
+    extract_profile_image_url,
+    extract_profile_name,
+    extract_rows,
+    has_operation_error_banner,
+    has_show_more_button,
+    parse_citation_count,
+    parse_cluster_id_from_href,
+    parse_publications,
+    parse_year,
+)
+from app.services.domains.scholar.source import FetchResult
+from app.services.domains.scholar.state_detection import (
+    classify_block_or_captcha_reason,
+    classify_network_error_reason,
+    detect_author_search_state,
+    detect_state,
+)
+
+
+def _raise_dom_error(code: str, message: str) -> None:
+    raise ScholarDomInvariantError(code=code, message=message)
+
+
+def _assert_profile_dom_invariants(
+    *,
+    fetch_result: FetchResult,
+    marker_counts: dict[str, int],
+    publications: list[PublicationCandidate],
+    warnings: list[str],
+    has_show_more_button_flag: bool,
+    articles_range: str | None,
+) -> None:
+    if fetch_result.status_code is None:
+        return
+    final_url = (fetch_result.final_url or "").lower()
+    if "accounts.google.com" in final_url or "sorry/index" in final_url:
+        return
+    if any(code.startswith("layout_") for code in warnings):
+        reason = next(code for code in warnings if code.startswith("layout_"))
+        _raise_dom_error(reason, f"Detected layout warning: {reason}")
+    if has_show_more_button_flag and not articles_range:
+        _raise_dom_error(
+            "layout_show_more_without_articles_range",
+            "Show-more control exists without an articles range marker.",
+        )
+    if marker_counts.get("gsc_a_tr", 0) > 0 and marker_counts.get("gsc_a_at", 0) <= 0:
+        _raise_dom_error(
+            "layout_missing_publication_title_anchor",
+            "Publication rows were present but title anchors were absent.",
+        )
+    if not publications:
+        has_profile_markers = marker_counts.get("gsc_prf_in", 0) > 0
+        has_table_markers = marker_counts.get("gsc_a_tr", 0) > 0 or marker_counts.get("gsc_a_at", 0) > 0
+        if not has_profile_markers and not has_table_markers:
+            _raise_dom_error("layout_markers_missing", "Expected scholar profile markers were absent.")
+    for publication in publications:
+        if not publication.title.strip():
+            raise ScholarMalformedDataError(
+                code="malformed_publication_title",
+                message="Encountered a publication candidate with an empty title.",
+            )
+        if publication.citation_count is not None and int(publication.citation_count) < 0:
+            raise ScholarMalformedDataError(
+                code="malformed_publication_negative_citations",
+                message="Encountered a publication candidate with negative citations.",
+            )
+
+
+def parse_profile_page(fetch_result: FetchResult) -> ParsedProfilePage:
+    publications, warnings = parse_publications(fetch_result.body)
+    marker_counts = count_markers(fetch_result.body)
+    visible_text = strip_tags(SCRIPT_STYLE_RE.sub(" ", fetch_result.body)).lower()
+
+    show_more = has_show_more_button(fetch_result.body)
+    operation_error_banner = has_operation_error_banner(fetch_result.body)
+    articles_range = extract_articles_range(fetch_result.body)
+
+    if show_more:
+        warnings.append("possible_partial_page_show_more_present")
+    if operation_error_banner:
+        warnings.append("operation_error_banner_present")
+
+    warnings = sorted(set(warnings))
+    _assert_profile_dom_invariants(
+        fetch_result=fetch_result,
+        marker_counts=marker_counts,
+        publications=publications,
+        warnings=warnings,
+        has_show_more_button_flag=show_more,
+        articles_range=articles_range,
+    )
+
+    state, state_reason = detect_state(
+        fetch_result,
+        publications,
+        marker_counts,
+        warnings=warnings,
+        has_show_more_button_flag=show_more,
+        articles_range=articles_range,
+        visible_text=visible_text,
+    )
+
+    return ParsedProfilePage(
+        state=state,
+        state_reason=state_reason,
+        profile_name=extract_profile_name(fetch_result.body),
+        profile_image_url=extract_profile_image_url(fetch_result.body),
+        publications=publications,
+        marker_counts=marker_counts,
+        warnings=warnings,
+        has_show_more_button=show_more,
+        has_operation_error_banner=operation_error_banner,
+        articles_range=articles_range,
+    )
+
+
+def parse_author_search_page(fetch_result: FetchResult) -> ParsedAuthorSearchPage:
+    parser = ScholarAuthorSearchParser()
+    parser.feed(fetch_result.body)
+
+    marker_counts = count_author_search_markers(fetch_result.body)
+    visible_text = strip_tags(SCRIPT_STYLE_RE.sub(" ", fetch_result.body)).lower()
+    warnings: list[str] = []
+    if not parser.candidates:
+        warnings.append("no_author_candidates_detected")
+
+    state, state_reason = detect_author_search_state(
+        fetch_result,
+        parser.candidates,
+        marker_counts,
+        visible_text=visible_text,
+    )
+
+    return ParsedAuthorSearchPage(
+        state=state,
+        state_reason=state_reason,
+        candidates=parser.candidates,
+        marker_counts=marker_counts,
+        warnings=warnings,
+    )
diff --git a/build/lib/app/services/domains/scholar/parser_constants.py b/build/lib/app/services/domains/scholar/parser_constants.py
new file mode 100644
index 0000000..c3c7a15
--- /dev/null
+++ b/build/lib/app/services/domains/scholar/parser_constants.py
@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import re
+
+BLOCKED_KEYWORDS = [
+    "unusual traffic",
+    "sorry/index",
+    "not a robot",
+    "our systems have detected",
+    "automated queries",
+    "recaptcha",
+    "captcha",
+]
+
+NO_RESULTS_KEYWORDS = [
+    "didn't match any articles",
+    "did not match any articles",
+    "no articles",
+    "no documents",
+]
+
+NO_AUTHOR_RESULTS_KEYWORDS = [
+    "didn't match any user profiles",
+    "did not match any user profiles",
+    "didn't match any scholars",
+    "did not match any scholars",
+    "no user profiles",
+]
+
+MARKER_KEYS = [
+    "gsc_a_tr",
+    "gsc_a_at",
+    "gsc_a_ac",
+    "gsc_a_h",
+    "gsc_a_y",
+    "gs_gray",
+    "gsc_prf_in",
+    "gsc_rsb_st",
+]
+
+AUTHOR_SEARCH_MARKER_KEYS = [
+    "gsc_1usr",
+    "gs_ai_name",
+    "gs_ai_aff",
+    "gs_ai_eml",
+    "gs_ai_cby",
+    "gs_ai_one_int",
+]
+
+NETWORK_DNS_ERROR_KEYWORDS = [
+    "temporary failure in name resolution",
+    "name or service not known",
+    "nodename nor servname provided",
+    "getaddrinfo failed",
+]
+
+NETWORK_TIMEOUT_KEYWORDS = [
+    "timed out",
+    "timeout",
+]
+
+NETWORK_TLS_ERROR_KEYWORDS = [
+    "ssl",
+    "tls",
+    "certificate verify failed",
+]
+
+TAG_RE = re.compile(r"<[^>]+>", re.S)
+SCRIPT_STYLE_RE = re.compile(r"<(script|style)\b[^>]*>.*?</\1>", re.I | re.S)
+SHOW_MORE_BUTTON_RE = re.compile(
+    r"<button\b[^>]*\bid\s*=\s*['\"]gsc_bpf_more['\"][^>]*>",
+    re.I | re.S,
+)
+
+PROFILE_ROW_PARSER_DIRECT_MARKERS = (
+    "gs_ggs",
+    "gs_ggsd",
+    "gs_ggsa",
+    "gs_or_ggsm",
+)
+
+PROFILE_ROW_DIRECT_LABEL_TOKENS = (
+    "pdf",
+    "[pdf]",
+    "full text",
+    "download",
+)
diff --git a/build/lib/app/services/domains/scholar/parser_types.py b/build/lib/app/services/domains/scholar/parser_types.py
new file mode 100644
index 0000000..7b657d8
--- /dev/null
+++ b/build/lib/app/services/domains/scholar/parser_types.py
@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class ParseState(StrEnum):
+    OK = "ok"
+    NO_RESULTS = "no_results"
+    BLOCKED_OR_CAPTCHA = "blocked_or_captcha"
+    LAYOUT_CHANGED = "layout_changed"
+    NETWORK_ERROR = "network_error"
+
+
+class ScholarParserError(RuntimeError):
+    code: str
+
+    def __init__(self, *, code: str, message: str) -> None:
+        super().__init__(message)
+        self.code = code
+
+
+class ScholarDomInvariantError(ScholarParserError):
+    pass
+
+
+class ScholarMalformedDataError(ScholarParserError):
+    pass
+
+
+@dataclass(frozen=True)
+class PublicationCandidate:
+    title: str
+    title_url: str | None
+    cluster_id: str | None
+    year: int | None
+    citation_count: int | None
+    authors_text: str | None
+    venue_text: str | None
+    pdf_url: str | None
+
+
+@dataclass(frozen=True)
+class ScholarSearchCandidate:
+    scholar_id: str
+    display_name: str
+    affiliation: str | None
+    email_domain: str | None
+    cited_by_count: int | None
+    interests: list[str]
+    profile_url: str
+    profile_image_url: str | None
+
+
+@dataclass(frozen=True)
+class ParsedProfilePage:
+    state: ParseState
+    state_reason: str
+    profile_name: str | None
+    profile_image_url: str | None
+    publications: list[PublicationCandidate]
+    marker_counts: dict[str, int]
+    warnings: list[str]
+    has_show_more_button: bool
+    has_operation_error_banner: bool
+    articles_range: str | None
+
+
+@dataclass(frozen=True)
+class ParsedAuthorSearchPage:
+    state: ParseState
+    state_reason: str
+    candidates: list[ScholarSearchCandidate]
+    marker_counts: dict[str, int]
+    warnings: list[str]
diff --git a/build/lib/app/services/domains/scholar/parser_utils.py b/build/lib/app/services/domains/scholar/parser_utils.py
new file mode 100644
index 0000000..1bf8687
--- /dev/null
+++ b/build/lib/app/services/domains/scholar/parser_utils.py
@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from html import unescape
+
+from app.services.domains.scholar.parser_constants import TAG_RE
+
+
+def normalize_space(value: str) -> str:
+    return " ".join(unescape(value).split())
+
+
+def strip_tags(value: str) -> str:
+    return normalize_space(TAG_RE.sub(" ", value))
+
+
+def attr_class(attrs: list[tuple[str, str | None]]) -> str:
+    for name, raw_value in attrs:
+        if name.lower() == "class":
+            return raw_value or ""
+    return ""
+
+
+def attr_href(attrs: list[tuple[str, str | None]]) -> str | None:
+    for name, raw_value in attrs:
+        if name.lower() == "href":
+            return raw_value
+    return None
+
+
+def attr_src(attrs: list[tuple[str, str | None]]) -> str | None:
+    for name, raw_value in attrs:
+        if name.lower() == "src":
+            return raw_value
+    return None
+
+
+def build_absolute_scholar_url(path_or_url: str | None) -> str | None:
+    if not path_or_url:
+        return None
+    from urllib.parse import urljoin
+
+    return urljoin("https://scholar.google.com", path_or_url)
diff --git a/build/lib/app/services/domains/scholar/profile_rows.py b/build/lib/app/services/domains/scholar/profile_rows.py
new file mode 100644
index 0000000..6a63274
--- /dev/null
+++ b/build/lib/app/services/domains/scholar/profile_rows.py
@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import re
+from html.parser import HTMLParser
+from urllib.parse import parse_qs, urlparse
+
+from app.services.domains.scholar.parser_constants import (
+    MARKER_KEYS,
+    SHOW_MORE_BUTTON_RE,
+)
+from app.services.domains.scholar.parser_types import PublicationCandidate
+from app.services.domains.scholar.parser_utils import (
+    attr_class,
+    attr_href,
+    attr_src,
+    build_absolute_scholar_url,
+    normalize_space,
+    strip_tags,
+)
+
+
+class ScholarRowParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.title_href: str | None = None
+        self.title_parts: list[str] = []
+        self.citation_parts: list[str] = []
+        self.year_parts: list[str] = []
+        self.gray_texts: list[str] = []
+
+        self._title_depth = 0
+        self._citation_depth = 0
+        self._year_depth = 0
+        self._gray_stack: list[dict[str, object]] = []
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if self._title_depth > 0:
+            self._title_depth += 1
+        if self._citation_depth > 0:
+            self._citation_depth += 1
+        if self._year_depth > 0:
+            self._year_depth += 1
+        if self._gray_stack:
+            self._gray_stack[-1]["depth"] += 1
+
+        classes = attr_class(attrs)
+
+        if tag == "a" and "gsc_a_at" in classes:
+            self._title_depth = 1
+            self.title_href = attr_href(attrs)
+            return
+
+        if tag == "a" and "gsc_a_ac" in classes:
+            self._citation_depth = 1
+            return
+
+        if tag in {"span", "a"} and ("gsc_a_h" in classes or "gsc_a_y" in classes):
+            self._year_depth = 1
+            return
+
+        if tag == "div" and "gs_gray" in classes:
+            self._gray_stack.append({"depth": 1, "parts": []})
+            return
+
+    def handle_data(self, data: str) -> None:
+        if self._title_depth > 0:
+            self.title_parts.append(data)
+        if self._citation_depth > 0:
+            self.citation_parts.append(data)
+        if self._year_depth > 0:
+            self.year_parts.append(data)
+        if self._gray_stack:
+            self._gray_stack[-1]["parts"].append(data)
+
+    def handle_endtag(self, tag: str) -> None:
+        if self._title_depth > 0:
+            self._title_depth -= 1
+        if self._citation_depth > 0:
+            self._citation_depth -= 1
+        if self._year_depth > 0:
+            self._year_depth -= 1
+        if self._gray_stack:
+            self._gray_stack[-1]["depth"] -= 1
+            if self._gray_stack[-1]["depth"] == 0:
+                text_value = normalize_space("".join(self._gray_stack[-1]["parts"]))
+                if text_value:
+                    self.gray_texts.append(text_value)
+                self._gray_stack.pop()
+
+
+def extract_rows(html: str) -> list[str]:
+    pattern = re.compile(
+        r"<tr\b(?=[^>]*\bclass\s*=\s*['\"][^'\"]*\bgsc_a_tr\b[^'\"]*['\"])[^>]*>(.*?)</tr>",
+        re.I | re.S,
+    )
+    return [match.group(1) for match in pattern.finditer(html)]
+
+
+def parse_cluster_id_from_href(href: str | None) -> str | None:
+    if not href:
+        return None
+    parsed = urlparse(href)
+    query = parse_qs(parsed.query)
+
+    citation_for_view = query.get("citation_for_view")
+    if citation_for_view:
+        token = citation_for_view[0].strip()
+        if token:
+            return f"cfv:{token}"
+
+    cluster = query.get("cluster")
+    if cluster:
+        token = cluster[0].strip()
+        if token:
+            return f"cluster:{token}"
+    return None
+
+
+def parse_year(parts: list[str]) -> int | None:
+    text = normalize_space(" ".join(parts))
+    match = re.search(r"\b(19|20)\d{2}\b", text)
+    if not match:
+        return None
+    try:
+        return int(match.group(0))
+    except ValueError:
+        return None
+
+
+def parse_citation_count(parts: list[str]) -> int | None:
+    text = normalize_space(" ".join(parts))
+    if not text:
+        return 0
+    digits = re.sub(r"\D+", "", text)
+    if not digits:
+        return None
+    return int(digits)
+
+
+def _parse_publication_row(row_html: str) -> tuple[PublicationCandidate | None, list[str]]:
+    parser = ScholarRowParser()
+    parser.feed(row_html)
+    warnings: list[str] = []
+    title = normalize_space("".join(parser.title_parts))
+    if not title:
+        warnings.append("row_missing_title")
+        return None, warnings
+    if not parser.title_href:
+        warnings.append("row_missing_title_href")
+
+    citation_text = normalize_space(" ".join(parser.citation_parts))
+    citation_count = parse_citation_count(parser.citation_parts)
+    if citation_text and citation_count is None:
+        warnings.append("layout_row_citation_unparseable")
+
+    year_text = normalize_space(" ".join(parser.year_parts))
+    year = parse_year(parser.year_parts)
+    if year_text and year is None:
+        warnings.append("layout_row_year_unparseable")
+
+    authors_text = parser.gray_texts[0] if len(parser.gray_texts) > 0 else None
+    venue_text = parser.gray_texts[1] if len(parser.gray_texts) > 1 else None
+    return (
+        PublicationCandidate(
+            title=title,
+            title_url=parser.title_href,
+            cluster_id=parse_cluster_id_from_href(parser.title_href),
+            year=year,
+            citation_count=citation_count,
+            authors_text=authors_text,
+            venue_text=venue_text,
+            pdf_url=None,
+        ),
+        warnings,
+    )
+
+
+def parse_publications(html: str) -> tuple[list[PublicationCandidate], list[str]]:
+    rows = extract_rows(html)
+    warnings: list[str] = []
+    publications: list[PublicationCandidate] = []
+
+    for row_html in rows:
+        publication, row_warnings = _parse_publication_row(row_html)
+        warnings.extend(row_warnings)
+        if publication is None:
+            continue
+        publications.append(publication)
+
+    if not rows:
+        warnings.append("no_rows_detected")
+    if rows and not publications:
+        warnings.append("layout_all_rows_unparseable")
+
+    return publications, sorted(set(warnings))
+
+
+def extract_profile_name(html: str) -> str | None:
+    pattern = re.compile(
+        r"<[^>]*\bid\s*=\s*['\"]gsc_prf_in['\"][^>]*>(.*?)</[^>]+>",
+        re.I | re.S,
+    )
+    match = pattern.search(html)
+    if not match:
+        return None
+    value = strip_tags(match.group(1))
+    return value or None
+
+
+def extract_profile_image_url(html: str) -> str | None:
+    og_image_pattern = re.compile(
+        r"<meta[^>]+property=['\"]og:image['\"][^>]+content=['\"]([^'\"]+)['\"][^>]*>",
+        re.I | re.S,
+    )
+    og_match = og_image_pattern.search(html)
+    if og_match:
+        value = normalize_space(og_match.group(1))
+        absolute = build_absolute_scholar_url(value)
+        if absolute:
+            return absolute
+
+    image_pattern = re.compile(
+        r"<img[^>]*\bid=['\"]gsc_prf_pup-img['\"][^>]*\bsrc=['\"]([^'\"]+)['\"][^>]*>",
+        re.I | re.S,
+    )
+    image_match = image_pattern.search(html)
+    if not image_match:
+        return None
+
+    value = normalize_space(image_match.group(1))
+    return build_absolute_scholar_url(value)
+
+
+def extract_articles_range(html: str) -> str | None:
+    pattern = re.compile(
+        r"<[^>]*\bid\s*=\s*['\"]gsc_a_nn['\"][^>]*>(.*?)</[^>]+>",
+        re.I | re.S,
+    )
+    match = pattern.search(html)
+    if not match:
+        return None
+    value = strip_tags(match.group(1))
+    return value or None
+
+
+def has_show_more_button(html: str) -> bool:
+    match = SHOW_MORE_BUTTON_RE.search(html)
+    if match is None:
+        return False
+
+    button_tag = match.group(0).lower()
+    if "disabled" in button_tag:
+        return False
+    if 'aria-disabled="true"' in button_tag or "aria-disabled='true'" in button_tag:
+        return False
+    if "gs_dis" in button_tag:
+        return False
+    return True
+
+
+def has_operation_error_banner(html: str) -> bool:
+    lowered = html.lower()
+    if "id=\"gsc_a_err\"" not in lowered and "id='gsc_a_err'" not in lowered:
+        return False
+    return "can't perform the operation now" in lowered or "cannot perform the operation now" in lowered
+
+
+def count_markers(html: str) -> dict[str, int]:
+    lowered = html.lower()
+    return {key: lowered.count(key.lower()) for key in MARKER_KEYS}
diff --git a/build/lib/app/services/domains/scholar/rate_limit.py b/build/lib/app/services/domains/scholar/rate_limit.py
new file mode 100644
index 0000000..947c91f
--- /dev/null
+++ b/build/lib/app/services/domains/scholar/rate_limit.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import asyncio
+import time
+
+_REQUEST_LOCK = asyncio.Lock()
+_LAST_REQUEST_AT = 0.0
+
+
+async def wait_for_scholar_slot(*, min_interval_seconds: float) -> None:
+    global _LAST_REQUEST_AT
+    interval = max(float(min_interval_seconds), 0.0)
+    async with _REQUEST_LOCK:
+        elapsed = time.monotonic() - _LAST_REQUEST_AT
+        remaining = interval - elapsed
+        if remaining > 0:
+            await asyncio.sleep(remaining)
+        _LAST_REQUEST_AT = time.monotonic()
diff --git a/build/lib/app/services/domains/scholar/source.py b/build/lib/app/services/domains/scholar/source.py
new file mode 100644
index 0000000..92c6702
--- /dev/null
+++ b/build/lib/app/services/domains/scholar/source.py
@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import random
+from dataclasses import dataclass
+from typing import Protocol
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+SCHOLAR_PROFILE_URL = "https://scholar.google.com/citations"
+DEFAULT_PAGE_SIZE = 100
+
+DEFAULT_USER_AGENTS = [
+    (
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+    ),
+    (
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7) AppleWebKit/605.1.15 "
+        "(KHTML, like Gecko) Version/18.1 Safari/605.1.15"
+    ),
+    (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) "
+        "Gecko/20100101 Firefox/131.0"
+    ),
+]
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class FetchResult:
+    requested_url: str
+    status_code: int | None
+    final_url: str | None
+    body: str
+    error: str | None
+
+
+class ScholarSource(Protocol):
+    async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
+        ...
+
+    async def fetch_profile_page_html(
+        self,
+        scholar_id: str,
+        *,
+        cstart: int,
+        pagesize: int,
+    ) -> FetchResult:
+        ...
+
+    async def fetch_author_search_html(
+        self,
+        query: str,
+        *,
+        start: int,
+    ) -> FetchResult:
+        ...
+
+
+class LiveScholarSource:
+    def __init__(
+        self,
+        *,
+        timeout_seconds: float = 25.0,
+        user_agents: list[str] | None = None,
+    ) -> None:
+        self._timeout_seconds = timeout_seconds
+        self._user_agents = user_agents or DEFAULT_USER_AGENTS
+
+    async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
+        return await self.fetch_profile_page_html(
+            scholar_id,
+            cstart=0,
+            pagesize=DEFAULT_PAGE_SIZE,
+        )
+
+    async def fetch_profile_page_html(
+        self,
+        scholar_id: str,
+        *,
+        cstart: int,
+        pagesize: int = DEFAULT_PAGE_SIZE,
+    ) -> FetchResult:
+        requested_url = _build_profile_url(
+            scholar_id=scholar_id,
+            cstart=cstart,
+            pagesize=pagesize,
+        )
+        logger.debug(
+            "scholar_source.fetch_started",
+            extra={
+                "event": "scholar_source.fetch_started",
+                "scholar_id": scholar_id,
+                "requested_url": requested_url,
+                "cstart": cstart,
+                "pagesize": pagesize,
+            },
+        )
+        return await asyncio.to_thread(self._fetch_sync, requested_url)
+
+    async def fetch_author_search_html(
+        self,
+        query: str,
+        *,
+        start: int = 0,
+    ) -> FetchResult:
+        requested_url = _build_author_search_url(
+            query=query,
+            start=start,
+        )
+        logger.debug(
+            "scholar_source.search_fetch_started",
+            extra={
+                "event": "scholar_source.search_fetch_started",
+                "query": query,
+                "requested_url": requested_url,
+                "start": start,
+            },
+        )
+        return await asyncio.to_thread(self._fetch_sync, requested_url)
+
+    async def fetch_publication_html(self, publication_url: str) -> FetchResult:
+        logger.debug(
+            "scholar_source.publication_fetch_started",
+            extra={
+                "event": "scholar_source.publication_fetch_started",
+                "requested_url": publication_url,
+            },
+        )
+        return await asyncio.to_thread(self._fetch_sync, publication_url)
+
+    def _build_request(self, requested_url: str) -> Request:
+        return Request(
+            requested_url,
+            headers={
+                "User-Agent": random.choice(self._user_agents),
+                "Accept": "text/html,application/xhtml+xml",
+                "Accept-Language": "en-US,en;q=0.9",
+                "Connection": "close",
+            },
+        )
+
+    @staticmethod
+    def _http_error_body(exc: HTTPError) -> str:
+        try:
+            return exc.read().decode("utf-8", errors="replace")
+        except Exception:
+            return ""
+
+    @staticmethod
+    def _network_error_result(requested_url: str, exc: URLError) -> FetchResult:
+        logger.warning(
+            "scholar_source.fetch_network_error",
+            extra={"event": "scholar_source.fetch_network_error", "requested_url": requested_url},
+        )
+        return FetchResult(
+            requested_url=requested_url,
+            status_code=None,
+            final_url=None,
+            body="",
+            error=str(exc),
+        )
+
+    @staticmethod
+    def _http_error_result(requested_url: str, exc: HTTPError) -> FetchResult:
+        logger.warning(
+            "scholar_source.fetch_http_error",
+            extra={
+                "event": "scholar_source.fetch_http_error",
+                "requested_url": requested_url,
+                "status_code": exc.code,
+            },
+        )
+        return FetchResult(
+            requested_url=requested_url,
+            status_code=exc.code,
+            final_url=exc.geturl(),
+            body=LiveScholarSource._http_error_body(exc),
+            error=str(exc),
+        )
+
+    @staticmethod
+    def _success_result(requested_url: str, response) -> FetchResult:
+        body = response.read().decode("utf-8", errors="replace")
+        status_code = getattr(response, "status", 200)
+        logger.debug(
+            "scholar_source.fetch_succeeded",
+            extra={
+                "event": "scholar_source.fetch_succeeded",
+                "requested_url": requested_url,
+                "status_code": status_code,
+            },
+        )
+        return FetchResult(
+            requested_url=requested_url,
+            status_code=status_code,
+            final_url=response.geturl(),
+            body=body,
+            error=None,
+        )
+
+    def _fetch_sync(self, requested_url: str) -> FetchResult:
+        request = self._build_request(requested_url)
+
+        try:
+            with urlopen(request, timeout=self._timeout_seconds) as response:
+                return self._success_result(requested_url, response)
+        except HTTPError as exc:
+            return self._http_error_result(requested_url, exc)
+        except URLError as exc:
+            return self._network_error_result(requested_url, exc)
+
+
+def _build_profile_url(*, scholar_id: str, cstart: int, pagesize: int) -> str:
+    query: dict[str, int | str] = {"hl": "en", "user": scholar_id}
+    if cstart > 0:
+        query["cstart"] = int(cstart)
+    if pagesize > 0:
+        query["pagesize"] = int(pagesize)
+    return f"{SCHOLAR_PROFILE_URL}?{urlencode(query)}"
+
+
+def _build_author_search_url(*, query: str, start: int) -> str:
+    params: dict[str, int | str] = {
+        "hl": "en",
+        "view_op": "search_authors",
+        "mauthors": query,
+    }
+    if start > 0:
+        params["astart"] = int(start)
+    return f"{SCHOLAR_PROFILE_URL}?{urlencode(params)}"
diff --git a/build/lib/app/services/domains/scholar/state_detection.py b/build/lib/app/services/domains/scholar/state_detection.py
new file mode 100644
index 0000000..cdc8780
--- /dev/null
+++ b/build/lib/app/services/domains/scholar/state_detection.py
@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from app.services.domains.scholar.parser_constants import (
+    BLOCKED_KEYWORDS,
+    NETWORK_DNS_ERROR_KEYWORDS,
+    NETWORK_TIMEOUT_KEYWORDS,
+    NETWORK_TLS_ERROR_KEYWORDS,
+    NO_AUTHOR_RESULTS_KEYWORDS,
+    NO_RESULTS_KEYWORDS,
+)
+from app.services.domains.scholar.parser_types import ParseState, PublicationCandidate, ScholarSearchCandidate
+from app.services.domains.scholar.source import FetchResult
+
+
+def classify_network_error_reason(fetch_error: str | None) -> str:
+    lowered = (fetch_error or "").lower()
+    if lowered:
+        if any(keyword in lowered for keyword in NETWORK_DNS_ERROR_KEYWORDS):
+            return "network_dns_resolution_failed"
+        if any(keyword in lowered for keyword in NETWORK_TIMEOUT_KEYWORDS):
+            return "network_timeout"
+        if any(keyword in lowered for keyword in NETWORK_TLS_ERROR_KEYWORDS):
+            return "network_tls_error"
+        if "connection reset" in lowered:
+            return "network_connection_reset"
+        if "connection refused" in lowered:
+            return "network_connection_refused"
+        if "network is unreachable" in lowered:
+            return "network_unreachable"
+    return "network_error_missing_status_code"
+
+
+def classify_block_or_captcha_reason(
+    *,
+    status_code: int,
+    final_url: str,
+    body_lowered: str,
+) -> str | None:
+    if "accounts.google.com" in final_url and ("signin" in final_url or "servicelogin" in final_url):
+        return "blocked_accounts_redirect"
+    if status_code == 429:
+        return "blocked_http_429_rate_limited"
+    if status_code == 403:
+        if "recaptcha" in body_lowered or "captcha" in body_lowered or "sorry/index" in final_url:
+            return "blocked_http_403_captcha_challenge"
+        return "blocked_http_403_forbidden"
+    if "sorry/index" in final_url or "sorry/index" in body_lowered:
+        return "blocked_google_sorry_challenge"
+    if "our systems have detected" in body_lowered or "unusual traffic" in body_lowered:
+        return "blocked_unusual_traffic_detected"
+    if "automated queries" in body_lowered:
+        return "blocked_automated_queries_detected"
+    if "not a robot" in body_lowered:
+        return "blocked_not_a_robot_challenge"
+    if "recaptcha" in body_lowered:
+        return "blocked_recaptcha_challenge"
+    if "captcha" in body_lowered:
+        return "blocked_captcha_challenge"
+    if any(keyword in body_lowered for keyword in BLOCKED_KEYWORDS):
+        return "blocked_keyword_detected"
+    return None
+
+
+def _warnings_contain(warnings: list[str], code: str) -> bool:
+    return any(item == code for item in warnings)
+
+
+def _has_layout_row_failure(marker_counts: dict[str, int], warnings: list[str]) -> bool:
+    if _warnings_contain(warnings, "layout_all_rows_unparseable"):
+        return True
+    if marker_counts.get("gsc_a_tr", 0) <= 0:
+        return False
+    if _warnings_contain(warnings, "row_missing_title"):
+        return True
+    return marker_counts.get("gsc_a_at", 0) <= 0
+
+
+def _first_layout_warning(warnings: list[str]) -> str | None:
+    for warning in warnings:
+        if warning.startswith("layout_"):
+            return warning
+    return None
+
+
+def detect_state(
+    fetch_result: FetchResult,
+    publications: list[PublicationCandidate],
+    marker_counts: dict[str, int],
+    *,
+    warnings: list[str],
+    has_show_more_button_flag: bool,
+    articles_range: str | None,
+    visible_text: str,
+) -> tuple[ParseState, str]:
+    if fetch_result.status_code is None:
+        return ParseState.NETWORK_ERROR, classify_network_error_reason(fetch_result.error)
+
+    lowered = fetch_result.body.lower()
+    final = (fetch_result.final_url or "").lower()
+    status_code = int(fetch_result.status_code)
+
+    block_reason = classify_block_or_captcha_reason(
+        status_code=status_code,
+        final_url=final,
+        body_lowered=lowered,
+    )
+    if block_reason is not None:
+        return ParseState.BLOCKED_OR_CAPTCHA, block_reason
+
+    if not publications and any(keyword in visible_text for keyword in NO_RESULTS_KEYWORDS):
+        return ParseState.NO_RESULTS, "no_results_keyword_detected"
+
+    layout_warning = _first_layout_warning(warnings)
+    if layout_warning is not None:
+        return ParseState.LAYOUT_CHANGED, layout_warning
+
+    if _has_layout_row_failure(marker_counts, warnings):
+        return ParseState.LAYOUT_CHANGED, "layout_publication_rows_unparseable"
+
+    if has_show_more_button_flag and not articles_range:
+        return ParseState.LAYOUT_CHANGED, "layout_show_more_without_articles_range"
+
+    if not publications:
+        has_profile_markers = marker_counts.get("gsc_prf_in", 0) > 0
+        has_table_markers = marker_counts.get("gsc_a_tr", 0) > 0 or marker_counts.get("gsc_a_at", 0) > 0
+        if not has_profile_markers and not has_table_markers:
+            return ParseState.LAYOUT_CHANGED, "layout_markers_missing"
+        return ParseState.OK, "no_rows_with_known_markers"
+
+    return ParseState.OK, "publications_extracted"
+
+
+def detect_author_search_state(
+    fetch_result: FetchResult,
+    candidates: list[ScholarSearchCandidate],
+    marker_counts: dict[str, int],
+    *,
+    visible_text: str,
+) -> tuple[ParseState, str]:
+    if fetch_result.status_code is None:
+        return ParseState.NETWORK_ERROR, classify_network_error_reason(fetch_result.error)
+
+    lowered = fetch_result.body.lower()
+    final = (fetch_result.final_url or "").lower()
+    status_code = int(fetch_result.status_code)
+
+    block_reason = classify_block_or_captcha_reason(
+        status_code=status_code,
+        final_url=final,
+        body_lowered=lowered,
+    )
+    if block_reason is not None:
+        return ParseState.BLOCKED_OR_CAPTCHA, block_reason
+
+    if not candidates and any(keyword in visible_text for keyword in NO_AUTHOR_RESULTS_KEYWORDS):
+        return ParseState.NO_RESULTS, "no_results_keyword_detected"
+
+    if not candidates:
+        has_search_markers = marker_counts.get("gsc_1usr", 0) > 0 or marker_counts.get("gs_ai_name", 0) > 0
+        if not has_search_markers:
+            return ParseState.NO_RESULTS, "no_search_candidates_detected"
+        return ParseState.LAYOUT_CHANGED, "layout_author_candidates_unparseable"
+
+    return ParseState.OK, "author_candidates_extracted"
diff --git a/build/lib/app/services/domains/scholars/__init__.py b/build/lib/app/services/domains/scholars/__init__.py
new file mode 100644
index 0000000..9d48db4
--- /dev/null
+++ b/build/lib/app/services/domains/scholars/__init__.py
@@ -0,0 +1 @@
+from __future__ import annotations
diff --git a/build/lib/app/services/domains/scholars/application.py b/build/lib/app/services/domains/scholars/application.py
new file mode 100644
index 0000000..8da041f
--- /dev/null
+++ b/build/lib/app/services/domains/scholars/application.py
@@ -0,0 +1,974 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import replace
+from datetime import datetime
+from datetime import timedelta
+from datetime import timezone
+import logging
+import os
+import random
+from uuid import uuid4
+
+from sqlalchemy import delete, func, select, text
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import AuthorSearchCacheEntry, AuthorSearchRuntimeState, ScholarProfile
+from app.services.domains.scholar.parser import (
+    ParseState,
+    ParsedAuthorSearchPage,
+    ScholarParserError,
+    parse_author_search_page,
+    parse_profile_page,
+)
+from app.services.domains.scholar.source import ScholarSource
+from app.services.domains.scholars.constants import (
+    ALLOWED_IMAGE_UPLOAD_CONTENT_TYPES,
+    AUTHOR_SEARCH_LOCK_KEY,
+    AUTHOR_SEARCH_LOCK_NAMESPACE,
+    AUTHOR_SEARCH_RUNTIME_STATE_KEY,
+    DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS,
+    DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES,
+    DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD,
+    DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD,
+    DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS,
+    DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS,
+    MAX_AUTHOR_SEARCH_LIMIT,
+    DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS,
+    DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD,
+    SEARCH_CACHED_BLOCK_REASON,
+    SEARCH_COOLDOWN_REASON,
+    SEARCH_DISABLED_REASON,
+)
+from app.services.domains.scholars.exceptions import ScholarServiceError
+from app.services.domains.scholars.search_hints import (
+    _merge_warnings,
+    _policy_blocked_author_search_result,
+    _trim_author_search_result,
+    resolve_profile_image,
+    scrape_state_hint,
+)
+from app.services.domains.scholars.uploads import (
+    _ensure_upload_root,
+    _resolve_upload_path,
+    _safe_remove_upload,
+    resolve_upload_file_path,
+)
+from app.services.domains.scholars.validators import (
+    normalize_display_name,
+    normalize_profile_image_url,
+    validate_scholar_id,
+)
+logger = logging.getLogger(__name__)
+
+
+async def _acquire_author_search_lock(db_session: AsyncSession) -> None:
+    await db_session.execute(
+        text("SELECT pg_advisory_xact_lock(:namespace, :lock_key)"),
+        {
+            "namespace": AUTHOR_SEARCH_LOCK_NAMESPACE,
+            "lock_key": AUTHOR_SEARCH_LOCK_KEY,
+        },
+    )
+
+
+async def _load_runtime_state_for_update(
+    db_session: AsyncSession,
+) -> AuthorSearchRuntimeState:
+    result = await db_session.execute(
+        select(AuthorSearchRuntimeState)
+        .where(AuthorSearchRuntimeState.state_key == AUTHOR_SEARCH_RUNTIME_STATE_KEY)
+        .with_for_update()
+    )
+    state = result.scalar_one_or_none()
+    if state is not None:
+        return state
+
+    state = AuthorSearchRuntimeState(state_key=AUTHOR_SEARCH_RUNTIME_STATE_KEY)
+    db_session.add(state)
+    await db_session.flush()
+    return state
+
+
+def _serialize_parsed_author_search_page(parsed: ParsedAuthorSearchPage) -> dict:
+    return {
+        "state": parsed.state.value,
+        "state_reason": parsed.state_reason,
+        "marker_counts": {str(key): int(value) for key, value in parsed.marker_counts.items()},
+        "warnings": [str(value) for value in parsed.warnings],
+        "candidates": [
+            {
+                "scholar_id": candidate.scholar_id,
+                "display_name": candidate.display_name,
+                "affiliation": candidate.affiliation,
+                "email_domain": candidate.email_domain,
+                "cited_by_count": candidate.cited_by_count,
+                "interests": [str(interest) for interest in candidate.interests],
+                "profile_url": candidate.profile_url,
+                "profile_image_url": candidate.profile_image_url,
+            }
+            for candidate in parsed.candidates
+        ],
+    }
+
+
+def _payload_state(payload: dict[str, object]) -> ParseState | None:
+    state_raw = str(payload.get("state", "")).strip()
+    try:
+        return ParseState(state_raw)
+    except ValueError:
+        return None
+
+
+def _payload_marker_counts(payload: dict[str, object]) -> dict[str, int]:
+    marker_counts_payload = payload.get("marker_counts")
+    if not isinstance(marker_counts_payload, dict):
+        return {}
+    parsed: dict[str, int] = {}
+    for key, value in marker_counts_payload.items():
+        try:
+            parsed[str(key)] = int(value)
+        except (TypeError, ValueError):
+            continue
+    return parsed
+
+
+def _payload_warnings(payload: dict[str, object]) -> list[str]:
+    warnings_payload = payload.get("warnings")
+    if not isinstance(warnings_payload, list):
+        return []
+    return [str(value) for value in warnings_payload if isinstance(value, str)]
+
+
+def _parse_optional_string(value: object) -> str | None:
+    if value is None:
+        return None
+    normalized = str(value).strip()
+    return normalized or None
+
+
+def _parse_optional_int(value: object) -> int | None:
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str) and value.strip():
+        try:
+            return int(value)
+        except ValueError:
+            return None
+    return None
+
+
+def _normalize_interests(value: object) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(item) for item in value if isinstance(item, str)]
+
+
+def _deserialize_candidate_payload(value: object) -> dict[str, object] | None:
+    if not isinstance(value, dict):
+        return None
+    scholar_id = str(value.get("scholar_id", "")).strip()
+    display_name = str(value.get("display_name", "")).strip()
+    profile_url = str(value.get("profile_url", "")).strip()
+    if not scholar_id or not display_name or not profile_url:
+        return None
+    return {
+        "scholar_id": scholar_id,
+        "display_name": display_name,
+        "affiliation": _parse_optional_string(value.get("affiliation")),
+        "email_domain": _parse_optional_string(value.get("email_domain")),
+        "cited_by_count": _parse_optional_int(value.get("cited_by_count")),
+        "interests": _normalize_interests(value.get("interests")),
+        "profile_url": profile_url,
+        "profile_image_url": _parse_optional_string(value.get("profile_image_url")),
+    }
+
+
+def _deserialize_candidates(payload: dict[str, object]) -> list[dict[str, object]]:
+    candidates_payload = payload.get("candidates")
+    if not isinstance(candidates_payload, list):
+        return []
+    normalized: list[dict[str, object]] = []
+    for value in candidates_payload:
+        candidate = _deserialize_candidate_payload(value)
+        if candidate is not None:
+            normalized.append(candidate)
+    return normalized
+
+
+def _deserialize_parsed_author_search_page(payload: object) -> ParsedAuthorSearchPage | None:
+    if not isinstance(payload, dict):
+        return None
+
+    state = _payload_state(payload)
+    if state is None:
+        return None
+
+    marker_counts = _payload_marker_counts(payload)
+    warnings = _payload_warnings(payload)
+    from app.services.domains.scholar.parser import ScholarSearchCandidate
+
+    normalized_candidates = _deserialize_candidates(payload)
+
+    return ParsedAuthorSearchPage(
+        state=state,
+        state_reason=str(payload.get("state_reason", "")).strip() or "unknown",
+        candidates=[
+            ScholarSearchCandidate(
+                scholar_id=item["scholar_id"],
+                display_name=item["display_name"],
+                affiliation=item["affiliation"],
+                email_domain=item["email_domain"],
+                cited_by_count=item["cited_by_count"],
+                interests=item["interests"],
+                profile_url=item["profile_url"],
+                profile_image_url=item["profile_image_url"],
+            )
+            for item in normalized_candidates
+        ],
+        marker_counts=marker_counts,
+        warnings=warnings,
+    )
+
+
+async def _cache_get_author_search_result(
+    db_session: AsyncSession,
+    *,
+    query_key: str,
+    now_utc: datetime,
+) -> ParsedAuthorSearchPage | None:
+    result = await db_session.execute(
+        select(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key == query_key)
+    )
+    entry = result.scalar_one_or_none()
+    if entry is None:
+        return None
+    expires_at = entry.expires_at
+    if expires_at.tzinfo is None:
+        expires_at = expires_at.replace(tzinfo=timezone.utc)
+    if expires_at <= now_utc:
+        await db_session.delete(entry)
+        return None
+    parsed = _deserialize_parsed_author_search_page(entry.payload)
+    if parsed is None:
+        await db_session.delete(entry)
+        return None
+    return parsed
+
+
+async def _cache_set_author_search_result(
+    db_session: AsyncSession,
+    *,
+    query_key: str,
+    parsed: ParsedAuthorSearchPage,
+    ttl_seconds: float,
+    max_entries: int,
+    now_utc: datetime,
+) -> None:
+    ttl = max(float(ttl_seconds), 0.0)
+    existing_result = await db_session.execute(
+        select(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key == query_key)
+    )
+    existing = existing_result.scalar_one_or_none()
+
+    if ttl <= 0.0:
+        if existing is not None:
+            await db_session.delete(existing)
+        return
+
+    expires_at = now_utc + timedelta(seconds=ttl)
+    payload = _serialize_parsed_author_search_page(parsed)
+    if existing is None:
+        db_session.add(
+            AuthorSearchCacheEntry(
+                query_key=query_key,
+                payload=payload,
+                expires_at=expires_at,
+                cached_at=now_utc,
+                updated_at=now_utc,
+            )
+        )
+    else:
+        existing.payload = payload
+        existing.expires_at = expires_at
+        existing.cached_at = now_utc
+        existing.updated_at = now_utc
+
+    await _prune_author_search_cache(db_session, now_utc=now_utc, max_entries=max_entries)
+
+
+async def _prune_author_search_cache(
+    db_session: AsyncSession,
+    *,
+    now_utc: datetime,
+    max_entries: int,
+) -> None:
+    await db_session.execute(
+        delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.expires_at <= now_utc)
+    )
+    bounded_max_entries = max(1, int(max_entries))
+    count_result = await db_session.execute(
+        select(func.count()).select_from(AuthorSearchCacheEntry)
+    )
+    entry_count = int(count_result.scalar_one() or 0)
+    overflow = max(0, entry_count - bounded_max_entries)
+    if overflow <= 0:
+        return
+    stale_keys_result = await db_session.execute(
+        select(AuthorSearchCacheEntry.query_key)
+        .order_by(AuthorSearchCacheEntry.cached_at.asc())
+        .limit(overflow)
+    )
+    stale_keys = [str(row[0]) for row in stale_keys_result.all()]
+    if stale_keys:
+        await db_session.execute(
+            delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key.in_(stale_keys))
+        )
+
+
+def _is_author_search_block_state(parsed: ParsedAuthorSearchPage) -> bool:
+    return parsed.state == ParseState.BLOCKED_OR_CAPTCHA
+
+
+def _author_search_cooldown_remaining_seconds(
+    runtime_state: AuthorSearchRuntimeState,
+    now_utc: datetime,
+) -> int:
+    cooldown_until = runtime_state.cooldown_until
+    if cooldown_until is None:
+        return 0
+    if cooldown_until.tzinfo is None:
+        cooldown_until = cooldown_until.replace(tzinfo=timezone.utc)
+    remaining_seconds = int((cooldown_until - now_utc).total_seconds())
+    return max(0, remaining_seconds)
+
+
+async def list_scholars_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+) -> list[ScholarProfile]:
+    result = await db_session.execute(
+        select(ScholarProfile)
+        .where(ScholarProfile.user_id == user_id)
+        .order_by(ScholarProfile.created_at.desc(), ScholarProfile.id.desc())
+    )
+    return list(result.scalars().all())
+
+
+async def create_scholar_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_id: str,
+    display_name: str,
+    profile_image_url: str | None = None,
+) -> ScholarProfile:
+    profile = ScholarProfile(
+        user_id=user_id,
+        scholar_id=validate_scholar_id(scholar_id),
+        display_name=normalize_display_name(display_name),
+        profile_image_url=normalize_profile_image_url(profile_image_url),
+    )
+    db_session.add(profile)
+    try:
+        await db_session.commit()
+    except IntegrityError as exc:
+        await db_session.rollback()
+        raise ScholarServiceError("That scholar is already tracked for this account.") from exc
+    await db_session.refresh(profile)
+    return profile
+
+
+async def get_user_scholar_by_id(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int,
+) -> ScholarProfile | None:
+    result = await db_session.execute(
+        select(ScholarProfile).where(
+            ScholarProfile.id == scholar_profile_id,
+            ScholarProfile.user_id == user_id,
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+async def toggle_scholar_enabled(
+    db_session: AsyncSession,
+    *,
+    profile: ScholarProfile,
+) -> ScholarProfile:
+    profile.is_enabled = not profile.is_enabled
+    await db_session.commit()
+    await db_session.refresh(profile)
+    return profile
+
+
+async def delete_scholar(
+    db_session: AsyncSession,
+    *,
+    profile: ScholarProfile,
+    upload_dir: str | None = None,
+) -> None:
+    if upload_dir:
+        upload_root = _ensure_upload_root(upload_dir, create=True)
+        _safe_remove_upload(upload_root, profile.profile_image_upload_path)
+
+    await db_session.delete(profile)
+    await db_session.commit()
+
+
+def _normalize_author_search_inputs(query: str, limit: int) -> tuple[str, int, str]:
+    normalized_query = query.strip()
+    if len(normalized_query) < 2:
+        raise ScholarServiceError("Search query must be at least 2 characters.")
+    bounded_limit = max(1, min(int(limit), MAX_AUTHOR_SEARCH_LIMIT))
+    return normalized_query, bounded_limit, normalized_query.casefold()
+
+
+def _disabled_search_result(*, normalized_query: str, bounded_limit: int) -> ParsedAuthorSearchPage:
+    logger.warning(
+        "scholar_search.disabled_by_configuration",
+        extra={"event": "scholar_search.disabled_by_configuration", "query": normalized_query},
+    )
+    return _policy_blocked_author_search_result(
+        reason=SEARCH_DISABLED_REASON,
+        warning_codes=["author_search_disabled_by_configuration"],
+        limit=bounded_limit,
+    )
+
+
+def _normalize_runtime_cooldown_state(
+    runtime_state: AuthorSearchRuntimeState,
+    *,
+    now_utc: datetime,
+) -> bool:
+    if runtime_state.cooldown_until is None:
+        return False
+    cooldown_until = runtime_state.cooldown_until
+    updated = False
+    if cooldown_until.tzinfo is None:
+        cooldown_until = cooldown_until.replace(tzinfo=timezone.utc)
+        runtime_state.cooldown_until = cooldown_until
+        updated = True
+    if now_utc < cooldown_until:
+        return updated
+    logger.info(
+        "scholar_search.cooldown_expired",
+        extra={"event": "scholar_search.cooldown_expired", "cooldown_until_utc": cooldown_until.isoformat()},
+    )
+    runtime_state.cooldown_until = None
+    runtime_state.cooldown_rejection_count = 0
+    runtime_state.cooldown_alert_emitted = False
+    return True
+
+
+def _cooldown_warning_codes(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    cooldown_remaining_seconds: int,
+) -> list[str]:
+    warning_codes = [
+        "author_search_cooldown_active",
+        f"author_search_cooldown_remaining_{cooldown_remaining_seconds}s",
+    ]
+    if bool(runtime_state.cooldown_alert_emitted):
+        warning_codes.append("author_search_cooldown_alert_threshold_exceeded")
+    return warning_codes
+
+
+def _emit_cooldown_threshold_alert(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    normalized_query: str,
+    cooldown_rejection_alert_threshold: int,
+) -> bool:
+    runtime_state.cooldown_rejection_count = int(runtime_state.cooldown_rejection_count) + 1
+    threshold = max(1, int(cooldown_rejection_alert_threshold))
+    if int(runtime_state.cooldown_rejection_count) < threshold:
+        return True
+    if bool(runtime_state.cooldown_alert_emitted):
+        return True
+    logger.error(
+        "scholar_search.cooldown_rejection_threshold_exceeded",
+        extra={
+            "event": "scholar_search.cooldown_rejection_threshold_exceeded",
+            "query": normalized_query,
+            "cooldown_rejection_count": int(runtime_state.cooldown_rejection_count),
+            "threshold": threshold,
+            "cooldown_until_utc": runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
+        },
+    )
+    runtime_state.cooldown_alert_emitted = True
+    return True
+
+
+def _cooldown_block_result(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    normalized_query: str,
+    bounded_limit: int,
+    cooldown_rejection_alert_threshold: int,
+    cooldown_remaining_seconds: int,
+) -> ParsedAuthorSearchPage:
+    _emit_cooldown_threshold_alert(
+        runtime_state=runtime_state,
+        normalized_query=normalized_query,
+        cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
+    )
+    logger.warning(
+        "scholar_search.cooldown_active",
+        extra={
+            "event": "scholar_search.cooldown_active",
+            "query": normalized_query,
+            "cooldown_remaining_seconds": cooldown_remaining_seconds,
+            "cooldown_until_utc": runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
+        },
+    )
+    return _policy_blocked_author_search_result(
+        reason=SEARCH_COOLDOWN_REASON,
+        warning_codes=_cooldown_warning_codes(
+            runtime_state=runtime_state,
+            cooldown_remaining_seconds=cooldown_remaining_seconds,
+        ),
+        limit=bounded_limit,
+    )
+
+
+async def _cache_hit_result(
+    db_session: AsyncSession,
+    *,
+    query_key: str,
+    now_utc: datetime,
+    normalized_query: str,
+    bounded_limit: int,
+) -> ParsedAuthorSearchPage | None:
+    cached = await _cache_get_author_search_result(
+        db_session,
+        query_key=query_key,
+        now_utc=now_utc,
+    )
+    if cached is None:
+        return None
+    logger.info(
+        "scholar_search.cache_hit",
+        extra={
+            "event": "scholar_search.cache_hit",
+            "query": normalized_query,
+            "state": cached.state.value,
+            "state_reason": cached.state_reason,
+        },
+    )
+    state_reason_override = SEARCH_CACHED_BLOCK_REASON if _is_author_search_block_state(cached) else None
+    return _trim_author_search_result(
+        cached,
+        limit=bounded_limit,
+        extra_warnings=["author_search_served_from_cache"],
+        state_reason_override=state_reason_override,
+    )
+
+
+def _throttle_sleep_seconds(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    now_utc: datetime,
+    min_interval_seconds: float,
+    interval_jitter_seconds: float,
+) -> tuple[float, bool]:
+    updated = False
+    if runtime_state.last_live_request_at is None:
+        enforced_wait_seconds = 0.0
+    else:
+        last_live_request_at = runtime_state.last_live_request_at
+        if last_live_request_at.tzinfo is None:
+            last_live_request_at = last_live_request_at.replace(tzinfo=timezone.utc)
+            runtime_state.last_live_request_at = last_live_request_at
+            updated = True
+        enforced_wait_seconds = (
+            last_live_request_at + timedelta(seconds=max(float(min_interval_seconds), 0.0)) - now_utc
+        ).total_seconds()
+    jitter_seconds = random.uniform(0.0, max(float(interval_jitter_seconds), 0.0))
+    return max(0.0, float(enforced_wait_seconds)) + jitter_seconds, updated
+
+
+async def _wait_for_author_search_throttle(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    normalized_query: str,
+    now_utc: datetime,
+    min_interval_seconds: float,
+    interval_jitter_seconds: float,
+) -> bool:
+    sleep_seconds, updated = _throttle_sleep_seconds(
+        runtime_state=runtime_state,
+        now_utc=now_utc,
+        min_interval_seconds=min_interval_seconds,
+        interval_jitter_seconds=interval_jitter_seconds,
+    )
+    if sleep_seconds <= 0.0:
+        return updated
+    logger.info(
+        "scholar_search.throttle_wait",
+        extra={"event": "scholar_search.throttle_wait", "query": normalized_query, "sleep_seconds": round(sleep_seconds, 3)},
+    )
+    await asyncio.sleep(sleep_seconds)
+    return True
+
+
+async def _fetch_author_search_with_retries(
+    *,
+    source: ScholarSource,
+    normalized_query: str,
+    network_error_retries: int,
+    retry_backoff_seconds: float,
+) -> tuple[ParsedAuthorSearchPage, int, list[str]]:
+    max_attempts = max(1, int(network_error_retries) + 1)
+    parsed: ParsedAuthorSearchPage | None = None
+    retry_warnings: list[str] = []
+    retry_scheduled_count = 0
+    for attempt_index in range(max_attempts):
+        fetch_result = await source.fetch_author_search_html(normalized_query, start=0)
+        try:
+            parsed = parse_author_search_page(fetch_result)
+        except ScholarParserError as exc:
+            parsed = ParsedAuthorSearchPage(
+                state=ParseState.LAYOUT_CHANGED,
+                state_reason=exc.code,
+                candidates=[],
+                marker_counts={},
+                warnings=[exc.code],
+            )
+        if parsed.state != ParseState.NETWORK_ERROR or attempt_index >= max_attempts - 1:
+            break
+        retry_warnings.append("network_retry_scheduled_for_author_search")
+        retry_scheduled_count += 1
+        retry_sleep_seconds = max(float(retry_backoff_seconds), 0.0) * (2**attempt_index)
+        if retry_sleep_seconds > 0:
+            await asyncio.sleep(retry_sleep_seconds)
+    if parsed is None:
+        raise ScholarServiceError("Unable to complete scholar author search.")
+    return parsed, retry_scheduled_count, retry_warnings
+
+
+def _with_retry_warnings(
+    parsed: ParsedAuthorSearchPage,
+    *,
+    retry_warnings: list[str],
+    retry_scheduled_count: int,
+    retry_alert_threshold: int,
+    normalized_query: str,
+) -> ParsedAuthorSearchPage:
+    merged = replace(parsed, warnings=_merge_warnings(parsed.warnings, retry_warnings))
+    threshold = max(1, int(retry_alert_threshold))
+    if retry_scheduled_count < threshold:
+        return merged
+    logger.warning(
+        "scholar_search.retry_threshold_exceeded",
+        extra={
+            "event": "scholar_search.retry_threshold_exceeded",
+            "query": normalized_query,
+            "retry_scheduled_count": retry_scheduled_count,
+            "threshold": threshold,
+            "final_state": merged.state.value,
+            "final_state_reason": merged.state_reason,
+        },
+    )
+    return replace(
+        merged,
+        warnings=_merge_warnings(
+            merged.warnings,
+            [f"author_search_retry_threshold_exceeded_{retry_scheduled_count}"],
+        ),
+    )
+
+
+def _apply_block_circuit_breaker(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    merged_parsed: ParsedAuthorSearchPage,
+    cooldown_block_threshold: int,
+    cooldown_seconds: int,
+    normalized_query: str,
+) -> ParsedAuthorSearchPage:
+    if not _is_author_search_block_state(merged_parsed):
+        runtime_state.consecutive_blocked_count = 0
+        return merged_parsed
+    runtime_state.consecutive_blocked_count = int(runtime_state.consecutive_blocked_count) + 1
+    logger.warning(
+        "scholar_search.block_detected",
+        extra={
+            "event": "scholar_search.block_detected",
+            "query": normalized_query,
+            "state_reason": merged_parsed.state_reason,
+            "consecutive_blocked_count": int(runtime_state.consecutive_blocked_count),
+        },
+    )
+    if int(runtime_state.consecutive_blocked_count) < max(1, int(cooldown_block_threshold)):
+        return merged_parsed
+    runtime_state.cooldown_until = datetime.now(timezone.utc) + timedelta(seconds=max(60, int(cooldown_seconds)))
+    runtime_state.consecutive_blocked_count = 0
+    runtime_state.cooldown_rejection_count = 0
+    runtime_state.cooldown_alert_emitted = False
+    logger.error(
+        "scholar_search.cooldown_activated",
+        extra={
+            "event": "scholar_search.cooldown_activated",
+            "query": normalized_query,
+            "cooldown_until_utc": runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
+        },
+    )
+    return replace(
+        merged_parsed,
+        warnings=_merge_warnings(merged_parsed.warnings, ["author_search_circuit_breaker_armed"]),
+    )
+
+
+def _resolve_author_search_cache_ttl_seconds(
+    *,
+    merged_parsed: ParsedAuthorSearchPage,
+    blocked_cache_ttl_seconds: int,
+    cache_ttl_seconds: int,
+) -> int:
+    if _is_author_search_block_state(merged_parsed):
+        return min(max(1, int(blocked_cache_ttl_seconds)), max(1, int(cache_ttl_seconds)))
+    return max(1, int(cache_ttl_seconds))
+
+
+async def _load_locked_runtime_state(
+    db_session: AsyncSession,
+) -> AuthorSearchRuntimeState:
+    await _acquire_author_search_lock(db_session)
+    return await _load_runtime_state_for_update(db_session)
+
+
+async def _cooldown_or_cache_result(
+    db_session: AsyncSession,
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    query_key: str,
+    normalized_query: str,
+    bounded_limit: int,
+    cooldown_rejection_alert_threshold: int,
+) -> tuple[ParsedAuthorSearchPage | None, bool]:
+    runtime_state_updated = _normalize_runtime_cooldown_state(
+        runtime_state,
+        now_utc=datetime.now(timezone.utc),
+    )
+    cooldown_remaining_seconds = _author_search_cooldown_remaining_seconds(
+        runtime_state,
+        datetime.now(timezone.utc),
+    )
+    if cooldown_remaining_seconds > 0:
+        return (
+            _cooldown_block_result(
+                runtime_state=runtime_state,
+                normalized_query=normalized_query,
+                bounded_limit=bounded_limit,
+                cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
+                cooldown_remaining_seconds=cooldown_remaining_seconds,
+            ),
+            True,
+        )
+    cached_result = await _cache_hit_result(
+        db_session,
+        query_key=query_key,
+        now_utc=datetime.now(timezone.utc),
+        normalized_query=normalized_query,
+        bounded_limit=bounded_limit,
+    )
+    return cached_result, runtime_state_updated
+
+
+async def _perform_live_author_search(db_session: AsyncSession, *, source: ScholarSource, runtime_state: AuthorSearchRuntimeState, normalized_query: str, query_key: str, network_error_retries: int, retry_backoff_seconds: float, min_interval_seconds: float, interval_jitter_seconds: float, retry_alert_threshold: int, cooldown_block_threshold: int, cooldown_seconds: int, blocked_cache_ttl_seconds: int, cache_ttl_seconds: int, cache_max_entries: int) -> tuple[ParsedAuthorSearchPage, bool]:
+    runtime_state_updated = await _wait_for_author_search_throttle(
+        runtime_state=runtime_state,
+        normalized_query=normalized_query,
+        now_utc=datetime.now(timezone.utc),
+        min_interval_seconds=min_interval_seconds,
+        interval_jitter_seconds=interval_jitter_seconds,
+    )
+    parsed, retry_count, retry_warnings = await _fetch_author_search_with_retries(
+        source=source,
+        normalized_query=normalized_query,
+        network_error_retries=network_error_retries,
+        retry_backoff_seconds=retry_backoff_seconds,
+    )
+    runtime_state.last_live_request_at = datetime.now(timezone.utc)
+    merged = _with_retry_warnings(
+        parsed,
+        retry_warnings=retry_warnings,
+        retry_scheduled_count=retry_count,
+        retry_alert_threshold=retry_alert_threshold,
+        normalized_query=normalized_query,
+    )
+    merged = _apply_block_circuit_breaker(
+        runtime_state=runtime_state,
+        merged_parsed=merged,
+        cooldown_block_threshold=cooldown_block_threshold,
+        cooldown_seconds=cooldown_seconds,
+        normalized_query=normalized_query,
+    )
+    ttl_seconds = _resolve_author_search_cache_ttl_seconds(
+        merged_parsed=merged,
+        blocked_cache_ttl_seconds=blocked_cache_ttl_seconds,
+        cache_ttl_seconds=cache_ttl_seconds,
+    )
+    await _cache_set_author_search_result(
+        db_session,
+        query_key=query_key,
+        parsed=merged,
+        ttl_seconds=float(ttl_seconds),
+        max_entries=cache_max_entries,
+        now_utc=datetime.now(timezone.utc),
+    )
+    return merged, True
+
+
+async def search_author_candidates(*, source: ScholarSource, db_session: AsyncSession, query: str, limit: int, network_error_retries: int = 1, retry_backoff_seconds: float = 1.0, search_enabled: bool = True, cache_ttl_seconds: int = 21_600, blocked_cache_ttl_seconds: int = DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS, cache_max_entries: int = DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES, min_interval_seconds: float = DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS, interval_jitter_seconds: float = DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS, cooldown_block_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD, cooldown_seconds: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS, retry_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD, cooldown_rejection_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD) -> ParsedAuthorSearchPage:
+    normalized_query, bounded_limit, query_key = _normalize_author_search_inputs(query, limit)
+    if not search_enabled:
+        return _disabled_search_result(
+            normalized_query=normalized_query,
+            bounded_limit=bounded_limit,
+        )
+
+    runtime_state = await _load_locked_runtime_state(db_session)
+    early_result, runtime_state_updated = await _cooldown_or_cache_result(
+        db_session,
+        runtime_state=runtime_state,
+        query_key=query_key,
+        normalized_query=normalized_query,
+        bounded_limit=bounded_limit,
+        cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
+    )
+    if early_result is not None:
+        await db_session.commit()
+        return early_result
+
+    merged_parsed, live_runtime_updated = await _perform_live_author_search(
+        db_session,
+        source=source,
+        runtime_state=runtime_state,
+        normalized_query=normalized_query,
+        query_key=query_key,
+        network_error_retries=network_error_retries,
+        retry_backoff_seconds=retry_backoff_seconds,
+        min_interval_seconds=min_interval_seconds,
+        interval_jitter_seconds=interval_jitter_seconds,
+        retry_alert_threshold=retry_alert_threshold,
+        cooldown_block_threshold=cooldown_block_threshold,
+        cooldown_seconds=cooldown_seconds,
+        blocked_cache_ttl_seconds=blocked_cache_ttl_seconds,
+        cache_ttl_seconds=cache_ttl_seconds,
+        cache_max_entries=cache_max_entries,
+    )
+    runtime_state_updated = runtime_state_updated or live_runtime_updated
+    if runtime_state_updated:
+        await db_session.commit()
+    return _trim_author_search_result(merged_parsed, limit=bounded_limit)
+
+
+async def hydrate_profile_metadata(
+    db_session: AsyncSession,
+    *,
+    profile: ScholarProfile,
+    source: ScholarSource,
+) -> ScholarProfile:
+    fetch_result = await source.fetch_profile_html(profile.scholar_id)
+    try:
+        parsed_page = parse_profile_page(fetch_result)
+    except ScholarParserError:
+        return profile
+
+    if parsed_page.profile_name and not (profile.display_name or "").strip():
+        profile.display_name = parsed_page.profile_name
+    if parsed_page.profile_image_url and not profile.profile_image_url:
+        profile.profile_image_url = parsed_page.profile_image_url
+
+    await db_session.commit()
+    await db_session.refresh(profile)
+    return profile
+
+
+async def set_profile_image_override_url(
+    db_session: AsyncSession,
+    *,
+    profile: ScholarProfile,
+    image_url: str | None,
+    upload_dir: str,
+) -> ScholarProfile:
+    upload_root = _ensure_upload_root(upload_dir, create=True)
+    _safe_remove_upload(upload_root, profile.profile_image_upload_path)
+
+    profile.profile_image_upload_path = None
+    profile.profile_image_override_url = normalize_profile_image_url(image_url)
+
+    await db_session.commit()
+    await db_session.refresh(profile)
+    return profile
+
+
+async def clear_profile_image_customization(
+    db_session: AsyncSession,
+    *,
+    profile: ScholarProfile,
+    upload_dir: str,
+) -> ScholarProfile:
+    upload_root = _ensure_upload_root(upload_dir, create=True)
+    _safe_remove_upload(upload_root, profile.profile_image_upload_path)
+
+    profile.profile_image_upload_path = None
+    profile.profile_image_override_url = None
+
+    await db_session.commit()
+    await db_session.refresh(profile)
+    return profile
+
+
+async def set_profile_image_upload(
+    db_session: AsyncSession,
+    *,
+    profile: ScholarProfile,
+    content_type: str | None,
+    image_bytes: bytes,
+    upload_dir: str,
+    max_upload_bytes: int,
+) -> ScholarProfile:
+    normalized_content_type = (content_type or "").strip().lower()
+    extension = ALLOWED_IMAGE_UPLOAD_CONTENT_TYPES.get(normalized_content_type)
+    if extension is None:
+        raise ScholarServiceError(
+            "Unsupported image type. Use JPEG, PNG, WEBP, or GIF."
+        )
+
+    if not image_bytes:
+        raise ScholarServiceError("Uploaded image file is empty.")
+
+    if len(image_bytes) > max_upload_bytes:
+        raise ScholarServiceError(
+            f"Uploaded image exceeds {max_upload_bytes} bytes."
+        )
+
+    upload_root = _ensure_upload_root(upload_dir, create=True)
+    user_dir = upload_root / str(profile.user_id)
+    user_dir.mkdir(parents=True, exist_ok=True)
+
+    filename = f"{profile.id}_{uuid4().hex}{extension}"
+    relative_path = os.path.join(str(profile.user_id), filename)
+    absolute_path = _resolve_upload_path(upload_root, relative_path)
+    absolute_path.write_bytes(image_bytes)
+
+    old_path = profile.profile_image_upload_path
+    profile.profile_image_upload_path = relative_path
+    profile.profile_image_override_url = None
+
+    await db_session.commit()
+    await db_session.refresh(profile)
+
+    if old_path and old_path != relative_path:
+        _safe_remove_upload(upload_root, old_path)
+
+    return profile
diff --git a/build/lib/app/services/domains/scholars/constants.py b/build/lib/app/services/domains/scholars/constants.py
new file mode 100644
index 0000000..7ee18ad
--- /dev/null
+++ b/build/lib/app/services/domains/scholars/constants.py
@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import re
+
+SCHOLAR_ID_PATTERN = re.compile(r"^[a-zA-Z0-9_-]{12}$")
+MAX_IMAGE_URL_LENGTH = 2048
+MAX_AUTHOR_SEARCH_LIMIT = 25
+
+DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES = 512
+DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS = 300
+DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD = 1
+DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS = 1800
+DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS = 3.0
+DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS = 1.0
+DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD = 2
+DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD = 3
+
+AUTHOR_SEARCH_RUNTIME_STATE_KEY = "global"
+AUTHOR_SEARCH_LOCK_NAMESPACE = 3901
+AUTHOR_SEARCH_LOCK_KEY = 1
+
+ALLOWED_IMAGE_UPLOAD_CONTENT_TYPES = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+}
+
+SEARCH_DISABLED_REASON = "search_disabled_by_configuration"
+SEARCH_COOLDOWN_REASON = "search_temporarily_disabled_due_to_repeated_blocks"
+SEARCH_CACHED_BLOCK_REASON = "search_temporarily_disabled_from_cached_blocked_response"
+
+STATE_REASON_HINTS: dict[str, str] = {
+    SEARCH_DISABLED_REASON: (
+        "Scholar name search is currently disabled by service policy. "
+        "Add scholars by profile URL or Scholar ID."
+    ),
+    SEARCH_COOLDOWN_REASON: (
+        "Scholar name search is temporarily paused after repeated block responses. "
+        "Use Scholar URL/ID adds until cooldown expires."
+    ),
+    SEARCH_CACHED_BLOCK_REASON: (
+        "A recent blocked response was cached to reduce traffic. "
+        "Retry later or add by Scholar URL/ID."
+    ),
+    "network_dns_resolution_failed": (
+        "DNS resolution failed while reaching scholar.google.com. "
+        "Verify container DNS/network and retry."
+    ),
+    "network_timeout": (
+        "Request timed out before Google Scholar responded. "
+        "Increase delay/backoff and retry."
+    ),
+    "network_tls_error": (
+        "TLS handshake/certificate validation failed. "
+        "Verify outbound TLS/network configuration."
+    ),
+    "blocked_http_429_rate_limited": (
+        "Google Scholar rate-limited the request. "
+        "Slow request cadence and retry later."
+    ),
+    "blocked_unusual_traffic_detected": (
+        "Google Scholar flagged traffic as unusual. "
+        "Increase delay/jitter and reduce concurrent scraping."
+    ),
+    "blocked_accounts_redirect": (
+        "Request was redirected to Google Account sign-in. "
+        "Treat as access block and retry later."
+    ),
+}
diff --git a/build/lib/app/services/domains/scholars/exceptions.py b/build/lib/app/services/domains/scholars/exceptions.py
new file mode 100644
index 0000000..f1383e3
--- /dev/null
+++ b/build/lib/app/services/domains/scholars/exceptions.py
@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+
+class ScholarServiceError(ValueError):
+    """Raised for expected scholar-management validation failures."""
diff --git a/build/lib/app/services/domains/scholars/search_hints.py b/build/lib/app/services/domains/scholars/search_hints.py
new file mode 100644
index 0000000..f905c14
--- /dev/null
+++ b/build/lib/app/services/domains/scholars/search_hints.py
@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from app.db.models import ScholarProfile
+from app.services.domains.scholar.parser import ParseState, ParsedAuthorSearchPage
+from app.services.domains.scholars.constants import (
+    MAX_AUTHOR_SEARCH_LIMIT,
+    STATE_REASON_HINTS,
+)
+
+
+def resolve_profile_image(
+    profile: ScholarProfile,
+    *,
+    uploaded_image_url: str | None,
+) -> tuple[str | None, str]:
+    if profile.profile_image_upload_path and uploaded_image_url:
+        return uploaded_image_url, "upload"
+    if profile.profile_image_override_url:
+        return profile.profile_image_override_url, "override"
+    if profile.profile_image_url:
+        return profile.profile_image_url, "scraped"
+    return None, "none"
+
+
+def scrape_state_hint(*, state: ParseState, state_reason: str) -> str | None:
+    if state not in {ParseState.NETWORK_ERROR, ParseState.BLOCKED_OR_CAPTCHA}:
+        return None
+    return STATE_REASON_HINTS.get(state_reason)
+
+
+def _merge_warnings(base: list[str], extra: list[str]) -> list[str]:
+    if not extra:
+        return sorted(set(base))
+    return sorted(set(base + extra))
+
+
+def _trim_author_search_result(
+    parsed: ParsedAuthorSearchPage,
+    *,
+    limit: int,
+    extra_warnings: list[str] | None = None,
+    state_reason_override: str | None = None,
+) -> ParsedAuthorSearchPage:
+    bounded_limit = max(1, min(int(limit), MAX_AUTHOR_SEARCH_LIMIT))
+    return ParsedAuthorSearchPage(
+        state=parsed.state,
+        state_reason=state_reason_override or parsed.state_reason,
+        candidates=parsed.candidates[:bounded_limit],
+        marker_counts=parsed.marker_counts,
+        warnings=_merge_warnings(parsed.warnings, extra_warnings or []),
+    )
+
+
+def _policy_blocked_author_search_result(
+    *,
+    reason: str,
+    warning_codes: list[str],
+    limit: int,
+) -> ParsedAuthorSearchPage:
+    _ = limit
+    return ParsedAuthorSearchPage(
+        state=ParseState.BLOCKED_OR_CAPTCHA,
+        state_reason=reason,
+        candidates=[],
+        marker_counts={},
+        warnings=_merge_warnings([], warning_codes),
+    )
diff --git a/build/lib/app/services/domains/scholars/uploads.py b/build/lib/app/services/domains/scholars/uploads.py
new file mode 100644
index 0000000..c33fd47
--- /dev/null
+++ b/build/lib/app/services/domains/scholars/uploads.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from app.services.domains.scholars.exceptions import ScholarServiceError
+
+
+def _ensure_upload_root(upload_dir: str, *, create: bool) -> Path:
+    root = Path(upload_dir).expanduser().resolve()
+    if create:
+        root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def _resolve_upload_path(upload_root: Path, relative_path: str) -> Path:
+    candidate = (upload_root / relative_path).resolve()
+    if upload_root != candidate and upload_root not in candidate.parents:
+        raise ScholarServiceError("Invalid scholar image path.")
+    return candidate
+
+
+def _safe_remove_upload(upload_root: Path, relative_path: str | None) -> None:
+    if not relative_path:
+        return
+    try:
+        file_path = _resolve_upload_path(upload_root, relative_path)
+    except ScholarServiceError:
+        return
+
+    try:
+        if file_path.exists() and file_path.is_file():
+            file_path.unlink()
+    except OSError:
+        return
+
+
+def resolve_upload_file_path(*, upload_dir: str, relative_path: str) -> Path:
+    root = _ensure_upload_root(upload_dir, create=False)
+    return _resolve_upload_path(root, relative_path)
diff --git a/build/lib/app/services/domains/scholars/validators.py b/build/lib/app/services/domains/scholars/validators.py
new file mode 100644
index 0000000..1c79baa
--- /dev/null
+++ b/build/lib/app/services/domains/scholars/validators.py
@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+from app.services.domains.scholars.constants import MAX_IMAGE_URL_LENGTH, SCHOLAR_ID_PATTERN
+from app.services.domains.scholars.exceptions import ScholarServiceError
+
+
+def validate_scholar_id(value: str) -> str:
+    scholar_id = value.strip()
+    if not SCHOLAR_ID_PATTERN.fullmatch(scholar_id):
+        raise ScholarServiceError("Scholar ID must match [a-zA-Z0-9_-]{12}.")
+    return scholar_id
+
+
+def normalize_display_name(value: str) -> str | None:
+    normalized = value.strip()
+    return normalized if normalized else None
+
+
+def normalize_profile_image_url(value: str | None) -> str | None:
+    if value is None:
+        return None
+
+    candidate = value.strip()
+    if not candidate:
+        return None
+
+    if len(candidate) > MAX_IMAGE_URL_LENGTH:
+        raise ScholarServiceError(
+            f"Image URL must be {MAX_IMAGE_URL_LENGTH} characters or fewer."
+        )
+
+    parsed = urlparse(candidate)
+    if parsed.scheme.lower() not in {"http", "https"} or not parsed.netloc:
+        raise ScholarServiceError("Image URL must be an absolute http(s) URL.")
+
+    return candidate
diff --git a/build/lib/app/services/domains/settings/__init__.py b/build/lib/app/services/domains/settings/__init__.py
new file mode 100644
index 0000000..9d48db4
--- /dev/null
+++ b/build/lib/app/services/domains/settings/__init__.py
@@ -0,0 +1 @@
+from __future__ import annotations
diff --git a/build/lib/app/services/domains/settings/application.py b/build/lib/app/services/domains/settings/application.py
new file mode 100644
index 0000000..7f435e8
--- /dev/null
+++ b/build/lib/app/services/domains/settings/application.py
@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import UserSetting
+
+
+class UserSettingsServiceError(ValueError):
+    """Raised for expected settings-validation failures."""
+
+
+NAV_PAGE_DASHBOARD = "dashboard"
+NAV_PAGE_SCHOLARS = "scholars"
+NAV_PAGE_PUBLICATIONS = "publications"
+NAV_PAGE_SETTINGS = "settings"
+NAV_PAGE_STYLE_GUIDE = "style-guide"
+NAV_PAGE_RUNS = "runs"
+NAV_PAGE_USERS = "users"
+
+ALLOWED_NAV_PAGES = (
+    NAV_PAGE_DASHBOARD,
+    NAV_PAGE_SCHOLARS,
+    NAV_PAGE_PUBLICATIONS,
+    NAV_PAGE_SETTINGS,
+    NAV_PAGE_STYLE_GUIDE,
+    NAV_PAGE_RUNS,
+    NAV_PAGE_USERS,
+)
+REQUIRED_NAV_PAGES = (
+    NAV_PAGE_DASHBOARD,
+    NAV_PAGE_SCHOLARS,
+    NAV_PAGE_SETTINGS,
+)
+DEFAULT_NAV_VISIBLE_PAGES = list(ALLOWED_NAV_PAGES)
+HARD_MIN_RUN_INTERVAL_MINUTES = 15
+HARD_MIN_REQUEST_DELAY_SECONDS = 2
+
+
+def resolve_run_interval_minimum(configured_minimum: int | None) -> int:
+    try:
+        parsed = int(configured_minimum) if configured_minimum is not None else HARD_MIN_RUN_INTERVAL_MINUTES
+    except (TypeError, ValueError):
+        parsed = HARD_MIN_RUN_INTERVAL_MINUTES
+    return max(HARD_MIN_RUN_INTERVAL_MINUTES, parsed)
+
+
+def resolve_request_delay_minimum(configured_minimum: int | None) -> int:
+    try:
+        parsed = int(configured_minimum) if configured_minimum is not None else HARD_MIN_REQUEST_DELAY_SECONDS
+    except (TypeError, ValueError):
+        parsed = HARD_MIN_REQUEST_DELAY_SECONDS
+    return max(HARD_MIN_REQUEST_DELAY_SECONDS, parsed)
+
+
+def parse_run_interval_minutes(value: str, *, minimum: int = HARD_MIN_RUN_INTERVAL_MINUTES) -> int:
+    try:
+        parsed = int(value)
+    except ValueError as exc:
+        raise UserSettingsServiceError("Check interval must be a whole number.") from exc
+    effective_minimum = resolve_run_interval_minimum(minimum)
+    if parsed < effective_minimum:
+        raise UserSettingsServiceError(
+            f"Check interval must be at least {effective_minimum} minutes."
+        )
+    return parsed
+
+
+def parse_request_delay_seconds(value: str, *, minimum: int = HARD_MIN_REQUEST_DELAY_SECONDS) -> int:
+    try:
+        parsed = int(value)
+    except ValueError as exc:
+        raise UserSettingsServiceError("Request delay must be a whole number.") from exc
+    effective_minimum = resolve_request_delay_minimum(minimum)
+    if parsed < effective_minimum:
+        raise UserSettingsServiceError(
+            f"Request delay must be at least {effective_minimum} seconds."
+        )
+    return parsed
+
+
+def parse_nav_visible_pages(value: object) -> list[str]:
+    if not isinstance(value, list):
+        raise UserSettingsServiceError("Navigation visibility must be a list of page ids.")
+
+    deduped: list[str] = []
+    seen: set[str] = set()
+
+    for raw_page in value:
+        if not isinstance(raw_page, str):
+            raise UserSettingsServiceError("Navigation visibility entries must be strings.")
+
+        page_id = raw_page.strip()
+        if page_id not in ALLOWED_NAV_PAGES:
+            raise UserSettingsServiceError(f"Unsupported navigation page id: {page_id}")
+
+        if page_id in seen:
+            continue
+
+        seen.add(page_id)
+        deduped.append(page_id)
+
+    missing_required = [page for page in REQUIRED_NAV_PAGES if page not in seen]
+    if missing_required:
+        raise UserSettingsServiceError(
+            "Dashboard, Scholars, and Settings must remain visible."
+        )
+
+    return deduped
+
+
+from app.settings import settings as app_settings
+
+async def get_or_create_settings(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+) -> UserSetting:
+    result = await db_session.execute(
+        select(UserSetting).where(UserSetting.user_id == user_id)
+    )
+    settings = result.scalar_one_or_none()
+    if settings is not None:
+        return settings
+
+    settings = UserSetting(
+        user_id=user_id,
+        openalex_api_key=app_settings.openalex_api_key,
+        crossref_api_token=app_settings.crossref_api_token,
+        crossref_api_mailto=app_settings.crossref_api_mailto,
+    )
+    db_session.add(settings)
+    await db_session.commit()
+    await db_session.refresh(settings)
+    return settings
+
+
+async def update_settings(
+    db_session: AsyncSession,
+    *,
+    settings: UserSetting,
+    auto_run_enabled: bool,
+    run_interval_minutes: int,
+    request_delay_seconds: int,
+    nav_visible_pages: list[str],
+    openalex_api_key: str | None,
+    crossref_api_token: str | None,
+    crossref_api_mailto: str | None,
+) -> UserSetting:
+    settings.auto_run_enabled = auto_run_enabled
+    settings.run_interval_minutes = run_interval_minutes
+    settings.request_delay_seconds = request_delay_seconds
+    settings.nav_visible_pages = nav_visible_pages
+    settings.openalex_api_key = openalex_api_key
+    settings.crossref_api_token = crossref_api_token
+    settings.crossref_api_mailto = crossref_api_mailto
+    await db_session.commit()
+    await db_session.refresh(settings)
+    return settings
diff --git a/build/lib/app/services/domains/unpaywall/__init__.py b/build/lib/app/services/domains/unpaywall/__init__.py
new file mode 100644
index 0000000..a1baa12
--- /dev/null
+++ b/build/lib/app/services/domains/unpaywall/__init__.py
@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+
+async def resolve_publication_pdf_urls(*args, **kwargs):
+    from app.services.domains.unpaywall.application import resolve_publication_pdf_urls as _impl
+
+    return await _impl(*args, **kwargs)
+
+
+__all__ = ["resolve_publication_pdf_urls"]
diff --git a/build/lib/app/services/domains/unpaywall/application.py b/build/lib/app/services/domains/unpaywall/application.py
new file mode 100644
index 0000000..13104e9
--- /dev/null
+++ b/build/lib/app/services/domains/unpaywall/application.py
@@ -0,0 +1,458 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import logging
+import re
+from typing import TYPE_CHECKING
+from urllib.parse import unquote
+
+from app.services.domains.crossref.application import discover_doi_for_publication
+from app.services.domains.doi.normalize import normalize_doi
+from app.services.domains.unpaywall.pdf_discovery import (
+    looks_like_pdf_url,
+    resolve_pdf_from_landing_page,
+)
+from app.services.domains.unpaywall.rate_limit import wait_for_unpaywall_slot
+from app.settings import settings
+
+if TYPE_CHECKING:
+    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+
+DOI_PATTERN = re.compile(r"10\.\d{4,9}/[-._;()/:A-Z0-9]+", re.I)
+DOI_PREFIX_RE = re.compile(r"\bdoi\s*[:=]\s*(10\.\d{4,9}/[-._;()/:A-Z0-9]+)", re.I)
+DOI_URL_RE = re.compile(r"(?:https?://)?(?:dx\.)?doi\.org/(10\.\d{4,9}/[-._;()/:A-Z0-9]+)", re.I)
+UNPAYWALL_URL_TEMPLATE = "https://api.unpaywall.org/v2/{doi}"
+FAILURE_MISSING_DOI = "missing_doi"
+FAILURE_NO_RECORD = "no_unpaywall_record"
+FAILURE_NO_PDF = "no_pdf_found"
+FAILURE_RESOLUTION_EXCEPTION = "resolution_exception"
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class OaResolutionOutcome:
+    publication_id: int
+    doi: str | None
+    pdf_url: str | None
+    failure_reason: str | None
+    source: str | None
+    used_crossref: bool
+
+
+def _extract_doi_candidate(text: str | None) -> str | None:
+    if not text:
+        return None
+    decoded = unquote(text)
+    match = DOI_PATTERN.search(decoded)
+    if not match:
+        return None
+    return match.group(0).rstrip(" .;,)")
+
+
+def _extract_explicit_doi(text: str | None) -> str | None:
+    if not text:
+        return None
+    decoded = unquote(text)
+    url_match = DOI_URL_RE.search(decoded)
+    if url_match:
+        return normalize_doi(url_match.group(1))
+    prefix_match = DOI_PREFIX_RE.search(decoded)
+    if prefix_match:
+        return normalize_doi(prefix_match.group(1))
+    return None
+
+
+def _publication_doi(item: PublicationListItem | UnreadPublicationItem) -> str | None:
+    stored = None
+    if getattr(item, "display_identifier", None) and item.display_identifier.kind == "doi":
+        stored = normalize_doi(item.display_identifier.value)
+    
+    explicit_doi = (
+        _extract_explicit_doi(item.pub_url)
+        or _extract_explicit_doi(item.venue_text)
+    )
+    if explicit_doi:
+        return explicit_doi
+    pub_url_doi = _extract_doi_candidate(item.pub_url)
+    if pub_url_doi:
+        return normalize_doi(pub_url_doi)
+    return stored
+
+
+def _payload_locations(payload: dict) -> list[dict]:
+    locations: list[dict] = []
+    best = payload.get("best_oa_location")
+    if isinstance(best, dict):
+        locations.append(best)
+    oa_locations = payload.get("oa_locations")
+    if isinstance(oa_locations, list):
+        locations.extend(location for location in oa_locations if isinstance(location, dict))
+    return locations
+
+
+def _location_value(location: dict, key: str) -> str | None:
+    value = location.get(key)
+    if not isinstance(value, str):
+        return None
+    normalized = value.strip()
+    return normalized or None
+
+
+def _payload_pdf_candidates(payload: dict) -> list[str]:
+    candidates: list[str] = []
+    seen: set[str] = set()
+    for location in _payload_locations(payload):
+        candidate = _location_value(location, "url_for_pdf")
+        if candidate is None or candidate in seen:
+            continue
+        seen.add(candidate)
+        candidates.append(candidate)
+    return candidates
+
+
+def _payload_landing_candidates(payload: dict) -> list[str]:
+    candidates: list[str] = []
+    seen: set[str] = set()
+    for location in _payload_locations(payload):
+        candidate = _location_value(location, "url")
+        if candidate is None or candidate in seen:
+            continue
+        seen.add(candidate)
+        candidates.append(candidate)
+    return candidates
+
+
+def _crawl_targets(
+    *,
+    payload: dict,
+    pdf_candidates: list[str],
+) -> list[str]:
+    targets = _payload_landing_candidates(payload)
+    seen = set(targets)
+    for candidate in pdf_candidates:
+        if candidate in seen:
+            continue
+        targets.append(candidate)
+        seen.add(candidate)
+    doi = normalize_doi(str(payload.get("doi") or ""))
+    doi_landing_url = f"https://doi.org/{doi}" if doi else None
+    if doi_landing_url and doi_landing_url not in seen:
+        targets.append(doi_landing_url)
+    return targets
+
+
+def _has_direct_payload_pdf(payload: dict) -> bool:
+    return any(looks_like_pdf_url(candidate) for candidate in _payload_pdf_candidates(payload))
+
+
+async def _resolved_pdf_url_from_payload(
+    payload: dict,
+    *,
+    client,
+) -> str | None:
+    pdf_candidates = _payload_pdf_candidates(payload)
+    for candidate in pdf_candidates:
+        if looks_like_pdf_url(candidate):
+            return candidate
+    for page_url in _crawl_targets(payload=payload, pdf_candidates=pdf_candidates)[:3]:
+        discovered = await resolve_pdf_from_landing_page(client, page_url=page_url)
+        if discovered:
+            logger.info(
+                "unpaywall.pdf_discovered_from_landing",
+                extra={"event": "unpaywall.pdf_discovered_from_landing", "landing_url": page_url},
+            )
+            return discovered
+    return None
+
+
+async def _fetch_unpaywall_payload_by_doi(
+    *,
+    client,
+    doi: str,
+    email: str,
+) -> dict | None:
+    await wait_for_unpaywall_slot(min_interval_seconds=settings.unpaywall_min_interval_seconds)
+    headers = {"User-Agent": f"scholar-scraper/1.0 (mailto:{email})"}
+    response = await client.get(
+        UNPAYWALL_URL_TEMPLATE.format(doi=doi),
+        params={"email": email},
+        headers=headers,
+    )
+    if response.status_code != 200:
+        return None
+    payload = response.json()
+    if not isinstance(payload, dict):
+        return None
+    return payload
+
+
+def _email_for_request(request_email: str | None) -> str | None:
+    email = (request_email or "").strip() or settings.unpaywall_email.strip()
+    return email or None
+
+
+def _log_resolution_summary(
+    *,
+    publication_count: int,
+    doi_input_count: int,
+    search_attempt_count: int,
+    resolved_pdf_count: int,
+    email: str,
+) -> None:
+    logger.info(
+        "unpaywall.resolve_completed",
+        extra={
+            "event": "unpaywall.resolve_completed",
+            "publication_count": publication_count,
+            "doi_input_count": doi_input_count,
+            "search_attempt_count": search_attempt_count,
+            "resolved_pdf_count": resolved_pdf_count,
+            "email_domain": email.split("@", 1)[-1] if "@" in email else None,
+        },
+    )
+
+
+async def _resolve_item_payload(
+    *,
+    client,
+    item: PublicationListItem,
+    email: str,
+    allow_crossref: bool,
+) -> tuple[dict | None, bool, str | None]:
+    doi = _publication_doi(item)
+    payload: dict | None = None
+    if doi:
+        payload = await _fetch_unpaywall_payload_by_doi(client=client, doi=doi, email=email)
+        if payload is not None and _has_direct_payload_pdf(payload):
+            return payload, False, doi
+    if not allow_crossref or not settings.crossref_enabled:
+        return payload, False, doi
+    crossref_doi = await discover_doi_for_publication(
+        item=item,
+        max_rows=settings.crossref_max_rows,
+        email=email,
+    )
+    if crossref_doi is None or crossref_doi == doi:
+        return payload, crossref_doi is not None, doi or crossref_doi
+    crossref_payload = await _fetch_unpaywall_payload_by_doi(
+        client=client,
+        doi=crossref_doi,
+        email=email,
+    )
+    if crossref_payload is not None:
+        return crossref_payload, True, crossref_doi
+    return payload, True, crossref_doi
+
+
+async def _doi_and_pdf_from_payload(
+    payload: dict,
+    *,
+    client,
+) -> tuple[str | None, str | None]:
+    doi = normalize_doi(str(payload.get("doi") or ""))
+    return doi, await _resolved_pdf_url_from_payload(payload, client=client)
+
+
+def _resolution_targets(items: list[PublicationListItem]) -> list[PublicationListItem]:
+    return [item for item in items if not item.pdf_url]
+
+
+def _crossref_budget_value() -> int:
+    return max(int(settings.crossref_max_lookups_per_request), 0)
+
+
+def _outcome_with_failure(
+    *,
+    item: PublicationListItem,
+    failure_reason: str,
+    used_crossref: bool,
+    doi_override: str | None = None,
+) -> OaResolutionOutcome:
+    return OaResolutionOutcome(
+        publication_id=item.publication_id,
+        doi=normalize_doi(doi_override) if doi_override is not None else _publication_doi(item),
+        pdf_url=None,
+        failure_reason=failure_reason,
+        source=None,
+        used_crossref=used_crossref,
+    )
+
+
+def _missing_payload_failure_reason(item: PublicationListItem, *, used_crossref: bool) -> str:
+    if _publication_doi(item):
+        return FAILURE_NO_RECORD
+    if used_crossref:
+        return FAILURE_NO_RECORD
+    return FAILURE_MISSING_DOI
+
+
+def _source_name(*, used_crossref: bool) -> str:
+    return "crossref+unpaywall" if used_crossref else "unpaywall"
+
+
+def _outcome_from_payload(
+    *,
+    item: PublicationListItem,
+    doi: str | None,
+    pdf_url: str | None,
+    used_crossref: bool,
+) -> OaResolutionOutcome:
+    return OaResolutionOutcome(
+        publication_id=item.publication_id,
+        doi=doi,
+        pdf_url=pdf_url,
+        failure_reason=None if pdf_url else FAILURE_NO_PDF,
+        source=_source_name(used_crossref=used_crossref),
+        used_crossref=used_crossref,
+    )
+
+
+def _resolved_pdf_count(outcomes: dict[int, OaResolutionOutcome]) -> int:
+    return sum(1 for outcome in outcomes.values() if outcome.pdf_url)
+
+
+def _outcome_metadata(outcomes: dict[int, OaResolutionOutcome]) -> dict[int, tuple[str | None, str | None]]:
+    return {
+        publication_id: (outcome.doi, outcome.pdf_url)
+        for publication_id, outcome in outcomes.items()
+    }
+
+
+async def _resolve_outcome_for_item(
+    *,
+    client,
+    item: PublicationListItem,
+    email: str,
+    allow_crossref: bool,
+) -> OaResolutionOutcome:
+    payload, used_crossref, resolved_doi = await _resolve_item_payload(
+        client=client,
+        item=item,
+        email=email,
+        allow_crossref=allow_crossref,
+    )
+    if not isinstance(payload, dict):
+        return _outcome_with_failure(
+            item=item,
+            failure_reason=_missing_payload_failure_reason(item, used_crossref=used_crossref),
+            used_crossref=used_crossref,
+            doi_override=resolved_doi,
+        )
+    doi, pdf_url = await _doi_and_pdf_from_payload(payload, client=client)
+    return _outcome_from_payload(
+        item=item,
+        doi=doi,
+        pdf_url=pdf_url,
+        used_crossref=used_crossref,
+    )
+
+
+def _doi_input_count(items: list[PublicationListItem]) -> int:
+    return len([item for item in items if _publication_doi(item)])
+
+
+def _search_attempt_count(*, targets: list[PublicationListItem]) -> int:
+    return len([item for item in targets if not _publication_doi(item)])
+
+
+async def _safe_outcome_for_item(
+    *,
+    client,
+    item: PublicationListItem,
+    email: str,
+    allow_crossref: bool,
+) -> OaResolutionOutcome:
+    try:
+        return await _resolve_outcome_for_item(
+            client=client,
+            item=item,
+            email=email,
+            allow_crossref=allow_crossref,
+        )
+    except Exception as exc:  # pragma: no cover - defensive network boundary
+        logger.warning(
+            "unpaywall.resolve_item_failed",
+            extra={
+                "event": "unpaywall.resolve_item_failed",
+                "publication_id": item.publication_id,
+                "error": str(exc),
+            },
+        )
+        return _outcome_with_failure(
+            item=item,
+            failure_reason=FAILURE_RESOLUTION_EXCEPTION,
+            used_crossref=allow_crossref and settings.crossref_enabled,
+        )
+
+
+async def _resolve_outcomes_with_client(
+    *,
+    client,
+    targets: list[PublicationListItem],
+    email: str,
+) -> dict[int, OaResolutionOutcome]:
+    outcomes: dict[int, OaResolutionOutcome] = {}
+    crossref_budget = _crossref_budget_value()
+    crossref_lookups = 0
+    for item in targets:
+        allow_crossref = crossref_budget > 0 and crossref_lookups < crossref_budget
+        outcome = await _safe_outcome_for_item(
+            client=client,
+            item=item,
+            email=email,
+            allow_crossref=allow_crossref,
+        )
+        if outcome.used_crossref:
+            crossref_lookups += 1
+        outcomes[item.publication_id] = outcome
+    return outcomes
+
+
+async def resolve_publication_oa_metadata(
+    items: list[PublicationListItem],
+    *,
+    request_email: str | None = None,
+) -> dict[int, tuple[str | None, str | None]]:
+    outcomes = await resolve_publication_oa_outcomes(items, request_email=request_email)
+    return _outcome_metadata(outcomes)
+
+
+async def resolve_publication_oa_outcomes(
+    items: list[PublicationListItem],
+    *,
+    request_email: str | None = None,
+) -> dict[int, OaResolutionOutcome]:
+    if not settings.unpaywall_enabled:
+        return {}
+    email = _email_for_request(request_email)
+    if email is None:
+        logger.debug("unpaywall.resolve_skipped_missing_email")
+        return {}
+    import httpx
+
+    timeout_seconds = max(float(settings.unpaywall_timeout_seconds), 0.5)
+    targets = _resolution_targets(items)[: max(int(settings.unpaywall_max_items_per_request), 0)]
+    headers = {"User-Agent": f"scholar-scraper/1.0 (mailto:{email})"}
+    async with httpx.AsyncClient(timeout=timeout_seconds, follow_redirects=True, headers=headers) as client:
+        outcomes = await _resolve_outcomes_with_client(
+            client=client,
+            targets=targets,
+            email=email,
+        )
+    _log_resolution_summary(
+        publication_count=len(items),
+        doi_input_count=_doi_input_count(items),
+        search_attempt_count=_search_attempt_count(targets=targets),
+        resolved_pdf_count=_resolved_pdf_count(outcomes),
+        email=email,
+    )
+    return outcomes
+
+
+async def resolve_publication_pdf_urls(
+    items: list[PublicationListItem],
+    *,
+    request_email: str | None = None,
+) -> dict[int, str | None]:
+    resolved = await resolve_publication_oa_metadata(items, request_email=request_email)
+    return {publication_id: pdf for publication_id, (_doi, pdf) in resolved.items()}
diff --git a/build/lib/app/services/domains/unpaywall/pdf_discovery.py b/build/lib/app/services/domains/unpaywall/pdf_discovery.py
new file mode 100644
index 0000000..5f82a58
--- /dev/null
+++ b/build/lib/app/services/domains/unpaywall/pdf_discovery.py
@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from html.parser import HTMLParser
+import re
+from urllib.parse import urljoin, urlparse
+
+from app.services.domains.unpaywall.rate_limit import wait_for_unpaywall_slot
+from app.settings import settings
+
+PDF_MIME = "application/pdf"
+URL_RE = re.compile(r"https?://[^\s\"'<>]+", re.I)
+
+
+class _LandingPdfParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.base_href: str | None = None
+        self.candidates: list[str] = []
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        attrs_map = {key.lower(): (value or "").strip() for key, value in attrs}
+        if tag == "base":
+            self.base_href = attrs_map.get("href") or self.base_href
+            return
+        if tag == "meta":
+            self._append_meta_candidate(attrs_map)
+            return
+        if tag == "link":
+            self._append_link_candidate(attrs_map)
+            return
+        if tag == "a":
+            self._append_anchor_candidate(attrs_map)
+
+    def _append_meta_candidate(self, attrs_map: dict[str, str]) -> None:
+        meta_name = (attrs_map.get("name") or attrs_map.get("property") or "").lower()
+        if meta_name != "citation_pdf_url":
+            return
+        content = attrs_map.get("content")
+        if content:
+            self.candidates.append(content)
+
+    def _append_link_candidate(self, attrs_map: dict[str, str]) -> None:
+        href = attrs_map.get("href")
+        link_type = (attrs_map.get("type") or "").lower()
+        if href and "pdf" in link_type:
+            self.candidates.append(href)
+
+    def _append_anchor_candidate(self, attrs_map: dict[str, str]) -> None:
+        href = attrs_map.get("href")
+        if href:
+            self.candidates.append(href)
+
+
+def looks_like_pdf_url(url: str | None) -> bool:
+    if not isinstance(url, str):
+        return False
+    value = url.strip()
+    if not value:
+        return False
+    parsed = urlparse(value)
+    path = (parsed.path or "").lower()
+    query = (parsed.query or "").lower()
+    return path.endswith(".pdf") or ".pdf" in query
+
+
+def _normalized_candidate_urls(*, page_url: str, html: str) -> list[str]:
+    parser = _LandingPdfParser()
+    parser.feed(html)
+    parser.close()
+    base_url = urljoin(page_url, parser.base_href) if parser.base_href else page_url
+    raw_candidates = [*parser.candidates, *_text_url_candidates(html)]
+    deduped: list[str] = []
+    seen: set[str] = set()
+    for raw in raw_candidates:
+        absolute = urljoin(base_url, raw.strip())
+        parsed = urlparse(absolute)
+        if parsed.scheme not in {"http", "https"}:
+            continue
+        if absolute in seen:
+            continue
+        seen.add(absolute)
+        deduped.append(absolute)
+    return sorted(deduped, key=_candidate_sort_key)
+
+
+def _text_url_candidates(html: str) -> list[str]:
+    candidates: list[str] = []
+    for match in URL_RE.findall(html):
+        cleaned = match.rstrip(".,);]}>")
+        if "pdf" not in cleaned.lower():
+            continue
+        candidates.append(cleaned)
+    return candidates
+
+
+def _candidate_sort_key(candidate: str) -> tuple[int, str]:
+    lowered = candidate.lower()
+    if looks_like_pdf_url(candidate):
+        return (0, lowered)
+    if any(token in lowered for token in ("doi", "full", "article", "download")):
+        return (1, lowered)
+    return (2, lowered)
+
+
+def _is_html_response(response) -> bool:
+    content_type = str(response.headers.get("content-type") or "").lower()
+    return "text/html" in content_type or "application/xhtml+xml" in content_type
+
+
+async def _fetch_page_html(client, *, page_url: str) -> str | None:
+    await wait_for_unpaywall_slot(min_interval_seconds=settings.unpaywall_min_interval_seconds)
+    response = await client.get(page_url, follow_redirects=True)
+    if response.status_code != 200 or not _is_html_response(response):
+        return None
+    text = response.text or ""
+    return text[: max(int(settings.unpaywall_pdf_discovery_max_html_bytes), 0)]
+
+
+async def _candidate_is_pdf(client, *, candidate_url: str) -> bool:
+    if looks_like_pdf_url(candidate_url):
+        return True
+    await wait_for_unpaywall_slot(min_interval_seconds=settings.unpaywall_min_interval_seconds)
+    response = await client.get(candidate_url, follow_redirects=True)
+    content_type = str(response.headers.get("content-type") or "").lower()
+    return response.status_code == 200 and PDF_MIME in content_type
+
+
+def _candidate_limit() -> int:
+    return max(int(settings.unpaywall_pdf_discovery_max_candidates), 1)
+
+
+async def _resolve_pdf_from_candidate_page(client, *, candidate_url: str) -> str | None:
+    html = await _fetch_page_html(client, page_url=candidate_url)
+    if not html:
+        return None
+    nested_candidates = _normalized_candidate_urls(page_url=candidate_url, html=html)
+    for nested in nested_candidates[: _candidate_limit()]:
+        if await _candidate_is_pdf(client, candidate_url=nested):
+            return nested
+    return None
+
+
+async def resolve_pdf_from_landing_page(client, *, page_url: str) -> str | None:
+    if not settings.unpaywall_pdf_discovery_enabled:
+        return None
+    html = await _fetch_page_html(client, page_url=page_url)
+    if not html:
+        return None
+    candidates = _normalized_candidate_urls(page_url=page_url, html=html)
+    for candidate in candidates[: _candidate_limit()]:
+        if await _candidate_is_pdf(client, candidate_url=candidate):
+            return candidate
+        nested_pdf = await _resolve_pdf_from_candidate_page(client, candidate_url=candidate)
+        if nested_pdf:
+            return nested_pdf
+    return None
diff --git a/build/lib/app/services/domains/unpaywall/rate_limit.py b/build/lib/app/services/domains/unpaywall/rate_limit.py
new file mode 100644
index 0000000..76d8a3d
--- /dev/null
+++ b/build/lib/app/services/domains/unpaywall/rate_limit.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import asyncio
+import time
+
+_REQUEST_LOCK = asyncio.Lock()
+_LAST_REQUEST_AT = 0.0
+
+
+async def wait_for_unpaywall_slot(*, min_interval_seconds: float) -> None:
+    global _LAST_REQUEST_AT
+    interval = max(float(min_interval_seconds), 0.0)
+    async with _REQUEST_LOCK:
+        elapsed = time.monotonic() - _LAST_REQUEST_AT
+        remaining = interval - elapsed
+        if remaining > 0:
+            await asyncio.sleep(remaining)
+        _LAST_REQUEST_AT = time.monotonic()
diff --git a/build/lib/app/services/domains/users/__init__.py b/build/lib/app/services/domains/users/__init__.py
new file mode 100644
index 0000000..9d48db4
--- /dev/null
+++ b/build/lib/app/services/domains/users/__init__.py
@@ -0,0 +1 @@
+from __future__ import annotations
diff --git a/build/lib/app/services/domains/users/application.py b/build/lib/app/services/domains/users/application.py
new file mode 100644
index 0000000..7f019c4
--- /dev/null
+++ b/build/lib/app/services/domains/users/application.py
@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import re
+
+from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import User
+
+EMAIL_PATTERN = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
+
+
+class UserServiceError(ValueError):
+    """Raised for expected user-management validation failures."""
+
+
+def normalize_email(value: str) -> str:
+    return value.strip().lower()
+
+
+def validate_email(value: str) -> str:
+    email = normalize_email(value)
+    if not EMAIL_PATTERN.fullmatch(email):
+        raise UserServiceError("Enter a valid email address.")
+    return email
+
+
+def validate_password(value: str) -> str:
+    password = value.strip()
+    if len(password) < 8:
+        raise UserServiceError("Password must be at least 8 characters.")
+    return password
+
+
+async def get_user_by_id(db_session: AsyncSession, user_id: int) -> User | None:
+    result = await db_session.execute(select(User).where(User.id == user_id))
+    return result.scalar_one_or_none()
+
+
+async def get_user_by_email(db_session: AsyncSession, email: str) -> User | None:
+    result = await db_session.execute(
+        select(User).where(User.email == normalize_email(email))
+    )
+    return result.scalar_one_or_none()
+
+
+async def list_users(db_session: AsyncSession) -> list[User]:
+    result = await db_session.execute(select(User).order_by(User.email.asc()))
+    return list(result.scalars().all())
+
+
+async def create_user(
+    db_session: AsyncSession,
+    *,
+    email: str,
+    password_hash: str,
+    is_admin: bool,
+) -> User:
+    user = User(
+        email=validate_email(email),
+        password_hash=password_hash,
+        is_admin=is_admin,
+        is_active=True,
+    )
+    db_session.add(user)
+    try:
+        await db_session.commit()
+    except IntegrityError as exc:
+        await db_session.rollback()
+        raise UserServiceError("A user with that email already exists.") from exc
+    await db_session.refresh(user)
+    return user
+
+
+async def set_user_active(
+    db_session: AsyncSession,
+    *,
+    user: User,
+    is_active: bool,
+) -> User:
+    user.is_active = is_active
+    await db_session.commit()
+    await db_session.refresh(user)
+    return user
+
+
+async def set_user_password_hash(
+    db_session: AsyncSession,
+    *,
+    user: User,
+    password_hash: str,
+) -> User:
+    user.password_hash = password_hash
+    await db_session.commit()
+    await db_session.refresh(user)
+    return user
+
diff --git a/build/lib/app/settings.py b/build/lib/app/settings.py
new file mode 100644
index 0000000..f56ff51
--- /dev/null
+++ b/build/lib/app/settings.py
@@ -0,0 +1,267 @@
+from dataclasses import dataclass
+import os
+
+DEFAULT_SECURITY_PERMISSIONS_POLICY = (
+    "accelerometer=(), autoplay=(), camera=(), display-capture=(), "
+    "geolocation=(), gyroscope=(), microphone=(), payment=(), usb=()"
+)
+DEFAULT_SECURITY_CSP_POLICY = (
+    "default-src 'self'; "
+    "base-uri 'self'; "
+    "form-action 'self'; "
+    "frame-ancestors 'none'; "
+    "img-src 'self' data: https:; "
+    "script-src 'self'; "
+    "style-src 'self' 'unsafe-inline'; "
+    "font-src 'self' data:; "
+    "connect-src 'self'; "
+    "object-src 'none'"
+)
+DEFAULT_SECURITY_CSP_DOCS_POLICY = (
+    "default-src 'self'; "
+    "img-src 'self' data: https:; "
+    "script-src 'self' 'unsafe-inline'; "
+    "style-src 'self' 'unsafe-inline'; "
+    "font-src 'self' data:; "
+    "connect-src 'self' https:; "
+    "object-src 'none'; "
+    "frame-ancestors 'none'"
+)
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _env_int(name: str, default: int) -> int:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return int(value)
+
+
+def _env_float(name: str, default: float) -> float:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return float(value)
+
+
+def _env_str(name: str, default: str) -> str:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.strip() or default
+
+
+@dataclass(frozen=True)
+class Settings:
+    app_name: str = os.getenv("APP_NAME", "scholarr")
+    database_url: str = os.getenv(
+        "DATABASE_URL",
+        "postgresql+asyncpg://scholar:scholar@db:5432/scholar",
+    )
+    database_pool_mode: str = _env_str("DATABASE_POOL_MODE", "auto")
+    database_pool_size: int = _env_int("DATABASE_POOL_SIZE", 5)
+    database_pool_max_overflow: int = _env_int("DATABASE_POOL_MAX_OVERFLOW", 10)
+    database_pool_timeout_seconds: int = _env_int("DATABASE_POOL_TIMEOUT_SECONDS", 30)
+    session_secret_key: str = os.getenv("SESSION_SECRET_KEY", "dev-insecure-session-key")
+    session_cookie_secure: bool = _env_bool("SESSION_COOKIE_SECURE", False)
+    security_headers_enabled: bool = _env_bool("SECURITY_HEADERS_ENABLED", True)
+    security_x_content_type_options: str = _env_str("SECURITY_X_CONTENT_TYPE_OPTIONS", "nosniff")
+    security_x_frame_options: str = _env_str("SECURITY_X_FRAME_OPTIONS", "DENY")
+    security_referrer_policy: str = _env_str("SECURITY_REFERRER_POLICY", "strict-origin-when-cross-origin")
+    security_permissions_policy: str = _env_str(
+        "SECURITY_PERMISSIONS_POLICY",
+        DEFAULT_SECURITY_PERMISSIONS_POLICY,
+    )
+    security_cross_origin_opener_policy: str = _env_str(
+        "SECURITY_CROSS_ORIGIN_OPENER_POLICY",
+        "same-origin",
+    )
+    security_cross_origin_resource_policy: str = _env_str(
+        "SECURITY_CROSS_ORIGIN_RESOURCE_POLICY",
+        "same-origin",
+    )
+    security_csp_enabled: bool = _env_bool("SECURITY_CSP_ENABLED", True)
+    security_csp_policy: str = _env_str("SECURITY_CSP_POLICY", DEFAULT_SECURITY_CSP_POLICY)
+    security_csp_docs_policy: str = _env_str("SECURITY_CSP_DOCS_POLICY", DEFAULT_SECURITY_CSP_DOCS_POLICY)
+    security_csp_report_only: bool = _env_bool("SECURITY_CSP_REPORT_ONLY", False)
+    security_strict_transport_security_enabled: bool = _env_bool(
+        "SECURITY_STRICT_TRANSPORT_SECURITY_ENABLED",
+        False,
+    )
+    security_strict_transport_security_max_age: int = _env_int(
+        "SECURITY_STRICT_TRANSPORT_SECURITY_MAX_AGE",
+        31_536_000,
+    )
+    security_strict_transport_security_include_subdomains: bool = _env_bool(
+        "SECURITY_STRICT_TRANSPORT_SECURITY_INCLUDE_SUBDOMAINS",
+        True,
+    )
+    security_strict_transport_security_preload: bool = _env_bool(
+        "SECURITY_STRICT_TRANSPORT_SECURITY_PRELOAD",
+        False,
+    )
+    login_rate_limit_attempts: int = _env_int("LOGIN_RATE_LIMIT_ATTEMPTS", 5)
+    login_rate_limit_window_seconds: int = _env_int(
+        "LOGIN_RATE_LIMIT_WINDOW_SECONDS",
+        60,
+    )
+    log_level: str = _env_str("LOG_LEVEL", "INFO")
+    log_format: str = _env_str("LOG_FORMAT", "console")
+    log_requests: bool = _env_bool("LOG_REQUESTS", True)
+    log_uvicorn_access: bool = _env_bool("LOG_UVICORN_ACCESS", False)
+    log_request_skip_paths: str = _env_str("LOG_REQUEST_SKIP_PATHS", "/healthz")
+    log_redact_fields: str = os.getenv("LOG_REDACT_FIELDS", "")
+    scheduler_enabled: bool = _env_bool("SCHEDULER_ENABLED", True)
+    scheduler_tick_seconds: int = _env_int("SCHEDULER_TICK_SECONDS", 60)
+    ingestion_automation_allowed: bool = _env_bool(
+        "INGESTION_AUTOMATION_ALLOWED",
+        True,
+    )
+    ingestion_manual_run_allowed: bool = _env_bool(
+        "INGESTION_MANUAL_RUN_ALLOWED",
+        True,
+    )
+    ingestion_min_run_interval_minutes: int = _env_int(
+        "INGESTION_MIN_RUN_INTERVAL_MINUTES",
+        15,
+    )
+    ingestion_min_request_delay_seconds: int = _env_int(
+        "INGESTION_MIN_REQUEST_DELAY_SECONDS",
+        2,
+    )
+    ingestion_network_error_retries: int = _env_int("INGESTION_NETWORK_ERROR_RETRIES", 1)
+    ingestion_retry_backoff_seconds: float = _env_float(
+        "INGESTION_RETRY_BACKOFF_SECONDS",
+        1.0,
+    )
+    ingestion_rate_limit_retries: int = _env_int("INGESTION_RATE_LIMIT_RETRIES", 3)
+    ingestion_rate_limit_backoff_seconds: float = _env_float(
+        "INGESTION_RATE_LIMIT_BACKOFF_SECONDS",
+        30.0,
+    )
+    ingestion_max_pages_per_scholar: int = _env_int(
+        "INGESTION_MAX_PAGES_PER_SCHOLAR",
+        30,
+    )
+    ingestion_page_size: int = _env_int("INGESTION_PAGE_SIZE", 100)
+    ingestion_alert_blocked_failure_threshold: int = _env_int(
+        "INGESTION_ALERT_BLOCKED_FAILURE_THRESHOLD",
+        1,
+    )
+    ingestion_alert_network_failure_threshold: int = _env_int(
+        "INGESTION_ALERT_NETWORK_FAILURE_THRESHOLD",
+        2,
+    )
+    ingestion_alert_retry_scheduled_threshold: int = _env_int(
+        "INGESTION_ALERT_RETRY_SCHEDULED_THRESHOLD",
+        3,
+    )
+    ingestion_safety_cooldown_blocked_seconds: int = _env_int(
+        "INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS",
+        1800,
+    )
+    ingestion_safety_cooldown_network_seconds: int = _env_int(
+        "INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS",
+        900,
+    )
+    ingestion_continuation_queue_enabled: bool = _env_bool(
+        "INGESTION_CONTINUATION_QUEUE_ENABLED",
+        True,
+    )
+    ingestion_continuation_base_delay_seconds: int = _env_int(
+        "INGESTION_CONTINUATION_BASE_DELAY_SECONDS",
+        120,
+    )
+    ingestion_continuation_max_delay_seconds: int = _env_int(
+        "INGESTION_CONTINUATION_MAX_DELAY_SECONDS",
+        3600,
+    )
+    ingestion_continuation_max_attempts: int = _env_int(
+        "INGESTION_CONTINUATION_MAX_ATTEMPTS",
+        6,
+    )
+    scheduler_queue_batch_size: int = _env_int("SCHEDULER_QUEUE_BATCH_SIZE", 10)
+    scheduler_pdf_queue_batch_size: int = _env_int("SCHEDULER_PDF_QUEUE_BATCH_SIZE", 15)
+    frontend_enabled: bool = _env_bool("FRONTEND_ENABLED", True)
+    frontend_dist_dir: str = _env_str("FRONTEND_DIST_DIR", "/app/frontend/dist")
+    scholar_image_upload_dir: str = _env_str(
+        "SCHOLAR_IMAGE_UPLOAD_DIR",
+        "/tmp/scholarr_uploads/scholar_images",
+    )
+    scholar_image_upload_max_bytes: int = _env_int(
+        "SCHOLAR_IMAGE_UPLOAD_MAX_BYTES",
+        2_000_000,
+    )
+    scholar_name_search_enabled: bool = _env_bool("SCHOLAR_NAME_SEARCH_ENABLED", True)
+    scholar_name_search_cache_ttl_seconds: int = _env_int(
+        "SCHOLAR_NAME_SEARCH_CACHE_TTL_SECONDS",
+        21_600,
+    )
+    scholar_name_search_blocked_cache_ttl_seconds: int = _env_int(
+        "SCHOLAR_NAME_SEARCH_BLOCKED_CACHE_TTL_SECONDS",
+        300,
+    )
+    scholar_name_search_cache_max_entries: int = _env_int(
+        "SCHOLAR_NAME_SEARCH_CACHE_MAX_ENTRIES",
+        512,
+    )
+    scholar_name_search_min_interval_seconds: float = _env_float(
+        "SCHOLAR_NAME_SEARCH_MIN_INTERVAL_SECONDS",
+        8.0,
+    )
+    scholar_name_search_interval_jitter_seconds: float = _env_float(
+        "SCHOLAR_NAME_SEARCH_INTERVAL_JITTER_SECONDS",
+        2.0,
+    )
+    scholar_name_search_cooldown_block_threshold: int = _env_int(
+        "SCHOLAR_NAME_SEARCH_COOLDOWN_BLOCK_THRESHOLD",
+        1,
+    )
+    scholar_name_search_cooldown_seconds: int = _env_int(
+        "SCHOLAR_NAME_SEARCH_COOLDOWN_SECONDS",
+        1800,
+    )
+    scholar_name_search_alert_retry_count_threshold: int = _env_int(
+        "SCHOLAR_NAME_SEARCH_ALERT_RETRY_COUNT_THRESHOLD",
+        2,
+    )
+    scholar_name_search_alert_cooldown_rejections_threshold: int = _env_int(
+        "SCHOLAR_NAME_SEARCH_ALERT_COOLDOWN_REJECTIONS_THRESHOLD",
+        3,
+    )
+    unpaywall_enabled: bool = _env_bool("UNPAYWALL_ENABLED", True)
+    unpaywall_email: str = _env_str("UNPAYWALL_EMAIL", "")
+    unpaywall_timeout_seconds: float = _env_float("UNPAYWALL_TIMEOUT_SECONDS", 4.0)
+    unpaywall_min_interval_seconds: float = _env_float("UNPAYWALL_MIN_INTERVAL_SECONDS", 0.6)
+    unpaywall_max_items_per_request: int = _env_int("UNPAYWALL_MAX_ITEMS_PER_REQUEST", 20)
+    unpaywall_retry_cooldown_seconds: int = _env_int("UNPAYWALL_RETRY_COOLDOWN_SECONDS", 1800)
+    pdf_auto_retry_interval_seconds: int = _env_int(
+        "PDF_AUTO_RETRY_INTERVAL_SECONDS",
+        86_400,
+    )
+    pdf_auto_retry_first_interval_seconds: int = _env_int(
+        "PDF_AUTO_RETRY_FIRST_INTERVAL_SECONDS",
+        3_600,
+    )
+    pdf_auto_retry_max_attempts: int = _env_int("PDF_AUTO_RETRY_MAX_ATTEMPTS", 3)
+    unpaywall_pdf_discovery_enabled: bool = _env_bool("UNPAYWALL_PDF_DISCOVERY_ENABLED", True)
+    unpaywall_pdf_discovery_max_candidates: int = _env_int("UNPAYWALL_PDF_DISCOVERY_MAX_CANDIDATES", 5)
+    unpaywall_pdf_discovery_max_html_bytes: int = _env_int("UNPAYWALL_PDF_DISCOVERY_MAX_HTML_BYTES", 500_000)
+    crossref_enabled: bool = _env_bool("CROSSREF_ENABLED", True)
+    crossref_max_rows: int = _env_int("CROSSREF_MAX_ROWS", 10)
+    crossref_timeout_seconds: float = _env_float("CROSSREF_TIMEOUT_SECONDS", 8.0)
+    crossref_min_interval_seconds: float = _env_float("CROSSREF_MIN_INTERVAL_SECONDS", 0.6)
+    crossref_max_lookups_per_request: int = _env_int("CROSSREF_MAX_LOOKUPS_PER_REQUEST", 8)
+    
+    openalex_api_key: str | None = os.getenv("OPENALEX_API_KEY")
+    crossref_api_token: str | None = os.getenv("CROSSREF_API_TOKEN")
+    crossref_api_mailto: str | None = os.getenv("CROSSREF_API_MAILTO")
+
+
+settings = Settings()
diff --git a/diag_pubs.py b/diag_pubs.py
new file mode 100644
index 0000000..2417001
--- /dev/null
+++ b/diag_pubs.py
@@ -0,0 +1,39 @@
+
+import asyncio
+from sqlalchemy import select, func
+from app.db.session import get_session_factory
+from app.db.models import Publication, ScholarPublication
+
+async def check_publications():
+    session_factory = get_session_factory()
+    async with session_factory() as session:
+        # Total publications
+        total_pubs = await session.execute(select(func.count()).select_from(Publication))
+        print(f"Total Publications: {total_pubs.scalar()}")
+
+        # Total scholar links
+        total_links = await session.execute(select(func.count()).select_from(ScholarPublication))
+        print(f"Total Scholar-Publication Links: {total_links.scalar()}")
+
+        # Check for orphans
+        orphans = await session.execute(
+            select(func.count())
+            .select_from(Publication)
+            .outerjoin(ScholarPublication, Publication.id == ScholarPublication.publication_id)
+            .where(ScholarPublication.publication_id == None)
+        )
+        print(f"Orphaned Publications (no link): {orphans.scalar()}")
+
+        # Check sorting behavior
+        latest_links = await session.execute(
+            select(Publication.title_raw, ScholarPublication.created_at)
+            .join(ScholarPublication, Publication.id == ScholarPublication.publication_id)
+            .order_by(ScholarPublication.created_at.desc())
+            .limit(10)
+        )
+        print("\nLatest 10 links by created_at:")
+        for row in latest_links:
+            print(f"- {row.created_at}: {row.title_raw[:50]}")
+
+if __name__ == "__main__":
+    asyncio.run(check_publications())
diff --git a/docs/developer/api-contract.md b/docs/developer/api-contract.md
new file mode 100644
index 0000000..6884bc6
--- /dev/null
+++ b/docs/developer/api-contract.md
@@ -0,0 +1,12 @@
+# API Contracts
+
+`Scholarr` is designed with strictly typed Pydantic V2 models, serialized across the network through standard OpenAPI `v3` specs via FastAPI.
+
+## DTO Models Structure
+FastAPI routes dynamically ingest request/response Data Transfer Objects.
+- **Example**: `PublicationListItem` no longer contains a hard-coded `.doi`. It contains a `.display_identifier` property resolving the highest confidence identifier regardless of backend origin.
+- **Testing**: Run `./scripts/check_frontend_api_contract.py` or equivalent integration steps mapped in CI to ensure that backend python routes strictly map to the TypeScript types compiled by the Frontend.
+
+## Frontend Contract Requirements
+The UI exclusively calls routes exposed by FastAPI's `APIRouter`. 
+All frontend integration tests enforce that Vue 3 Components do not assume hard properties directly outside the bounded TS schemas. This avoids type mismatch runtime explosions if the database is scaled horizontally.
diff --git a/docs/developer/architecture.md b/docs/developer/architecture.md
index 0a169e6..afa6b05 100644
--- a/docs/developer/architecture.md
+++ b/docs/developer/architecture.md
@@ -20,6 +20,32 @@ Canonical business logic belongs in `app/services/domains/*`.
 
 ## Frontend Behavior Notes
 
-- Mobile primary nav is in a left drawer and closes on route change or logout.
-- Long list views use internal scroll containers.
-- Name search remains intentionally constrained due upstream anti-bot behavior; production onboarding should prefer scholar ID/profile URL.
+- Navigation: Mobile primary nav is in a left drawer and closes on route change or logout.
+- Lists: Long list views use internal scroll containers to prevent viewport overflow.
+- Rate Limiting: Name search remains intentionally constrained due to upstream anti-bot behavior; production onboarding should prefer scholar ID/profile URLs directly if possible.
+
+## Data Integration & Acquisition Flow
+
+```mermaid
+graph TD
+    UI[Frontend Vue App] --> API[FastAPI Backend]
+    API --> Scheduler[Background Celery/Async Scheduler]
+    
+    Scheduler -->|1. Fetch HTML| Scholar[Google Scholar HTML Parser]
+    Scholar -->|2. Extract Metadata| IdentifierModule[Identifier Gathering]
+    
+    IdentifierModule -->|Search arXiv API| API1(arXiv)
+    IdentifierModule -->|Search Crossref API| API2(Crossref)
+    
+    IdentifierModule -->|3. Save Identifiers| DB[(PostgreSQL)]
+    
+    Scheduler -->|4. Resolve PDF| PDFPipeline[PDF Resolution Pipeline]
+    DB --> |Identified DOIs| PDFPipeline
+    PDFPipeline -->|Search Open Access APIs| Unpaywall(Unpaywall API)
+    
+    Unpaywall --> |Acquire PDF URL| PDFWorker[PDF Download Worker]
+    PDFWorker --> |Store PDF Metadata| DB 
+```
+
+### Identifier Engine Philosophy
+The platform previously treated the `DOI` as a hardcoded 1:1 property of a publication. It now utilizes a decoupled *Identifier Gathering* module (`PublicationIdentifier` table). A single publication can have multiple identifiers (ex. `doi`, `arxiv`, `pmid`, `pmcid`). This creates high resilience when integrating with external APIs, allowing systems like Unpaywall to be fed explicitly with high-confidence DOIs, rather than relying on unstructured search heuristics.
diff --git a/docs/developer/ingestion.md b/docs/developer/ingestion.md
new file mode 100644
index 0000000..b906f15
--- /dev/null
+++ b/docs/developer/ingestion.md
@@ -0,0 +1,26 @@
+# Ingestion System & Backoff Strategies
+
+The `ScholarIngestionService` drives the primary data acquisition loop. Since Google Scholar utilizes heavy bot protection and rate limits, this package contains nuanced backoffs to protect user networks from automated IP bans.
+
+## Ingestion Overview
+The underlying ingestion process:
+1. Receives an explicit request or background cron trigger to resolve a `scholar_profile_id`.
+2. Connects asynchronously using configured HTTPX adapters with strict browser headers.
+3. Downloads the paginated HTML feed for a user across multiple page iterations.
+4. Uses `regex` and DOM-invariants (e.g. `gsc_vcd_cib`) to pull individual publication blocks.
+
+## Handling 429 Too Many Requests
+Google Scholar aggressively throws HTTP 429 responses if multiple concurrent tabs or rapidly sequential commands query the same IP address for specific API endpoints (like `citations?view_op=view_citation...`). 
+
+Scholarr treats these distinct from random network timeouts.
+- **Network Error Retries**: Handled via `ingestion_network_error_retries` with a base backoff of `ingestion_retry_backoff_seconds` (Default 1.0s).
+- **Rate Limit 429 Retries**: When `ParseState.BLOCKED_OR_CAPTCHA` captures `blocked_http_429_rate_limited`, the system applies a dedicated cooldown. It respects `ingestion_rate_limit_retries` multiplied by `ingestion_rate_limit_backoff_seconds` (Default 30.0s). This prevents the pipeline from fatalizing a user's job completely, pausing operations seamlessly instead.
+
+## Publication Identifiers Loop
+Once a publication is built, the `gather_identifiers_for_publication` module isolates keys explicitly.
+- **Local Parsing**: Searches for direct identifiers within the HTML parameters (DOI patterns, arXiv regexes).
+- **API Fetching**: Queries secondary bibliographic platforms sequentially:
+  - `export.arxiv.org/api/query` (Queries by Title and Author strings).
+  - `crossref.restful` APIs (Queries by Title and Author strings).
+
+These identifiers are accumulated in `publication_identifiers` instead of being bound as hard-coded properties, maximizing matching resilience in the automated Unpaywall PDF acquisition stage.
diff --git a/docs/developer/overview.md b/docs/developer/overview.md
index 4d9880e..7ab91cc 100644
--- a/docs/developer/overview.md
+++ b/docs/developer/overview.md
@@ -5,5 +5,7 @@ Use this section if you are contributing code or running full quality gates.
 - [Documentation Standards](./documentation-standards.md)
 - [Local Development](./local-development.md)
 - [Architecture Boundaries](./architecture.md)
+- [Ingestion API & Backoff Strategies](./ingestion.md)
+- [API Contracts](./api-contract.md)
 - [Contributing](./contributing.md)
 - [Frontend Theme Inventory](./frontend-theme-inventory.md)
diff --git a/frontend/src/components/layout/AppNav.vue b/frontend/src/components/layout/AppNav.vue
index 788e5bf..1679059 100644
--- a/frontend/src/components/layout/AppNav.vue
+++ b/frontend/src/components/layout/AppNav.vue
@@ -39,6 +39,10 @@ const navRunStateStatus = computed(() => {
   if (runStatus.isSubmitting && !runStatus.isLikelyRunning) {
     return "starting";
   }
+  const s = runStatus.latestRun?.status;
+  if (s === "resolving") {
+    return "resolving";
+  }
   if (runStatus.isLikelyRunning) {
     return "running";
   }
diff --git a/frontend/src/components/patterns/RunStatusBadge.vue b/frontend/src/components/patterns/RunStatusBadge.vue
index 575b5c7..da5accf 100644
--- a/frontend/src/components/patterns/RunStatusBadge.vue
+++ b/frontend/src/components/patterns/RunStatusBadge.vue
@@ -20,9 +20,15 @@ const toneClass = computed(() => {
   if (props.status === "running") {
     return "border-state-info-border bg-state-info-bg text-state-info-text";
   }
+  if (props.status === "resolving") {
+    return "border-state-info-border bg-state-info-bg text-state-info-text";
+  }
   if (props.status === "starting") {
     return "border-state-info-border bg-state-info-bg text-state-info-text";
   }
+  if (props.status === "canceled") {
+    return "border-state-warning-border bg-state-warning-bg text-state-warning-text";
+  }
   return "border-stroke-default bg-surface-card-muted text-ink-secondary";
 });
 </script>
diff --git a/frontend/src/features/admin_dbops/index.ts b/frontend/src/features/admin_dbops/index.ts
index 2f042f5..0b16b3a 100644
--- a/frontend/src/features/admin_dbops/index.ts
+++ b/frontend/src/features/admin_dbops/index.ts
@@ -41,7 +41,6 @@ export interface AdminDbRepairJob {
 export interface AdminPdfQueueItem {
   publication_id: number;
   title: string;
-  doi: string | null;
   display_identifier: DisplayIdentifier | null;
   pdf_url: string | null;
   status: string;
@@ -160,3 +159,19 @@ export async function requeueAllAdminPdfLookups(limit = 1000): Promise<AdminPdfQ
   );
   return response.data;
 }
+
+export interface DropAllPublicationsResult {
+  deleted_count: number;
+  message: string;
+}
+
+export async function dropAllPublications(confirmationText: string): Promise<DropAllPublicationsResult> {
+  const response = await apiRequest<DropAllPublicationsResult>(
+    "/admin/db/drop-all-publications",
+    {
+      method: "POST",
+      body: { confirmation_text: confirmationText },
+    },
+  );
+  return response.data;
+}
diff --git a/frontend/src/features/publications/index.ts b/frontend/src/features/publications/index.ts
index f238a0e..3f80806 100644
--- a/frontend/src/features/publications/index.ts
+++ b/frontend/src/features/publications/index.ts
@@ -19,7 +19,6 @@ export interface PublicationItem {
   citation_count: number;
   venue_text: string | null;
   pub_url: string | null;
-  doi: string | null;
   display_identifier: DisplayIdentifier | null;
   pdf_url: string | null;
   pdf_status: "untracked" | "queued" | "running" | "resolved" | "failed";
@@ -44,6 +43,7 @@ export interface PublicationsResult {
   total_count: number;
   page: number;
   page_size: number;
+  snapshot: string;
   has_next: boolean;
   has_prev: boolean;
   publications: PublicationItem[];
@@ -53,8 +53,12 @@ export interface PublicationsQuery {
   mode?: PublicationMode;
   favoriteOnly?: boolean;
   scholarProfileId?: number;
+  search?: string;
+  sortBy?: string;
+  sortDir?: "asc" | "desc";
   page?: number;
   pageSize?: number;
+  snapshot?: string;
 }
 
 export interface PublicationSelection {
@@ -74,12 +78,24 @@ export async function listPublications(query: PublicationsQuery = {}): Promise<P
   if (query.scholarProfileId) {
     params.set("scholar_profile_id", String(query.scholarProfileId));
   }
+  if (query.search && query.search.trim().length > 0) {
+    params.set("search", query.search.trim());
+  }
+  if (query.sortBy) {
+    params.set("sort_by", query.sortBy);
+  }
+  if (query.sortDir) {
+    params.set("sort_dir", query.sortDir);
+  }
   const parsedPage = Number.isFinite(query.page) ? Math.max(1, Math.trunc(Number(query.page))) : 1;
   const parsedPageSize = Number.isFinite(query.pageSize)
     ? Math.max(1, Math.min(500, Math.trunc(Number(query.pageSize))))
     : 100;
   params.set("page", String(parsedPage));
   params.set("page_size", String(parsedPageSize));
+  if (query.snapshot && query.snapshot.trim().length > 0) {
+    params.set("snapshot", query.snapshot.trim());
+  }
 
   const suffix = params.toString();
   const response = await apiRequest<PublicationsResult>(
diff --git a/frontend/src/features/runs/index.ts b/frontend/src/features/runs/index.ts
index 97d49c6..735776d 100644
--- a/frontend/src/features/runs/index.ts
+++ b/frontend/src/features/runs/index.ts
@@ -145,6 +145,13 @@ export async function triggerManualRun(): Promise<{
   return response.data;
 }
 
+export async function cancelRun(runId: number): Promise<RunDetail> {
+  const response = await apiRequest<RunDetail>(`/runs/${runId}/cancel`, {
+    method: "POST",
+  });
+  return response.data;
+}
+
 export async function listQueueItems(limit = 200): Promise<QueueItem[]> {
   const response = await apiRequest<QueueListData>(`/runs/queue/items?limit=${limit}`, {
     method: "GET",
diff --git a/frontend/src/features/scholars/index.ts b/frontend/src/features/scholars/index.ts
index db19e76..ef3c8c4 100644
--- a/frontend/src/features/scholars/index.ts
+++ b/frontend/src/features/scholars/index.ts
@@ -54,7 +54,6 @@ export interface PublicationExportItem {
   author_text: string | null;
   venue_text: string | null;
   pub_url: string | null;
-  doi: string | null;
   pdf_url: string | null;
   is_read: boolean;
 }
@@ -86,7 +85,7 @@ interface ScholarsListData {
   scholars: ScholarProfile[];
 }
 
-interface ScholarSearchData extends ScholarSearchResult {}
+interface ScholarSearchData extends ScholarSearchResult { }
 
 export async function listScholars(): Promise<ScholarProfile[]> {
   const response = await apiRequest<ScholarsListData>("/scholars", { method: "GET" });
diff --git a/frontend/src/features/settings/SettingsAdminPanel.vue b/frontend/src/features/settings/SettingsAdminPanel.vue
index 7edf67b..e5edfb4 100644
--- a/frontend/src/features/settings/SettingsAdminPanel.vue
+++ b/frontend/src/features/settings/SettingsAdminPanel.vue
@@ -14,6 +14,7 @@ import AppRefreshButton from "@/components/ui/AppRefreshButton.vue";
 import AppSelect from "@/components/ui/AppSelect.vue";
 import AppTable from "@/components/ui/AppTable.vue";
 import {
+  dropAllPublications,
   getAdminDbIntegrityReport,
   listAdminDbRepairJobs,
   listAdminPdfQueue,
@@ -42,6 +43,7 @@ const SECTION_PDF = "pdf";
 const SCOPE_SINGLE_USER = "single_user";
 const SCOPE_ALL_USERS = "all_users";
 const APPLY_ALL_USERS_CONFIRM_TEXT = "REPAIR ALL USERS";
+const DROP_PUBLICATIONS_CONFIRM_TEXT = "DROP ALL PUBLICATIONS";
 
 type RepairScopeMode = typeof SCOPE_SINGLE_USER | typeof SCOPE_ALL_USERS;
 
@@ -81,6 +83,13 @@ const repairDryRun = ref(true);
 const repairGcOrphans = ref(false);
 const repairConfirmationText = ref("");
 
+const droppingPublications = ref(false);
+const dropConfirmationText = ref("");
+const dropResult = ref<{ deleted_count: number; message: string } | null>(null);
+const dropConfirmationValid = computed(
+  () => dropConfirmationText.value.trim() === DROP_PUBLICATIONS_CONFIRM_TEXT,
+);
+
 const refreshingPdfQueue = ref(false);
 const requeueingPublicationId = ref<number | null>(null);
 const requeueingAllPdfs = ref(false);
@@ -433,6 +442,22 @@ async function onRequeueAllPdfs(): Promise<void> {
   }
 }
 
+async function onDropAllPublications(): Promise<void> {
+  droppingPublications.value = true;
+  clearAlerts();
+  dropResult.value = null;
+  try {
+    const result = await dropAllPublications(dropConfirmationText.value.trim());
+    dropResult.value = result;
+    successMessage.value = result.message;
+    dropConfirmationText.value = "";
+  } catch (error) {
+    assignError(error, "Unable to drop publications.");
+  } finally {
+    droppingPublications.value = false;
+  }
+}
+
 onMounted(async () => {
   loading.value = true;
   clearAlerts();
@@ -686,6 +711,45 @@ watch(
             </tbody>
           </AppTable>
         </AppCard>
+
+        <AppCard class="space-y-3 border-danger-300 dark:border-danger-700">
+          <div class="flex items-center gap-1">
+            <h2 class="text-lg font-semibold text-danger-600 dark:text-danger-400">Drop All Publications</h2>
+            <AppHelpHint text="Permanently delete ALL publications, links, identifiers, and PDF jobs. Scholar baselines will be reset so the next run re-discovers everything." />
+          </div>
+
+          <p class="text-sm text-secondary">
+            This action is <strong>irreversible</strong>. It deletes every publication record across all users.
+            The next ingestion run will re-populate all data from scratch.
+          </p>
+
+          <form class="grid gap-3" @submit.prevent="onDropAllPublications">
+            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+              <span>Type '{{ DROP_PUBLICATIONS_CONFIRM_TEXT }}' to confirm</span>
+              <AppInput
+                v-model="dropConfirmationText"
+                :placeholder="DROP_PUBLICATIONS_CONFIRM_TEXT"
+                autocomplete="off"
+              />
+            </label>
+            <div>
+              <AppButton
+                type="submit"
+                variant="danger"
+                :disabled="droppingPublications || !dropConfirmationValid"
+              >
+                {{ droppingPublications ? "Dropping..." : "Drop all publications" }}
+              </AppButton>
+            </div>
+          </form>
+
+          <div v-if="dropResult" class="rounded-lg border border-stroke-default bg-surface-card-muted p-3 text-xs">
+            <div class="mb-1 flex items-center gap-2">
+              <AppBadge tone="danger">Deleted: {{ dropResult.deleted_count }}</AppBadge>
+            </div>
+            <p class="text-secondary">{{ dropResult.message }}</p>
+          </div>
+        </AppCard>
       </section>
 
       <AppCard v-if="props.section === SECTION_PDF" class="space-y-3">
diff --git a/frontend/src/features/settings/index.ts b/frontend/src/features/settings/index.ts
index e8ef325..6ff6c94 100644
--- a/frontend/src/features/settings/index.ts
+++ b/frontend/src/features/settings/index.ts
@@ -19,6 +19,9 @@ export interface UserSettings {
   nav_visible_pages: string[];
   policy: UserSettingsPolicy;
   safety_state: ScrapeSafetyState;
+  openalex_api_key: string | null;
+  crossref_api_token: string | null;
+  crossref_api_mailto: string | null;
 }
 
 export interface UserSettingsUpdate {
@@ -26,6 +29,9 @@ export interface UserSettingsUpdate {
   run_interval_minutes: number;
   request_delay_seconds: number;
   nav_visible_pages: string[];
+  openalex_api_key: string | null;
+  crossref_api_token: string | null;
+  crossref_api_mailto: string | null;
 }
 
 export interface ChangePasswordPayload {
diff --git a/frontend/src/pages/DashboardPage.vue b/frontend/src/pages/DashboardPage.vue
index e61df8d..90d8513 100644
--- a/frontend/src/pages/DashboardPage.vue
+++ b/frontend/src/pages/DashboardPage.vue
@@ -64,6 +64,7 @@ const startCheckLabel = computed(() => {
 const isStartCheckAnimating = computed(
   () => runStatus.isSubmitting || runStatus.isLikelyRunning,
 );
+const isCancelAnimating = ref(false);
 
 const displayedLatestRun = computed(() => {
   const snapshotLatest = snapshot.value?.latestRun ?? null;
@@ -102,6 +103,25 @@ const recentRuns = computed(() => {
   mergedRuns.splice(existingIndex, 1, latest);
   return mergedRuns;
 });
+
+const recentPublications = computed(() => {
+  const stream = runStatus.livePublications;
+  // DashboardSnapshot's recentPublications is compatible with PublicationItem,
+  // but let's cast it slightly to guarantee iteration.
+  const base = snapshot.value?.recentPublications ?? [];
+  const merged = [...stream, ...base];
+  
+  const seenIds = new Set();
+  const deduped: any[] = [];
+  for (const item of merged) {
+    if (!seenIds.has(item.publication_id)) {
+      seenIds.add(item.publication_id);
+      deduped.push(item);
+    }
+  }
+  return deduped;
+});
+
 const activeRunId = computed(() => runStatus.latestRun?.status === "running" ? runStatus.latestRun.id : null);
 const showRunningHint = computed(
   () => runStatus.isLikelyRunning && displayedLatestRun.value?.status !== "running",
@@ -178,7 +198,6 @@ async function onTriggerRun(): Promise<void> {
       return;
     }
 
-    errorMessage.value = result.message;
     errorRequestId.value = result.requestId;
   } catch {
     errorMessage.value = "Unable to start an update check.";
@@ -186,6 +205,28 @@ async function onTriggerRun(): Promise<void> {
   }
 }
 
+async function onCancelRun(): Promise<void> {
+  if (!activeRunId.value) return;
+  errorMessage.value = null;
+  errorRequestId.value = null;
+  successMessage.value = null;
+  isCancelAnimating.value = true;
+
+  try {
+    const result = await runStatus.cancelActiveCheck();
+    if (result.kind === "success") {
+      successMessage.value = "Update check canceled successfully.";
+      await loadSnapshot();
+    } else {
+      errorMessage.value = result.message;
+    }
+  } catch {
+    errorMessage.value = "Unable to cancel the update check.";
+  } finally {
+    isCancelAnimating.value = false;
+  }
+}
+
 onMounted(() => {
   void loadSnapshot();
   void runStatus.syncLatest();
@@ -252,14 +293,14 @@ watch(
                 </div>
 
                 <AppEmptyState
-                  v-if="snapshot.recentPublications.length === 0"
+                  v-if="recentPublications.length === 0"
                   title="No new publications"
                   body="When a completed update check discovers changes, they will appear here."
                 />
 
                 <ul v-else class="grid min-h-0 flex-1 content-start gap-3 overflow-y-scroll overscroll-contain pr-1">
                   <li
-                    v-for="item in snapshot.recentPublications.slice(0, 20)"
+                    v-for="item in recentPublications.slice(0, 20)"
                     :key="item.publication_id"
                     class="grid gap-1 rounded-xl border border-stroke-default bg-surface-card-muted px-3 py-2"
                   >
@@ -328,6 +369,22 @@ watch(
                       />
                     </div>
                     <div class="flex items-center gap-2">
+                      <AppButton
+                        v-if="auth.isAdmin && runStatus.isLikelyRunning"
+                        variant="danger"
+                        :disabled="!activeRunId || isCancelAnimating.value"
+                        @click="onCancelRun"
+                      >
+                        <span class="inline-flex items-center gap-2">
+                          <span v-if="isCancelAnimating" class="relative inline-flex h-2.5 w-2.5">
+                            <span
+                              class="absolute inline-flex h-full w-full animate-ping rounded-full bg-current opacity-60"
+                            />
+                            <span class="relative inline-flex h-2.5 w-2.5 rounded-full bg-current" />
+                          </span>
+                          Cancel check
+                        </span>
+                      </AppButton>
                       <AppButton
                         v-if="auth.isAdmin"
                         :disabled="isStartBlocked"
diff --git a/frontend/src/pages/PublicationsPage.vue b/frontend/src/pages/PublicationsPage.vue
index 21afc03..35b7f06 100644
--- a/frontend/src/pages/PublicationsPage.vue
+++ b/frontend/src/pages/PublicationsPage.vue
@@ -30,11 +30,9 @@ import { useUserSettingsStore } from "@/stores/user_settings";
 
 type PublicationSortKey =
   | "title"
-  | "favorite"
   | "scholar"
   | "year"
   | "citations"
-  | "status"
   | "first_seen";
 
 type BulkAction =
@@ -56,6 +54,7 @@ const sortKey = ref<PublicationSortKey>("first_seen");
 const sortDirection = ref<"asc" | "desc">("desc");
 const currentPage = ref(1);
 const pageSize = ref("50");
+const publicationSnapshot = ref<string | null>(null);
 
 const scholars = ref<ScholarProfile[]>([]);
 const listState = ref<PublicationsResult | null>(null);
@@ -190,27 +189,42 @@ const selectedScholarName = computed(() => {
 });
 
 const filteredPublications = computed(() => {
+  let stream = [...runStatus.livePublications];
+  if (favoriteOnly.value) {
+    stream = stream.filter((p) => p.is_favorite);
+  }
+  if (mode.value === "unread") {
+    stream = stream.filter((p) => !p.is_read);
+  }
+  const selectedScholarId = Number(selectedScholarFilter.value);
+  if (Number.isInteger(selectedScholarId) && selectedScholarId > 0) {
+    stream = stream.filter((p) => p.scholar_profile_id === selectedScholarId);
+  }
+
   const base = listState.value?.publications ?? [];
+  const merged = [...stream, ...base];
+  const seenIds = new Set();
+  const deduped: typeof base = [];
+  for (const item of merged) {
+    if (!seenIds.has(item.publication_id)) {
+      seenIds.add(item.publication_id);
+      deduped.push(item);
+    }
+  }
+
   const normalized = searchQuery.value.trim().toLowerCase();
   if (!normalized) {
-    return base;
+    return deduped;
   }
-  return base.filter((item) => {
-    const year = item.year === null ? "" : String(item.year);
-    return [item.title, item.scholar_label, item.venue_text || "", year]
-      .join(" ")
-      .toLowerCase()
-      .includes(normalized);
-  });
+  // Client-side fallback: filter live-discovered publications that haven't been
+  // server-round-tripped yet. The main server query already filters by search.
+  return deduped;
 });
 
 function publicationSortValue(item: PublicationItem, key: PublicationSortKey): number | string {
   if (key === "title") {
     return item.title;
   }
-  if (key === "favorite") {
-    return item.is_favorite ? 1 : 0;
-  }
   if (key === "scholar") {
     return item.scholar_label;
   }
@@ -220,38 +234,14 @@ function publicationSortValue(item: PublicationItem, key: PublicationSortKey): n
   if (key === "citations") {
     return item.citation_count;
   }
-  if (key === "status") {
-    if (item.is_read) {
-      return 2;
-    }
-    if (item.is_new_in_latest_run) {
-      return 0;
-    }
-    return 1;
-  }
   const timestamp = Date.parse(item.first_seen_at);
   return Number.isNaN(timestamp) ? 0 : timestamp;
 }
 
 const sortedPublications = computed(() => {
-  const sorted = [...filteredPublications.value];
-  sorted.sort((a, b) => {
-    const left = publicationSortValue(a, sortKey.value);
-    const right = publicationSortValue(b, sortKey.value);
-
-    let comparison: number;
-    if (typeof left === "string" && typeof right === "string") {
-      comparison = textCollator.compare(left, right);
-    } else {
-      comparison = Number(left) - Number(right);
-    }
-
-    if (comparison === 0) {
-      comparison = textCollator.compare(a.title, b.title);
-    }
-    return sortDirection.value === "asc" ? comparison : comparison * -1;
-  });
-  return sorted;
+  // Server already returns data in the correct sort order.
+  // We just pass through the filtered/merged list without client-side re-sorting.
+  return filteredPublications.value;
 });
 
 const visibleUnreadKeys = computed(() => {
@@ -437,13 +427,16 @@ watch(hasSelection, (nextHasSelection) => {
   bulkAction.value = nextHasSelection ? "mark_selected_read" : "mark_all_unread_read";
 });
 
-function toggleSort(nextKey: PublicationSortKey): void {
+async function toggleSort(nextKey: PublicationSortKey): Promise<void> {
   if (sortKey.value === nextKey) {
     sortDirection.value = sortDirection.value === "asc" ? "desc" : "asc";
-    return;
+  } else {
+    sortKey.value = nextKey;
+    sortDirection.value = nextKey === "first_seen" ? "desc" : "asc";
   }
-  sortKey.value = nextKey;
-  sortDirection.value = nextKey === "first_seen" ? "desc" : "asc";
+  currentPage.value = 1;
+  publicationSnapshot.value = null;
+  await loadPublications();
 }
 
 function sortMarker(key: PublicationSortKey): string {
@@ -476,9 +469,14 @@ async function loadPublications(): Promise<void> {
       mode: mode.value,
       favoriteOnly: favoriteOnly.value,
       scholarProfileId: selectedScholarId(),
+      search: searchQuery.value.trim() || undefined,
+      sortBy: sortKey.value,
+      sortDir: sortDirection.value,
       page: currentPage.value,
       pageSize: pageSizeValue.value,
+      snapshot: publicationSnapshot.value ?? undefined,
     });
+    publicationSnapshot.value = listState.value.snapshot;
     currentPage.value = listState.value.page;
     pageSize.value = String(listState.value.page_size);
     selectedPublicationKeys.value = new Set();
@@ -498,12 +496,14 @@ async function loadPublications(): Promise<void> {
 
 async function onModeChanged(): Promise<void> {
   currentPage.value = 1;
+  publicationSnapshot.value = null;
   await syncFiltersToRoute();
   await loadPublications();
 }
 
 async function onScholarFilterChanged(): Promise<void> {
   currentPage.value = 1;
+  publicationSnapshot.value = null;
   await syncFiltersToRoute();
   await loadPublications();
 }
@@ -511,12 +511,14 @@ async function onScholarFilterChanged(): Promise<void> {
 async function onFavoriteOnlyChanged(): Promise<void> {
   favoriteOnly.value = !favoriteOnly.value;
   currentPage.value = 1;
+  publicationSnapshot.value = null;
   await syncFiltersToRoute();
   await loadPublications();
 }
 
 async function onPageSizeChanged(): Promise<void> {
   currentPage.value = 1;
+  publicationSnapshot.value = null;
   await syncFiltersToRoute();
   await loadPublications();
 }
@@ -605,15 +607,15 @@ function canRetryPublicationPdf(item: PublicationItem): boolean {
 
 function pdfPendingLabel(item: PublicationItem): string {
   if (item.pdf_status === "queued") {
-    return "queued";
+    return "Queued";
   }
   if (item.pdf_status === "running") {
-    return "resolving";
+    return "Resolving...";
   }
   if (item.pdf_status === "failed") {
-    return "failed";
+    return "Missing";
   }
-  return "untracked";
+  return "Untracked";
 }
 
 function replacePublication(updated: PublicationItem): void {
@@ -784,6 +786,18 @@ function resetSearchQuery(): void {
   searchQuery.value = "";
 }
 
+let searchDebounceTimer: ReturnType<typeof setTimeout> | null = null;
+watch(searchQuery, () => {
+  if (searchDebounceTimer !== null) {
+    clearTimeout(searchDebounceTimer);
+  }
+  searchDebounceTimer = setTimeout(() => {
+    currentPage.value = 1;
+    publicationSnapshot.value = null;
+    void loadPublications();
+  }, 300);
+});
+
 onMounted(() => {
   syncFiltersFromRoute();
   void Promise.all([loadScholarFilters(), loadPublications(), runStatus.syncLatest()]);
@@ -792,10 +806,18 @@ onMounted(() => {
 watch(
   () => [route.query.scholar, route.query.favorite, route.query.page],
   async () => {
+    const previousScholar = selectedScholarFilter.value;
+    const previousFavorite = favoriteOnly.value;
     const changed = syncFiltersFromRoute();
     if (!changed) {
       return;
     }
+    if (
+      selectedScholarFilter.value !== previousScholar
+      || favoriteOnly.value !== previousFavorite
+    ) {
+      publicationSnapshot.value = null;
+    }
     await loadPublications();
   },
 );
@@ -843,7 +865,7 @@ watch(
         <label class="grid gap-1 text-xs text-secondary" for="publications-search-input">
           <span class="inline-flex items-center gap-1">
             Search
-            <AppHelpHint text="Searches title, scholar, venue, and year within currently loaded results." />
+            <AppHelpHint text="Searches title, scholar name, and venue." />
           </span>
           <div class="flex min-w-0 items-center gap-2">
             <AppInput
@@ -975,11 +997,7 @@ watch(
                   @change="onToggleAllVisible"
                 />
               </th>
-              <th scope="col" class="w-12">
-                <button type="button" class="table-sort" @click="toggleSort('favorite')">
-                  ★ <span aria-hidden="true" class="sort-marker">{{ sortMarker('favorite') }}</span>
-                </button>
-              </th>
+              <th scope="col" class="w-12 text-left font-semibold text-ink-primary">★</th>
               <th scope="col" class="w-[44%] min-w-[24rem]">
                 <button type="button" class="table-sort" @click="toggleSort('title')">
                   Title <span aria-hidden="true" class="sort-marker">{{ sortMarker('title') }}</span>
@@ -990,7 +1008,7 @@ watch(
                   Scholar <span aria-hidden="true" class="sort-marker">{{ sortMarker('scholar') }}</span>
                 </button>
               </th>
-              <th scope="col" class="w-[8.5rem] whitespace-nowrap">PDF</th>
+              <th scope="col" class="w-[8.5rem] whitespace-nowrap text-left font-semibold text-ink-primary">PDF</th>
               <th scope="col" class="w-16 whitespace-nowrap">
                 <button type="button" class="table-sort" @click="toggleSort('year')">
                   Year <span aria-hidden="true" class="sort-marker">{{ sortMarker('year') }}</span>
@@ -1001,11 +1019,7 @@ watch(
                   Citations <span aria-hidden="true" class="sort-marker">{{ sortMarker('citations') }}</span>
                 </button>
               </th>
-              <th scope="col" class="w-44 whitespace-nowrap">
-                <button type="button" class="table-sort" @click="toggleSort('status')">
-                  Read status <span aria-hidden="true" class="sort-marker">{{ sortMarker('status') }}</span>
-                </button>
-              </th>
+              <th scope="col" class="w-44 whitespace-nowrap text-left font-semibold text-ink-primary">Read status</th>
               <th scope="col" class="w-32 whitespace-nowrap">
                 <button type="button" class="table-sort" @click="toggleSort('first_seen')">
                   First seen <span aria-hidden="true" class="sort-marker">{{ sortMarker('first_seen') }}</span>
@@ -1073,8 +1087,12 @@ watch(
                   target="_blank"
                   rel="noreferrer"
                   class="pdf-link-button"
+                  title="Open PDF"
                 >
-                  PDF
+                  <svg class="mr-1 h-3 w-3" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14" />
+                  </svg>
+                  Available
                 </a>
                 <button
                   v-else-if="canRetryPublicationPdf(item)"
@@ -1083,9 +1101,19 @@ watch(
                   :disabled="isRetryingPublication(item)"
                   @click="onRetryPdf(item)"
                 >
-                  {{ isRetryingPublication(item) ? "..." : "retry" }}
+                  <svg v-if="isRetryingPublication(item)" class="mr-1 h-3 w-3 animate-spin" viewBox="0 0 24 24" fill="none">
+                    <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                    <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                  </svg>
+                  {{ isRetryingPublication(item) ? "Retrying..." : "Missing (Retry)" }}
                 </button>
-                <span v-else class="pdf-state-label">{{ pdfPendingLabel(item) }}</span>
+                <span v-else class="pdf-state-label" :class="{ 'bg-surface-accent-muted border-accent-300 text-accent-700': item.pdf_status === 'running' || item.pdf_status === 'queued' }">
+                  <svg v-if="item.pdf_status === 'running'" class="mr-1 h-3 w-3 animate-spin text-accent-600" viewBox="0 0 24 24" fill="none">
+                    <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                    <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                  </svg>
+                  {{ pdfPendingLabel(item) }}
+                </span>
               </td>
               <td class="whitespace-nowrap">{{ item.year ?? "n/a" }}</td>
               <td class="whitespace-nowrap">{{ item.citation_count }}</td>
diff --git a/frontend/src/pages/RunsPage.vue b/frontend/src/pages/RunsPage.vue
index 711158c..d28a3dc 100644
--- a/frontend/src/pages/RunsPage.vue
+++ b/frontend/src/pages/RunsPage.vue
@@ -23,6 +23,7 @@ import {
   type RunListItem,
 } from "@/features/runs";
 import { ApiRequestError } from "@/lib/api/errors";
+import { useAuthStore } from "@/stores/auth";
 import { useRunStatusStore } from "@/stores/run_status";
 import { useUserSettingsStore } from "@/stores/user_settings";
 
@@ -33,8 +34,10 @@ const errorMessage = ref<string | null>(null);
 const errorRequestId = ref<string | null>(null);
 const successMessage = ref<string | null>(null);
 const activeQueueItemId = ref<number | null>(null);
+const auth = useAuthStore();
 const runStatus = useRunStatusStore();
 const userSettings = useUserSettingsStore();
+const isCancelAnimating = ref(false);
 
 function formatDate(value: string | null): string {
   if (!value) {
@@ -62,7 +65,7 @@ function queueHealth() {
 }
 
 const queueCounts = computed(() => queueHealth());
-const activeRunId = computed(() => runStatus.latestRun?.status === "running" ? runStatus.latestRun.id : null);
+const activeRunId = computed(() => runStatus.isRunActive && runStatus.latestRun ? runStatus.latestRun.id : null);
 const isStartBlocked = computed(
   () =>
     runStatus.isRunActive ||
@@ -151,6 +154,28 @@ async function onTriggerManualRun(): Promise<void> {
   }
 }
 
+async function onCancelRun(): Promise<void> {
+  if (!activeRunId.value) return;
+  errorMessage.value = null;
+  errorRequestId.value = null;
+  successMessage.value = null;
+  isCancelAnimating.value = true;
+
+  try {
+    const result = await runStatus.cancelActiveCheck();
+    if (result.kind === "success") {
+      successMessage.value = "Update check canceled successfully.";
+      await loadData();
+    } else {
+      errorMessage.value = result.message;
+    }
+  } catch {
+    errorMessage.value = "Unable to cancel the update check.";
+  } finally {
+    isCancelAnimating.value = false;
+  }
+}
+
 async function runQueueAction(itemId: number, action: "retry" | "drop" | "clear"): Promise<void> {
   activeQueueItemId.value = itemId;
   successMessage.value = null;
@@ -208,6 +233,22 @@ onMounted(() => {
         :manual-run-allowed="userSettings.manualRunAllowed"
       />
       <div class="flex flex-wrap items-center gap-2">
+        <AppButton
+          v-if="runStatus.isRunActive"
+          variant="danger"
+          :disabled="!activeRunId || isCancelAnimating"
+          @click="onCancelRun"
+        >
+          <span class="inline-flex items-center gap-2">
+            <span v-if="isCancelAnimating" class="relative inline-flex h-2.5 w-2.5">
+              <span
+                class="absolute inline-flex h-full w-full animate-ping rounded-full bg-current opacity-60"
+              />
+              <span class="relative inline-flex h-2.5 w-2.5 rounded-full bg-current" />
+            </span>
+            Cancel check
+          </span>
+        </AppButton>
         <AppButton :disabled="isStartBlocked" :title="startCheckDisabledReason || undefined" @click="onTriggerManualRun">
           {{ runButtonLabel }}
         </AppButton>
diff --git a/frontend/src/pages/SettingsPage.vue b/frontend/src/pages/SettingsPage.vue
index a7b00b1..66f12eb 100644
--- a/frontend/src/pages/SettingsPage.vue
+++ b/frontend/src/pages/SettingsPage.vue
@@ -30,6 +30,7 @@ const TAB_ADMIN_USERS = "admin-users";
 const TAB_ADMIN_INTEGRITY = "admin-integrity";
 const TAB_ADMIN_REPAIRS = "admin-repairs";
 const TAB_ADMIN_PDF = "admin-pdf";
+const TAB_ADMIN_INTEGRATIONS = "admin-integrations";
 
 const auth = useAuthStore();
 const userSettings = useUserSettingsStore();
@@ -45,6 +46,9 @@ const autoRunEnabled = ref(false);
 const runIntervalMinutes = ref("60");
 const requestDelaySeconds = ref("2");
 const navVisiblePages = ref<string[]>([]);
+const openalexApiKey = ref("");
+const crossrefApiToken = ref("");
+const crossrefApiMailto = ref("");
 
 const currentPassword = ref("");
 const newPassword = ref("");
@@ -72,6 +76,7 @@ const tabItems = computed<AppTabItem[]>(() => {
       { id: TAB_ADMIN_INTEGRITY, label: "Integrity" },
       { id: TAB_ADMIN_REPAIRS, label: "Repairs" },
       { id: TAB_ADMIN_PDF, label: "PDF Queue" },
+      { id: TAB_ADMIN_INTEGRATIONS, label: "Integrations" },
     );
   }
   return tabs;
@@ -129,6 +134,10 @@ function hydrateSettings(settings: UserSettings): void {
   requestDelaySeconds.value = String(settings.request_delay_seconds);
   navVisiblePages.value = normalizeUserNavVisiblePages(settings.nav_visible_pages);
 
+  openalexApiKey.value = settings.openalex_api_key ?? "";
+  crossrefApiToken.value = settings.crossref_api_token ?? "";
+  crossrefApiMailto.value = settings.crossref_api_mailto ?? "";
+
   userSettings.applySettings(settings);
   runStatus.setSafetyState(settings.safety_state);
 }
@@ -183,6 +192,9 @@ async function onSaveSettings(): Promise<void> {
         minRequestDelaySeconds.value,
       ),
       nav_visible_pages: normalizeUserNavVisiblePages(navVisiblePages.value),
+      openalex_api_key: openalexApiKey.value.trim() || null,
+      crossref_api_token: crossrefApiToken.value.trim() || null,
+      crossref_api_mailto: crossrefApiMailto.value.trim() || null,
     };
 
     const saved = await updateSettings(payload);
@@ -357,6 +369,50 @@ onMounted(async () => {
           </form>
         </section>
 
+        <section v-if="activeTab === TAB_ADMIN_INTEGRATIONS" class="grid gap-4">
+          <div class="flex items-center gap-1">
+            <h2 class="text-lg font-semibold text-ink-primary">API Integrations</h2>
+            <AppHelpHint text="Configure API keys for external services like OpenAlex and Crossref. These are global system settings." />
+          </div>
+          <p class="text-sm text-secondary">If no keys are provided, the system will gracefully fall back to free unauthenticated tiers where available.</p>
+
+          <div class="grid gap-3">
+            <div class="grid gap-2 rounded-lg border border-stroke-default bg-surface-card-muted p-3">
+              <h3 class="text-sm font-semibold text-ink-secondary">OpenAlex</h3>
+              <p class="text-xs text-secondary mb-2">
+                OpenAlex is a free index of the world's research. Providing a key unlocks a higher rate limit. 
+                Values returned from the backend might be 'SET' to hide the raw key for security.
+              </p>
+              <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+                <span>API Key</span>
+                <AppInput v-model="openalexApiKey" placeholder="e.g. iBo3Ye2q322zKYkEyI..." autocomplete="off" />
+              </label>
+            </div>
+
+            <div class="grid gap-2 rounded-lg border border-stroke-default bg-surface-card-muted p-3">
+              <h3 class="text-sm font-semibold text-ink-secondary">Crossref</h3>
+              <p class="text-xs text-secondary mb-2">
+                Crossref metadata search for DOIs. A "mailto" address puts you in their "Polite Pool" for better performance. 
+                A Plus API token unlocks the fastest tier.
+              </p>
+              <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+                <span>API Token (Plus)</span>
+                <AppInput v-model="crossrefApiToken" placeholder="Usually empty unless you have an enterprise Plus account" autocomplete="off" />
+              </label>
+              <label class="grid gap-1 text-sm font-medium text-ink-secondary mt-2">
+                <span>Mailto (Polite Pool)</span>
+                <AppInput v-model="crossrefApiMailto" placeholder="e.g. admin@yourdomain.com" type="email" autocomplete="off" />
+              </label>
+            </div>
+          </div>
+
+          <div>
+            <AppButton :disabled="saving" @click="onSaveSettings">
+              {{ saving ? "Saving..." : "Save integrations" }}
+            </AppButton>
+          </div>
+        </section>
+
         <SettingsAdminPanel v-if="activeAdminSection" :section="activeAdminSection" />
       </AppCard>
     </AsyncStateGate>
diff --git a/frontend/src/stores/run_status.test.ts b/frontend/src/stores/run_status.test.ts
index ec04bf4..99bf552 100644
--- a/frontend/src/stores/run_status.test.ts
+++ b/frontend/src/stores/run_status.test.ts
@@ -7,9 +7,10 @@ import { createDefaultSafetyState } from "@/features/safety";
 vi.mock("@/features/runs", () => ({
   listRuns: vi.fn(),
   triggerManualRun: vi.fn(),
+  cancelRun: vi.fn(),
 }));
 
-import { listRuns, triggerManualRun } from "@/features/runs";
+import { cancelRun, listRuns, triggerManualRun } from "@/features/runs";
 import {
   RUN_STATUS_POLL_INTERVAL_MS,
   RUN_STATUS_STARTING_PHASE_MS,
@@ -51,11 +52,13 @@ function buildRunsPayload(runs: ReturnType<typeof buildRun>[]) {
 describe("run status store", () => {
   const mockedListRuns = vi.mocked(listRuns);
   const mockedTriggerManualRun = vi.mocked(triggerManualRun);
+  const mockedCancelRun = vi.mocked(cancelRun);
 
   beforeEach(() => {
     setActivePinia(createPinia());
     mockedListRuns.mockReset();
     mockedTriggerManualRun.mockReset();
+    mockedCancelRun.mockReset();
     vi.useRealTimers();
   });
 
@@ -223,4 +226,87 @@ describe("run status store", () => {
     await startPromise;
     expect(store.isRunActive).toBe(true);
   });
+
+  it("cancels an active check and transitions to canceled state", async () => {
+    mockedCancelRun.mockResolvedValueOnce({
+      run: buildRun({ id: 50, status: "canceled" }),
+      summary: {
+        succeeded_count: 0,
+        failed_count: 0,
+        partial_count: 0,
+        failed_state_counts: {},
+        failed_reason_counts: {},
+        scrape_failure_counts: {},
+        retry_counts: {
+          retries_scheduled_count: 0,
+          scholars_with_retries_count: 0,
+          retry_exhausted_count: 0,
+        },
+        alert_thresholds: {},
+        alert_flags: {},
+      },
+      scholar_results: [],
+      safety_state: createDefaultSafetyState(),
+    } as any);
+
+    const store = useRunStatusStore();
+    store.setLatestRun(buildRun({ id: 50, status: "running", end_dt: null }));
+    expect(store.isRunActive).toBe(true);
+
+    const result = await store.cancelActiveCheck();
+
+    expect(result.kind).toBe("success");
+    expect(store.latestRun?.status).toBe("canceled");
+    expect(store.isRunActive).toBe(false);
+    expect(store.isPolling).toBe(false);
+  });
+
+  it("cancels a resolving run using server status as source of truth", async () => {
+    mockedCancelRun.mockResolvedValueOnce({
+      run: buildRun({ id: 72, status: "failed" }),
+      summary: {
+        succeeded_count: 0,
+        failed_count: 1,
+        partial_count: 0,
+        failed_state_counts: {},
+        failed_reason_counts: {},
+        scrape_failure_counts: {},
+        retry_counts: {
+          retries_scheduled_count: 0,
+          scholars_with_retries_count: 0,
+          retry_exhausted_count: 0,
+        },
+        alert_thresholds: {},
+        alert_flags: {},
+      },
+      scholar_results: [],
+      safety_state: createDefaultSafetyState(),
+    } as any);
+
+    const store = useRunStatusStore();
+    store.setLatestRun(buildRun({ id: 72, status: "resolving", end_dt: null }));
+
+    const result = await store.cancelActiveCheck();
+
+    expect(result.kind).toBe("success");
+    expect(store.latestRun?.status).toBe("failed");
+    expect(store.isRunActive).toBe(false);
+  });
+
+  it("reconciles poll responses without regressing publication counters", async () => {
+    mockedListRuns.mockResolvedValueOnce(
+      buildRunsPayload([buildRun({ id: 99, status: "running", new_publication_count: 1, end_dt: null })]),
+    );
+
+    const store = useRunStatusStore();
+    await store.syncLatest();
+    store.latestRun = buildRun({ id: 99, status: "running", new_publication_count: 5, end_dt: null });
+
+    mockedListRuns.mockResolvedValueOnce(
+      buildRunsPayload([buildRun({ id: 99, status: "running", new_publication_count: 3, end_dt: null })]),
+    );
+    await store.syncLatest();
+
+    expect(store.latestRun?.new_publication_count).toBe(5);
+  });
 });
diff --git a/frontend/src/stores/run_status.ts b/frontend/src/stores/run_status.ts
index 9c12540..e5b5cd7 100644
--- a/frontend/src/stores/run_status.ts
+++ b/frontend/src/stores/run_status.ts
@@ -1,11 +1,12 @@
 import { defineStore } from "pinia";
 
-import { listRuns, triggerManualRun, type RunListItem } from "@/features/runs";
+import { listRuns, triggerManualRun, cancelRun, type RunListItem } from "@/features/runs";
 import {
   createDefaultSafetyState,
   normalizeSafetyState,
   type ScrapeSafetyState,
 } from "@/features/safety";
+import { type PublicationItem } from "@/features/publications";
 import { ApiRequestError } from "@/lib/api/errors";
 
 export const RUN_STATUS_POLL_INTERVAL_MS = 5000;
@@ -13,24 +14,31 @@ export const RUN_STATUS_STARTING_PHASE_MS = 1500;
 
 export type StartManualCheckResult =
   | {
-      kind: "started";
-      runId: number;
-      reusedExistingRun: boolean;
-    }
+    kind: "started";
+    runId: number;
+    reusedExistingRun: boolean;
+  }
   | {
-      kind: "already_running";
-      runId: number | null;
-      requestId: string | null;
-    }
+    kind: "already_running";
+    runId: number | null;
+    requestId: string | null;
+  }
   | {
-      kind: "error";
-      message: string;
-      requestId: string | null;
-    };
+    kind: "error";
+    message: string;
+    requestId: string | null;
+  };
+
+export type CancelCheckResult =
+  | { kind: "success" }
+  | { kind: "error"; message: string };
 
 let pollTimer: ReturnType<typeof setInterval> | null = null;
 let syncPromise: Promise<void> | null = null;
 let submittingPhaseTimer: ReturnType<typeof setTimeout> | null = null;
+let eventSource: EventSource | null = null;
+let activeStreamRunId: number | null = null;
+const ACTIVE_STATUSES = new Set(["running", "resolving"]);
 
 function parseRunId(value: unknown): number | null {
   if (typeof value === "number" && Number.isFinite(value)) {
@@ -67,6 +75,32 @@ function extractSafetyStateFromDetails(details: unknown): ScrapeSafetyState | nu
   return normalizeSafetyState(candidate);
 }
 
+function isActiveStatus(value: string | null | undefined): boolean {
+  return value !== undefined && value !== null && ACTIVE_STATUSES.has(value);
+}
+
+function parsePublicationCount(value: unknown, fallback: number): number {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.max(Math.trunc(value), 0);
+  }
+  return fallback;
+}
+
+function reconcileRunCounters(previous: RunListItem | null, next: RunListItem | null): RunListItem | null {
+  if (previous === null || next === null) {
+    return next;
+  }
+  if (previous.id !== next.id) {
+    return next;
+  }
+  const previousCount = parsePublicationCount(previous.new_publication_count, 0);
+  const nextCount = parsePublicationCount(next.new_publication_count, previousCount);
+  return {
+    ...next,
+    new_publication_count: Math.max(previousCount, nextCount),
+  };
+}
+
 function buildPlaceholderRunningRun(runId: number): RunListItem {
   return {
     id: runId,
@@ -91,13 +125,16 @@ export const useRunStatusStore = defineStore("runStatus", {
     lastErrorMessage: null as string | null,
     lastErrorRequestId: null as string | null,
     lastSyncAt: null as number | null,
+    livePublications: [] as Array<PublicationItem>,
   }),
   getters: {
     isRunActive(state): boolean {
-      return state.isSubmitting || state.latestRun?.status === "running";
+      const s = state.latestRun?.status;
+      return state.isSubmitting || s === "running" || s === "resolving";
     },
     isLikelyRunning(state): boolean {
-      return state.latestRun?.status === "running" || state.assumeRunningFromSubmission;
+      const s = state.latestRun?.status;
+      return s === "running" || s === "resolving" || state.assumeRunningFromSubmission;
     },
     canStart(): boolean {
       return !this.isRunActive && !this.safetyState.cooldown_active;
@@ -125,7 +162,7 @@ export const useRunStatusStore = defineStore("runStatus", {
       this.lastSyncAt = Date.now();
       this.lastErrorMessage = null;
       this.lastErrorRequestId = null;
-      if (run?.status === "running") {
+      if (isActiveStatus(run?.status)) {
         this.assumeRunningFromSubmission = true;
       } else if (!this.isSubmitting) {
         this.assumeRunningFromSubmission = false;
@@ -156,9 +193,69 @@ export const useRunStatusStore = defineStore("runStatus", {
     updatePolling(): void {
       if (this.isRunActive) {
         this.startPolling();
+        this.updateEventSource();
         return;
       }
       this.stopPolling();
+      this.updateEventSource();
+    },
+    updateEventSource(): void {
+      const targetRunId = this.latestRun?.status === "running" ? this.latestRun.id : null;
+      if (activeStreamRunId === targetRunId) {
+        return;
+      }
+      if (eventSource !== null) {
+        eventSource.close();
+        eventSource = null;
+        activeStreamRunId = null;
+      }
+      if (targetRunId !== null) {
+        if (typeof EventSource === "undefined") {
+          return;
+        }
+        activeStreamRunId = targetRunId;
+        this.livePublications = [];
+        eventSource = new EventSource(`/api/v1/runs/${targetRunId}/stream`);
+        eventSource.addEventListener("publication_discovered", (e) => {
+          try {
+            const data = JSON.parse(e.data);
+            if (this.latestRun && this.latestRun.id === targetRunId) {
+              const baseline = parsePublicationCount(this.latestRun.new_publication_count, 0);
+              const payloadCount = parsePublicationCount(data?.new_publication_count, baseline + 1);
+              this.latestRun.new_publication_count = Math.max(baseline, payloadCount);
+            }
+            this.livePublications.unshift({
+              publication_id: data.publication_id,
+              scholar_profile_id: data.scholar_profile_id,
+              scholar_label: data.scholar_label,
+              title: data.title,
+              pub_url: data.pub_url,
+              first_seen_at: data.first_seen_at,
+              year: null,
+              citation_count: 0,
+              venue_text: null,
+              display_identifier: null,
+              pdf_url: null,
+              pdf_status: "untracked",
+              pdf_attempt_count: 0,
+              pdf_failure_reason: null,
+              pdf_failure_detail: null,
+              is_read: false,
+              is_favorite: false,
+              is_new_in_latest_run: true,
+            });
+            if (this.livePublications.length > 50) {
+              this.livePublications.pop();
+            }
+          } catch (err) {
+            console.error("Failed to parse SSE event", err);
+          }
+        });
+        eventSource.onerror = () => {
+          // Reconnecting is handled automatically by EventSource,
+          // but if it's permanently closed, we could do something here.
+        };
+      }
     },
     async syncLatest(): Promise<void> {
       if (syncPromise) {
@@ -169,13 +266,13 @@ export const useRunStatusStore = defineStore("runStatus", {
       syncPromise = (async () => {
         try {
           const payload = await listRuns({ limit: 1 });
-          const latest = payload.runs[0] ?? null;
+          const latest = reconcileRunCounters(this.latestRun, payload.runs[0] ?? null);
           this.latestRun = latest;
           this.safetyState = normalizeSafetyState(payload.safety_state);
           this.lastSyncAt = Date.now();
           this.lastErrorMessage = null;
           this.lastErrorRequestId = null;
-          if (latest?.status === "running") {
+          if (isActiveStatus(latest?.status)) {
             this.assumeRunningFromSubmission = true;
           } else if (!this.isSubmitting) {
             this.assumeRunningFromSubmission = false;
@@ -294,14 +391,36 @@ export const useRunStatusStore = defineStore("runStatus", {
       } finally {
         this.isSubmitting = false;
         this.clearSubmittingPhaseTimer();
-        if (this.latestRun?.status !== "running") {
+        if (!isActiveStatus(this.latestRun?.status)) {
           this.assumeRunningFromSubmission = false;
         }
         this.updatePolling();
       }
     },
+    async cancelActiveCheck(): Promise<{ kind: "success" } | { kind: "error"; message: string }> {
+      if (!this.latestRun || !isActiveStatus(this.latestRun.status)) {
+        return { kind: "error", message: "No active run to cancel." };
+      }
+      try {
+        const response = await cancelRun(this.latestRun.id);
+        this.setLatestRun(reconcileRunCounters(this.latestRun, response.run));
+        this.setSafetyState(response.safety_state);
+        return { kind: "success" };
+      } catch (error) {
+        let errMessage = "Failed to cancel check.";
+        if (error instanceof ApiRequestError) {
+          errMessage = error.message;
+        }
+        return { kind: "error", message: errMessage };
+      }
+    },
     reset(): void {
       this.stopPolling();
+      if (eventSource !== null) {
+        eventSource.close();
+        eventSource = null;
+        activeStreamRunId = null;
+      }
       this.clearSubmittingPhaseTimer();
       this.latestRun = null;
       this.isSubmitting = false;
diff --git a/frontend/src/stores/user_settings.test.ts b/frontend/src/stores/user_settings.test.ts
index 72cbb81..46b25f5 100644
--- a/frontend/src/stores/user_settings.test.ts
+++ b/frontend/src/stores/user_settings.test.ts
@@ -43,6 +43,9 @@ describe("user settings store", () => {
           last_evaluated_run_id: null,
         },
       },
+      openalex_api_key: null,
+      crossref_api_token: null,
+      crossref_api_mailto: null,
     });
 
     expect(store.networkFailureThreshold).toBe(2);
diff --git a/pyproject.toml b/pyproject.toml
index e469967..27426bc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -17,7 +17,9 @@ dependencies = [
   "httpx>=0.28,<0.29",
   "itsdangerous>=2.2,<3.0",
   "python-multipart>=0.0.9,<0.1",
+  "rapidfuzz>=3.14.3",
   "sqlalchemy>=2.0,<2.1",
+  "tenacity>=9.1.4",
   "uvicorn[standard]>=0.34,<0.35",
 ]
 
diff --git a/test_enrich.py b/test_enrich.py
new file mode 100644
index 0000000..9a76001
--- /dev/null
+++ b/test_enrich.py
@@ -0,0 +1,42 @@
+import asyncio
+from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
+from app.settings import settings
+from app.db.models import ScholarProfile
+from app.services.domains.ingestion.application import ScholarIngestionService
+from app.services.domains.scholar.parser_types import PublicationCandidate
+from app.services.domains.openalex.client import OpenAlexClient
+
+async def main():
+    service = ScholarIngestionService()
+    scholar = ScholarProfile(
+        id=1,
+        scholar_id="SaiiI5MAAAAJ",
+        name="Test Scholar"
+    )
+    pubs = [
+        PublicationCandidate(
+            title="A fast quantum mechanical algorithm for database search",
+            year=1996,
+            citation_count=1000,
+            authors_text="LK Grover",
+            venue_text="Proceedings of the 28th Annual ACM Symposium on the Theory of Computing",
+            cluster_id=None,
+            title_url=None,
+            pdf_url=None
+        )
+    ]
+    
+    print("Enriching...")
+    try:
+        enriched = await service._enrich_publications_with_openalex(scholar, pubs)
+        for p in enriched:
+            print(f"Title: {p.title}")
+            print(f"Year: {p.year}")
+            print(f"Citations: {p.citation_count}")
+            print(f"PDF URL: {p.pdf_url}")
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/tests/integration/test_api_v1.py b/tests/integration/test_api_v1.py
index bb21f34..e6a5422 100644
--- a/tests/integration/test_api_v1.py
+++ b/tests/integration/test_api_v1.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
@@ -66,6 +67,31 @@ def _assert_safety_state_contract(payload: dict[str, object]) -> None:
     assert set(counters.keys()) == SAFETY_COUNTER_KEYS
 
 
+_ACTIVE_RUN_STATUSES = {"running", "resolving"}
+
+
+async def _wait_for_run_complete(
+    client: TestClient,
+    run_id: int,
+    *,
+    max_retries: int = 300,
+    poll_interval: float = 0.2,
+) -> dict:
+    """Poll GET /api/v1/runs/{run_id} until the run is in a terminal state.
+
+    Returns the final run detail data dict.
+    """
+    for _ in range(max_retries):
+        await asyncio.sleep(poll_interval)
+        r = client.get(f"/api/v1/runs/{run_id}")
+        assert r.status_code == 200
+        data = r.json()["data"]
+        if data["run"]["status"] not in _ACTIVE_RUN_STATUSES:
+            return data
+    r = client.get(f"/api/v1/runs/{run_id}")
+    return r.json()["data"]
+
+
 async def _seed_publication_link_for_user(
     db_session: AsyncSession,
     *,
@@ -1041,44 +1067,42 @@ async def test_api_manual_run_skips_unchanged_initial_page_for_scholar(
 
     app.dependency_overrides[get_scholar_source] = lambda: StubScholarSource()
     try:
-        client = TestClient(app)
-        login_user(client, email="api-skip-unchanged@example.com", password="api-password")
-        headers = _api_csrf_headers(client)
+        with TestClient(app) as client:
+            login_user(client, email="api-skip-unchanged@example.com", password="api-password")
+            headers = _api_csrf_headers(client)
 
-        create_response = client.post(
-            "/api/v1/scholars",
-            json={"scholar_id": "abcDEF123456"},
-            headers=headers,
-        )
-        assert create_response.status_code == 201
+            create_response = client.post(
+                "/api/v1/scholars",
+                json={"scholar_id": "abcDEF123456"},
+                headers=headers,
+            )
+            assert create_response.status_code == 201
 
-        first_run_response = client.post(
-            "/api/v1/runs/manual",
-            headers={**headers, "Idempotency-Key": "skip-unchanged-run-001"},
-        )
-        assert first_run_response.status_code == 200
-        first_run_id = int(first_run_response.json()["data"]["run_id"])
+            first_run_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "skip-unchanged-run-001"},
+            )
+            assert first_run_response.status_code == 200
+            first_run_id = int(first_run_response.json()["data"]["run_id"])
 
-        first_run_detail = client.get(f"/api/v1/runs/{first_run_id}")
-        assert first_run_detail.status_code == 200
-        first_results = first_run_detail.json()["data"]["scholar_results"]
-        assert len(first_results) == 1
-        assert first_results[0]["state_reason"] != "no_change_initial_page_signature"
+            first_detail_data = await _wait_for_run_complete(client, first_run_id)
+            first_results = first_detail_data["scholar_results"]
+            assert len(first_results) == 1
+            assert first_results[0]["state_reason"] != "no_change_initial_page_signature"
 
-        second_run_response = client.post(
-            "/api/v1/runs/manual",
-            headers={**headers, "Idempotency-Key": "skip-unchanged-run-002"},
-        )
-        assert second_run_response.status_code == 200
-        second_run_id = int(second_run_response.json()["data"]["run_id"])
+            second_run_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "skip-unchanged-run-002"},
+            )
+            assert second_run_response.status_code == 200
+            second_run_id = int(second_run_response.json()["data"]["run_id"])
 
-        second_run_detail = client.get(f"/api/v1/runs/{second_run_id}")
-        assert second_run_detail.status_code == 200
-        second_results = second_run_detail.json()["data"]["scholar_results"]
-        assert len(second_results) == 1
-        assert second_results[0]["state_reason"] == "no_change_initial_page_signature"
-        assert second_results[0]["publication_count"] == 0
-        assert second_results[0]["outcome"] == "success"
+            second_detail_data = await _wait_for_run_complete(client, second_run_id)
+            second_results = second_detail_data["scholar_results"]
+            assert len(second_results) == 1
+            assert second_results[0]["state_reason"] == "no_change_initial_page_signature"
+            assert second_results[0]["publication_count"] == 0
+            assert second_results[0]["outcome"] == "success"
     finally:
         app.dependency_overrides.pop(get_scholar_source, None)
 
@@ -1227,7 +1251,7 @@ async def test_api_runs_manual_and_queue_actions(db_session: AsyncSession) -> No
     assert run_response.status_code == 200
     run_payload = run_response.json()["data"]
     assert "run_id" in run_payload
-    assert run_payload["status"] in {"success", "partial_failure", "failed"}
+    assert run_payload["status"] in {"running", "resolving", "success", "partial_failure", "failed"}
     assert run_payload["reused_existing_run"] is False
     assert run_payload["idempotency_key"] == "manual-run-0001"
     _assert_safety_state_contract(run_payload["safety_state"])
@@ -1243,11 +1267,15 @@ async def test_api_runs_manual_and_queue_actions(db_session: AsyncSession) -> No
         "/api/v1/runs/manual",
         headers={**headers, "Idempotency-Key": "manual-run-0001"},
     )
-    assert replay_response.status_code == 200
-    replay_payload = replay_response.json()["data"]
-    assert replay_payload["run_id"] == run_payload["run_id"]
-    assert replay_payload["reused_existing_run"] is True
-    _assert_safety_state_contract(replay_payload["safety_state"])
+    assert replay_response.status_code in {200, 409}
+    if replay_response.status_code == 200:
+        replay_payload = replay_response.json()["data"]
+        assert replay_payload["run_id"] == run_payload["run_id"]
+        assert replay_payload["reused_existing_run"] is True
+        _assert_safety_state_contract(replay_payload["safety_state"])
+    else:
+        replay_error = replay_response.json()["error"]
+        assert replay_error["code"] == "run_in_progress"
 
     runs_response = client.get("/api/v1/runs")
     assert runs_response.status_code == 200
@@ -1429,43 +1457,45 @@ async def test_api_manual_run_enforces_scrape_safety_cooldown(db_session: AsyncS
     object.__setattr__(settings, "ingestion_safety_cooldown_blocked_seconds", 600)
 
     try:
-        client = TestClient(app)
-        login_user(client, email="api-runs-safety@example.com", password="api-password")
-        headers = _api_csrf_headers(client)
+        with TestClient(app) as client:
+            login_user(client, email="api-runs-safety@example.com", password="api-password")
+            headers = _api_csrf_headers(client)
 
-        first_run_response = client.post(
-            "/api/v1/runs/manual",
-            headers={**headers, "Idempotency-Key": "safety-cooldown-run-1"},
-        )
-        assert first_run_response.status_code == 200
+            first_run_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "safety-cooldown-run-1"},
+            )
+            assert first_run_response.status_code == 200
+            first_run_id = int(first_run_response.json()["data"]["run_id"])
+            await _wait_for_run_complete(client, first_run_id)
 
-        settings_response = client.get("/api/v1/settings")
-        assert settings_response.status_code == 200
-        safety_state = settings_response.json()["data"]["safety_state"]
-        _assert_safety_state_contract(safety_state)
-        assert safety_state["cooldown_active"] is True
-        assert safety_state["cooldown_reason"] == "blocked_failure_threshold_exceeded"
-        assert int(safety_state["cooldown_remaining_seconds"]) > 0
-        assert int(safety_state["counters"]["cooldown_entry_count"]) >= 1
-        assert int(safety_state["counters"]["last_blocked_failure_count"]) >= 1
+            settings_response = client.get("/api/v1/settings")
+            assert settings_response.status_code == 200
+            safety_state = settings_response.json()["data"]["safety_state"]
+            _assert_safety_state_contract(safety_state)
+            assert safety_state["cooldown_active"] is True
+            assert safety_state["cooldown_reason"] == "blocked_failure_threshold_exceeded"
+            assert int(safety_state["cooldown_remaining_seconds"]) > 0
+            assert int(safety_state["counters"]["cooldown_entry_count"]) >= 1
+            assert int(safety_state["counters"]["last_blocked_failure_count"]) >= 1
 
-        blocked_start_response = client.post(
-            "/api/v1/runs/manual",
-            headers={**headers, "Idempotency-Key": "safety-cooldown-run-2"},
-        )
-        assert blocked_start_response.status_code == 429
-        blocked_payload = blocked_start_response.json()
-        assert blocked_payload["error"]["code"] == "scrape_cooldown_active"
-        blocked_state = blocked_payload["error"]["details"]["safety_state"]
-        _assert_safety_state_contract(blocked_state)
-        assert blocked_state["cooldown_active"] is True
-        assert blocked_state["cooldown_reason"] == "blocked_failure_threshold_exceeded"
-        assert int(blocked_state["counters"]["blocked_start_count"]) >= 1
+            blocked_start_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "safety-cooldown-run-2"},
+            )
+            assert blocked_start_response.status_code == 429
+            blocked_payload = blocked_start_response.json()
+            assert blocked_payload["error"]["code"] == "scrape_cooldown_active"
+            blocked_state = blocked_payload["error"]["details"]["safety_state"]
+            _assert_safety_state_contract(blocked_state)
+            assert blocked_state["cooldown_active"] is True
+            assert blocked_state["cooldown_reason"] == "blocked_failure_threshold_exceeded"
+            assert int(blocked_state["counters"]["blocked_start_count"]) >= 1
 
-        runs_response = client.get("/api/v1/runs")
-        assert runs_response.status_code == 200
-        _assert_safety_state_contract(runs_response.json()["data"]["safety_state"])
-        assert runs_response.json()["data"]["safety_state"]["cooldown_active"] is True
+            runs_response = client.get("/api/v1/runs")
+            assert runs_response.status_code == 200
+            _assert_safety_state_contract(runs_response.json()["data"]["safety_state"])
+            assert runs_response.json()["data"]["safety_state"]["cooldown_active"] is True
     finally:
         object.__setattr__(settings, "ingestion_alert_blocked_failure_threshold", previous_blocked_threshold)
         object.__setattr__(settings, "ingestion_safety_cooldown_blocked_seconds", previous_blocked_cooldown_seconds)
@@ -1535,37 +1565,39 @@ async def test_api_manual_run_enforces_network_failure_safety_cooldown(
     object.__setattr__(settings, "ingestion_retry_backoff_seconds", 0.0)
 
     try:
-        client = TestClient(app)
-        login_user(client, email="api-runs-safety-network@example.com", password="api-password")
-        headers = _api_csrf_headers(client)
+        with TestClient(app) as client:
+            login_user(client, email="api-runs-safety-network@example.com", password="api-password")
+            headers = _api_csrf_headers(client)
 
-        first_run_response = client.post(
-            "/api/v1/runs/manual",
-            headers={**headers, "Idempotency-Key": "safety-network-cooldown-run-1"},
-        )
-        assert first_run_response.status_code == 200
+            first_run_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "safety-network-cooldown-run-1"},
+            )
+            assert first_run_response.status_code == 200
+            first_run_id = int(first_run_response.json()["data"]["run_id"])
+            await _wait_for_run_complete(client, first_run_id)
 
-        settings_response = client.get("/api/v1/settings")
-        assert settings_response.status_code == 200
-        safety_state = settings_response.json()["data"]["safety_state"]
-        _assert_safety_state_contract(safety_state)
-        assert safety_state["cooldown_active"] is True
-        assert safety_state["cooldown_reason"] == "network_failure_threshold_exceeded"
-        assert int(safety_state["cooldown_remaining_seconds"]) > 0
-        assert int(safety_state["counters"]["last_network_failure_count"]) >= 1
+            settings_response = client.get("/api/v1/settings")
+            assert settings_response.status_code == 200
+            safety_state = settings_response.json()["data"]["safety_state"]
+            _assert_safety_state_contract(safety_state)
+            assert safety_state["cooldown_active"] is True
+            assert safety_state["cooldown_reason"] == "network_failure_threshold_exceeded"
+            assert int(safety_state["cooldown_remaining_seconds"]) > 0
+            assert int(safety_state["counters"]["last_network_failure_count"]) >= 1
 
-        blocked_start_response = client.post(
-            "/api/v1/runs/manual",
-            headers={**headers, "Idempotency-Key": "safety-network-cooldown-run-2"},
-        )
-        assert blocked_start_response.status_code == 429
-        blocked_payload = blocked_start_response.json()
-        assert blocked_payload["error"]["code"] == "scrape_cooldown_active"
-        blocked_state = blocked_payload["error"]["details"]["safety_state"]
-        _assert_safety_state_contract(blocked_state)
-        assert blocked_state["cooldown_active"] is True
-        assert blocked_state["cooldown_reason"] == "network_failure_threshold_exceeded"
-        assert int(blocked_state["counters"]["blocked_start_count"]) >= 1
+            blocked_start_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "safety-network-cooldown-run-2"},
+            )
+            assert blocked_start_response.status_code == 429
+            blocked_payload = blocked_start_response.json()
+            assert blocked_payload["error"]["code"] == "scrape_cooldown_active"
+            blocked_state = blocked_payload["error"]["details"]["safety_state"]
+            _assert_safety_state_contract(blocked_state)
+            assert blocked_state["cooldown_active"] is True
+            assert blocked_state["cooldown_reason"] == "network_failure_threshold_exceeded"
+            assert int(blocked_state["counters"]["blocked_start_count"]) >= 1
     finally:
         object.__setattr__(settings, "ingestion_alert_network_failure_threshold", previous_network_threshold)
         object.__setattr__(settings, "ingestion_safety_cooldown_network_seconds", previous_network_cooldown_seconds)
@@ -2152,7 +2184,6 @@ async def test_api_publication_retry_pdf_queues_resolution_job(
                 citation_count=item.citation_count,
                 venue_text=item.venue_text,
                 pub_url=item.pub_url,
-                doi=item.doi,
                 pdf_url=item.pdf_url,
                 is_read=item.is_read,
                 first_seen_at=item.first_seen_at,
@@ -2189,11 +2220,10 @@ async def test_api_publication_retry_pdf_queues_resolution_job(
     assert payload["publication"]["pdf_failure_reason"] == "no_pdf_found"
 
     stored = await db_session.execute(
-        text("SELECT doi, pdf_url FROM publications WHERE id = :publication_id"),
+        text("SELECT pdf_url FROM publications WHERE id = :publication_id"),
         {"publication_id": publication_id},
     )
-    stored_doi, stored_pdf_url = stored.one()
-    assert stored_doi is None
+    stored_pdf_url = stored.scalar_one()
     assert stored_pdf_url is None
 
 
diff --git a/tests/integration/test_deferred_enrichment.py b/tests/integration/test_deferred_enrichment.py
new file mode 100644
index 0000000..c51861e
--- /dev/null
+++ b/tests/integration/test_deferred_enrichment.py
@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import pytest
+from unittest.mock import patch, AsyncMock, MagicMock
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from datetime import datetime, timezone
+
+from app.db.models import CrawlRun, Publication, ScholarProfile, ScholarPublication, RunStatus, RunTriggerType
+from app.services.domains.ingestion.application import ScholarIngestionService
+from app.services.domains.openalex.types import OpenAlexWork
+from tests.integration.helpers import insert_user
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_deferred_enrichment_sweeps_previous_runs(db_session: AsyncSession) -> None:
+    # 1. Setup: Create user and scholar
+    user_id = await insert_user(db_session, email="test@example.com", password="password123")
+    
+    scholar = ScholarProfile(
+        user_id=user_id,
+        scholar_id="SaiiI5MAAAAJ",
+        display_name="Test Scholar",
+        is_enabled=True,
+    )
+    db_session.add(scholar)
+    await db_session.flush()
+    
+    # 2. Simulate a previous FAILED run that left an un-enriched publication
+    failed_run = CrawlRun(
+        user_id=user_id,
+        status=RunStatus.FAILED,
+        trigger_type=RunTriggerType.MANUAL,
+        start_dt=datetime.now(timezone.utc),
+    )
+    db_session.add(failed_run)
+    await db_session.flush()
+    
+    pub = Publication(
+        title_raw="A fast quantum mechanical algorithm for database search",
+        title_normalized="a fast quantum mechanical algorithm for database search",
+        fingerprint_sha256="dummy_fingerprint_for_test",
+        author_text="LK Grover",
+        openalex_enriched=False,
+    )
+    db_session.add(pub)
+    await db_session.flush()
+    
+    link = ScholarPublication(
+        scholar_profile_id=scholar.id,
+        publication_id=pub.id,
+        first_seen_run_id=failed_run.id,
+    )
+    db_session.add(link)
+    await db_session.commit()
+    
+    # 3. Create a NEW run
+    new_run = CrawlRun(
+        user_id=user_id,
+        status=RunStatus.RUNNING,
+        trigger_type=RunTriggerType.MANUAL,
+        start_dt=datetime.now(timezone.utc),
+    )
+    db_session.add(new_run)
+    await db_session.commit()
+    
+    # 4. Mock OpenAlex client to return enrichment data
+    mock_work = OpenAlexWork(
+        openalex_id="W1234567",
+        doi="10.1145/237814.237866",
+        pmid=None,
+        pmcid=None,
+        title="A fast quantum mechanical algorithm for database search",
+        publication_year=1996,
+        cited_by_count=1000,
+        is_oa=True,
+        oa_url="http://example.com/grover.pdf",
+    )
+    
+    mock_source = MagicMock()
+    service = ScholarIngestionService(source=mock_source)
+    
+    # We patch the client at its source, and also mock arXiv to avoid real HTTP calls
+    with patch("app.services.domains.openalex.client.OpenAlexClient") as MockClient, \
+         patch("app.services.domains.arxiv.application.discover_arxiv_id_for_publication", new=AsyncMock(return_value=None)):
+        mock_instance = MockClient.return_value
+        mock_instance.get_works_by_filter = AsyncMock(return_value=[mock_work])
+
+        # 5. Execute the enrichment pass for the NEW run
+        await service._enrich_pending_publications(db_session, run_id=new_run.id)
+        await db_session.commit()
+    
+    # 6. Verification: The publication from the FAILED run should now be enriched
+    await db_session.refresh(pub)
+    assert pub.openalex_enriched is True
+    assert pub.citation_count == 1000
+    assert pub.pdf_url == "http://example.com/grover.pdf"
+    
+    # Double check it was indeed processed
+    stmt = select(Publication).where(Publication.id == pub.id)
+    result = await db_session.execute(stmt)
+    enriched_pub = result.scalar_one()
+    assert enriched_pub.openalex_enriched is True
diff --git a/tests/integration/test_fixture_probe_runs.py b/tests/integration/test_fixture_probe_runs.py
index eb3762a..65361f2 100644
--- a/tests/integration/test_fixture_probe_runs.py
+++ b/tests/integration/test_fixture_probe_runs.py
@@ -144,7 +144,9 @@ async def test_fixture_probe_run_emits_failure_and_retry_summary_metrics(
         request_delay_seconds=0,
         network_error_retries=1,
         retry_backoff_seconds=0.0,
-        max_pages_per_scholar=1,
+        rate_limit_retries=0,
+        rate_limit_backoff_seconds=0.0,
+        max_pages_per_scholar=10,
         page_size=100,
         auto_queue_continuations=False,
         alert_blocked_failure_threshold=1,
diff --git a/tests/integration/test_migrations.py b/tests/integration/test_migrations.py
index 7b4295a..f8c3e0a 100644
--- a/tests/integration/test_migrations.py
+++ b/tests/integration/test_migrations.py
@@ -19,7 +19,7 @@ EXPECTED_TABLES = {
 }
 
 EXPECTED_ENUMS = {"run_status", "run_trigger_type"}
-EXPECTED_REVISION = "20260221_0015"
+EXPECTED_REVISION = "20260225_0022"
 
 
 @pytest.mark.integration
@@ -137,6 +137,28 @@ async def test_crawl_runs_has_manual_idempotency_unique_index(db_session: AsyncS
     assert "WHERE" in indexdef
 
 
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.migrations
+@pytest.mark.asyncio
+async def test_crawl_runs_has_single_active_run_unique_index(db_session: AsyncSession) -> None:
+    result = await db_session.execute(
+        text(
+            """
+            SELECT indexdef
+            FROM pg_indexes
+            WHERE schemaname = 'public'
+              AND tablename = 'crawl_runs'
+              AND indexname = 'uq_crawl_runs_user_active'
+            """
+        )
+    )
+    indexdef = result.scalar_one()
+    assert "UNIQUE INDEX" in indexdef
+    assert "(user_id)" in indexdef
+    assert "WHERE" in indexdef
+
+
 @pytest.mark.integration
 @pytest.mark.db
 @pytest.mark.migrations
diff --git a/tests/integration/test_run_lifecycle_consistency.py b/tests/integration/test_run_lifecycle_consistency.py
new file mode 100644
index 0000000..28020e6
--- /dev/null
+++ b/tests/integration/test_run_lifecycle_consistency.py
@@ -0,0 +1,514 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import text
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from app.api.runtime_deps import get_ingestion_service
+from app.db.models import CrawlRun, Publication, RunStatus, RunTriggerType
+from app.main import app
+from app.services.domains.ingestion.application import ScholarIngestionService
+from tests.integration.helpers import insert_user, login_user
+
+
+def _csrf_headers(client: TestClient) -> dict[str, str]:
+    response = client.get("/api/v1/auth/me")
+    assert response.status_code == 200
+    csrf_token = response.json()["data"]["csrf_token"]
+    assert isinstance(csrf_token, str) and csrf_token
+    return {"X-CSRF-Token": csrf_token}
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_crawl_runs_enforce_single_active_run_per_user(db_session: AsyncSession) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-single-active@example.com",
+        password="api-password",
+    )
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO crawl_runs (user_id, trigger_type, status, scholar_count, new_pub_count)
+            VALUES (:user_id, 'manual', 'running', 1, 0)
+            """
+        ),
+        {"user_id": user_id},
+    )
+    await db_session.commit()
+
+    with pytest.raises(IntegrityError):
+        await db_session.execute(
+            text(
+                """
+                INSERT INTO crawl_runs (user_id, trigger_type, status, scholar_count, new_pub_count)
+                VALUES (:user_id, 'scheduled', 'resolving', 1, 0)
+                """
+            ),
+            {"user_id": user_id},
+        )
+        await db_session.commit()
+    await db_session.rollback()
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_manual_run_conflicts_when_an_active_run_exists(
+    db_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-run-conflict@example.com",
+        password="api-password",
+    )
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            """
+        ),
+        {"user_id": user_id, "scholar_id": "runConflict001", "display_name": "Run Conflict"},
+    )
+    await db_session.commit()
+
+    service = ScholarIngestionService(source=object())
+
+    async def _stall_execute_run(**_kwargs: Any) -> None:
+        await asyncio.sleep(0.4)
+
+    monkeypatch.setattr(service, "execute_run", _stall_execute_run)
+    app.dependency_overrides[get_ingestion_service] = lambda: service
+    try:
+        client = TestClient(app)
+        login_user(client, email="api-run-conflict@example.com", password="api-password")
+        headers = _csrf_headers(client)
+
+        first_response = client.post("/api/v1/runs/manual", headers=headers)
+        assert first_response.status_code == 200
+        assert first_response.json()["data"]["status"] == "running"
+
+        second_response = client.post("/api/v1/runs/manual", headers=headers)
+        assert second_response.status_code == 409
+        payload = second_response.json()
+        assert payload["error"]["code"] == "run_in_progress"
+        await asyncio.sleep(0.45)
+    finally:
+        app.dependency_overrides.pop(get_ingestion_service, None)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_cancel_allows_resolving_and_rejects_terminal_run(db_session: AsyncSession) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-cancel-resolving@example.com",
+        password="api-password",
+    )
+    run_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO crawl_runs (user_id, trigger_type, status, scholar_count, new_pub_count)
+            VALUES (:user_id, 'manual', 'resolving', 1, 2)
+            RETURNING id
+            """
+        ),
+        {"user_id": user_id},
+    )
+    run_id = int(run_result.scalar_one())
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-cancel-resolving@example.com", password="api-password")
+    headers = _csrf_headers(client)
+
+    cancel_response = client.post(f"/api/v1/runs/{run_id}/cancel", headers=headers)
+    assert cancel_response.status_code == 200
+    assert cancel_response.json()["data"]["run"]["status"] == "canceled"
+
+    cancel_again_response = client.post(f"/api/v1/runs/{run_id}/cancel", headers=headers)
+    assert cancel_again_response.status_code == 409
+    assert cancel_again_response.json()["error"]["code"] == "run_not_cancelable"
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_background_enrichment_preserves_canceled_status(
+    db_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-cancel-enrichment@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, 'cancelResolve001', 'Cancel Resolve', true)
+            RETURNING id
+            """
+        ),
+        {"user_id": user_id},
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    run = CrawlRun(
+        user_id=user_id,
+        trigger_type=RunTriggerType.MANUAL,
+        status=RunStatus.RESOLVING,
+        scholar_count=1,
+    )
+    publication = Publication(
+        fingerprint_sha256=f"{(user_id + 9000):064x}",
+        title_raw="Cancel During Resolving",
+        title_normalized="cancel during resolving",
+        citation_count=0,
+        openalex_enriched=False,
+    )
+    db_session.add_all([run, publication])
+    await db_session.flush()
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (
+                scholar_profile_id,
+                publication_id,
+                first_seen_run_id,
+                is_read
+            )
+            VALUES (:scholar_profile_id, :publication_id, :run_id, false)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "publication_id": int(publication.id),
+            "run_id": int(run.id),
+        },
+    )
+    await db_session.commit()
+
+    session_factory = async_sessionmaker(db_session.bind, expire_on_commit=False)
+
+    class _OpenAlexClientStub:
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            _ = (args, kwargs)
+
+        async def get_works_by_filter(self, *_args: Any, **_kwargs: Any) -> list[Any]:
+            async with session_factory() as cancel_session:
+                run_to_cancel = await cancel_session.get(CrawlRun, int(run.id))
+                assert run_to_cancel is not None
+                run_to_cancel.status = RunStatus.CANCELED
+                await cancel_session.commit()
+            return []
+
+    monkeypatch.setattr(
+        "app.services.domains.openalex.client.OpenAlexClient",
+        _OpenAlexClientStub,
+    )
+
+    service = ScholarIngestionService(source=object())
+    await service._background_enrich(
+        session_factory,
+        run_id=int(run.id),
+        intended_final_status=RunStatus.SUCCESS,
+    )
+
+    await db_session.refresh(run)
+    await db_session.refresh(publication)
+    assert run.status == RunStatus.CANCELED
+    assert publication.openalex_enriched is False
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_publications_list_endpoint_does_not_raise_name_error(
+    db_session: AsyncSession,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-publications-nameerror@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, 'pubNameError001', 'Pub NameError', true)
+            RETURNING id
+            """
+        ),
+        {"user_id": user_id},
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    publication_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 1)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 2222):064x}",
+            "title_raw": "NameError Regression",
+            "title_normalized": "nameerror regression",
+        },
+    )
+    publication_id = int(publication_result.scalar_one())
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
+            VALUES (:scholar_profile_id, :publication_id, false, false)
+            """
+        ),
+        {"scholar_profile_id": scholar_profile_id, "publication_id": publication_id},
+    )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-publications-nameerror@example.com", password="api-password")
+    response = client.get("/api/v1/publications?mode=all&limit=10&offset=0")
+    assert response.status_code == 200
+    assert len(response.json()["data"]["publications"]) == 1
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_partial_discovery_exception_keeps_new_pub_count_consistent(
+    db_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-pub-count-consistency@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, 'countConsistency001', 'Count Consistency', true)
+            RETURNING id
+            """
+        ),
+        {"user_id": user_id},
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+
+    run = CrawlRun(
+        user_id=user_id,
+        trigger_type=RunTriggerType.MANUAL,
+        status=RunStatus.RUNNING,
+        scholar_count=1,
+        new_pub_count=0,
+    )
+    publication = Publication(
+        fingerprint_sha256=f"{(user_id + 777):064x}",
+        title_raw="Persisted Discovery",
+        title_normalized="persisted discovery",
+        citation_count=0,
+    )
+    db_session.add_all([run, publication])
+    await db_session.commit()
+
+    service = ScholarIngestionService(source=object())
+    call_count = 0
+
+    async def _resolve_publication_stub(*_args: Any, **_kwargs: Any) -> Publication:
+        nonlocal call_count
+        call_count += 1
+        if call_count == 1:
+            return publication
+        raise RuntimeError("mid_page_failure")
+
+    monkeypatch.setattr(service, "_resolve_publication", _resolve_publication_stub)
+
+    from app.services.domains.scholar.parser_types import PublicationCandidate
+    from app.db.models import ScholarProfile
+
+    scholar = await db_session.get(ScholarProfile, scholar_profile_id)
+    assert scholar is not None
+
+    publications = [
+        PublicationCandidate(
+            title="Persisted Discovery",
+            title_url=None,
+            cluster_id=None,
+            year=None,
+            citation_count=0,
+            authors_text=None,
+            venue_text=None,
+            pdf_url=None,
+        ),
+        PublicationCandidate(
+            title="Will Fail",
+            title_url=None,
+            cluster_id=None,
+            year=None,
+            citation_count=0,
+            authors_text=None,
+            venue_text=None,
+            pdf_url=None,
+        ),
+    ]
+
+    with pytest.raises(RuntimeError, match="mid_page_failure"):
+        await service._upsert_profile_publications(
+            db_session,
+            run=run,
+            scholar=scholar,
+            publications=publications,
+        )
+
+    refreshed_run = await db_session.get(CrawlRun, int(run.id))
+    assert refreshed_run is not None
+    assert int(refreshed_run.new_pub_count) == 1
+    link_count_result = await db_session.execute(
+        text(
+            """
+            SELECT count(*)
+            FROM scholar_publications
+            WHERE scholar_profile_id = :scholar_profile_id
+              AND first_seen_run_id = :run_id
+            """
+        ),
+        {"scholar_profile_id": scholar_profile_id, "run_id": int(run.id)},
+    )
+    assert int(link_count_result.scalar_one()) == 1
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_publications_pagination_snapshot_stays_stable_across_inserts(
+    db_session: AsyncSession,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-publications-snapshot@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, 'pagingSnapshot001', 'Paging Snapshot', true)
+            RETURNING id
+            """
+        ),
+        {"user_id": user_id},
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+
+    publication_ids: list[int] = []
+    for index in range(4):
+        created = await db_session.execute(
+            text(
+                """
+                INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+                VALUES (:fingerprint, :title_raw, :title_normalized, 1)
+                RETURNING id
+                """
+            ),
+            {
+                "fingerprint": f"{(user_id + 1000 + index):064x}",
+                "title_raw": f"Stable Page {index}",
+                "title_normalized": f"stable page {index}",
+            },
+        )
+        publication_ids.append(int(created.scalar_one()))
+
+    for publication_id in publication_ids:
+        await db_session.execute(
+            text(
+                """
+                INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
+                VALUES (:scholar_profile_id, :publication_id, false, false)
+                """
+            ),
+            {"scholar_profile_id": scholar_profile_id, "publication_id": publication_id},
+        )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-publications-snapshot@example.com", password="api-password")
+
+    first_page_response = client.get("/api/v1/publications?mode=all&page=1&page_size=2")
+    assert first_page_response.status_code == 200
+    first_page = first_page_response.json()["data"]
+    first_page_ids = [int(item["publication_id"]) for item in first_page["publications"]]
+    snapshot = first_page["snapshot"]
+    assert isinstance(snapshot, str) and snapshot
+
+    inserted = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 1)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 5000):064x}",
+            "title_raw": "Inserted After Snapshot",
+            "title_normalized": "inserted after snapshot",
+        },
+    )
+    inserted_publication_id = int(inserted.scalar_one())
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
+            VALUES (:scholar_profile_id, :publication_id, false, false)
+            """
+        ),
+        {"scholar_profile_id": scholar_profile_id, "publication_id": inserted_publication_id},
+    )
+    await db_session.commit()
+
+    second_page_response = client.get(
+        "/api/v1/publications",
+        params={
+            "mode": "all",
+            "page": 2,
+            "page_size": 2,
+            "snapshot": snapshot,
+        },
+    )
+    assert second_page_response.status_code == 200
+    second_page = second_page_response.json()["data"]
+    second_page_ids = [int(item["publication_id"]) for item in second_page["publications"]]
+
+    first_page_again_response = client.get(
+        "/api/v1/publications",
+        params={
+            "mode": "all",
+            "page": 1,
+            "page_size": 2,
+            "snapshot": snapshot,
+        },
+    )
+    assert first_page_again_response.status_code == 200
+    first_page_again = first_page_again_response.json()["data"]
+    first_page_again_ids = [
+        int(item["publication_id"]) for item in first_page_again["publications"]
+    ]
+
+    assert first_page_again_ids == first_page_ids
+    assert not (set(first_page_ids) & set(second_page_ids))
+    assert inserted_publication_id not in set(first_page_ids + second_page_ids)
diff --git a/tests/unit/services/domains/openalex/test_client.py b/tests/unit/services/domains/openalex/test_client.py
new file mode 100644
index 0000000..4b31cb3
--- /dev/null
+++ b/tests/unit/services/domains/openalex/test_client.py
@@ -0,0 +1,64 @@
+import pytest
+from app.services.domains.openalex.types import OpenAlexWork
+
+def test_parse_openalex_work_from_api_dict() -> None:
+    raw_api_response = {
+        "id": "https://openalex.org/W2741809807",
+        "doi": "https://doi.org/10.1038/s41586-020-0315-z",
+        "title": "Machine learning and the physical sciences",
+        "publication_year": 2019,
+        "cited_by_count": 1420,
+        "ids": {
+            "openalex": "https://openalex.org/W2741809807",
+            "doi": "https://doi.org/10.1038/s41586-020-0315-z",
+            "mag": "2741809807",
+            "pmid": "https://pubmed.ncbi.nlm.nih.gov/32040050",
+            "pmcid": "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7325852"
+        },
+        "open_access": {
+            "is_oa": True,
+            "oa_url": "https://example.com/pdf"
+        },
+        "authorships": [
+            {
+                "author_position": "first",
+                "author": {
+                    "id": "https://openalex.org/A1969205032",
+                    "display_name": "Giuseppe Carleo"
+                }
+            },
+            {
+                "author_position": "middle",
+                "author": {
+                    "id": "https://openalex.org/A4356881717",
+                    "display_name": "Ignacio Cirac"
+                }
+            }
+        ]
+    }
+
+    work = OpenAlexWork.from_api_dict(raw_api_response)
+
+    assert work.openalex_id == "https://openalex.org/W2741809807"
+    assert work.title == "Machine learning and the physical sciences"
+    assert work.doi == "10.1038/s41586-020-0315-z"
+    assert work.pmid == "32040050"
+    assert work.pmcid == "PMC7325852"
+    assert work.publication_year == 2019
+    assert work.cited_by_count == 1420
+    assert work.is_oa is True
+    assert work.oa_url == "https://example.com/pdf"
+    assert len(work.authors) == 2
+    assert work.authors[0].display_name == "Giuseppe Carleo"
+    assert work.authors[1].display_name == "Ignacio Cirac"
+
+def test_parse_openalex_work_empty() -> None:
+    work = OpenAlexWork.from_api_dict({"id": "W123"})
+    assert work.openalex_id == "W123"
+    assert work.doi is None
+    assert work.pmid is None
+    assert work.title is None
+    assert work.publication_year is None
+    assert work.cited_by_count == 0
+    assert work.is_oa is False
+    assert len(work.authors) == 0
diff --git a/tests/unit/services/domains/openalex/test_matching.py b/tests/unit/services/domains/openalex/test_matching.py
new file mode 100644
index 0000000..b8583a0
--- /dev/null
+++ b/tests/unit/services/domains/openalex/test_matching.py
@@ -0,0 +1,55 @@
+import pytest
+from app.services.domains.openalex.types import OpenAlexWork
+from app.services.domains.openalex.matching import find_best_match
+
+def test_find_best_match_exact_title():
+    cand1 = OpenAlexWork.from_api_dict({"id": "W1", "title": "Exact Title of the Paper"})
+    cand2 = OpenAlexWork.from_api_dict({"id": "W2", "title": "Totally Different Paper"})
+    
+    match = find_best_match("Exact Title of the Paper", 2020, "Author A", [cand1, cand2])
+    assert match is not None
+    assert match.openalex_id == "W1"
+
+def test_find_best_match_fuzzy_title():
+    # Only differences are punctuation or minor phrasing (e.g., matching a preprint title vs published)
+    cand1 = OpenAlexWork.from_api_dict({"id": "W1", "title": "Fuzzier Title: A Study on OpenAlex"})
+    cand2 = OpenAlexWork.from_api_dict({"id": "W2", "title": "Some completely unrelated work"})
+    
+    match = find_best_match("Fuzzier Title A Study on OpenAlex", 2021, "Author B", [cand1, cand2])
+    assert match is not None
+    assert match.openalex_id == "W1"
+
+def test_find_best_match_rejects_low_score():
+    cand1 = OpenAlexWork.from_api_dict({"id": "W1", "title": "Cats in hats"})
+    
+    match = find_best_match("Dogs with logs", 2020, "Author A", [cand1])
+    assert match is None
+
+def test_find_best_match_year_tiebreaker():
+    # Both titles are very similar, one has exact year.
+    cand1 = OpenAlexWork.from_api_dict({"id": "W1", "title": "The exact same title", "publication_year": 2018})
+    cand2 = OpenAlexWork.from_api_dict({"id": "W2", "title": "The exact same title", "publication_year": 2020})
+    
+    match = find_best_match("The exact same title", 2020, "Author A", [cand1, cand2])
+    assert match is not None
+    assert match.openalex_id == "W2"
+
+def test_find_best_match_author_tiebreaker():
+    # Titles and years match exactly. Author overlap decides it.
+    cand1 = OpenAlexWork.from_api_dict({
+        "id": "W1", 
+        "title": "A popular title", 
+        "publication_year": 2020,
+        "authorships": [{"author": {"display_name": "Smith, J"}}]
+    })
+    cand2 = OpenAlexWork.from_api_dict({
+        "id": "W2", 
+        "title": "A popular title", 
+        "publication_year": 2020,
+        "authorships": [{"author": {"display_name": "Doe, J"}}]
+    })
+    
+    # Target authors contains "Doe"
+    match = find_best_match("A popular title", 2020, "A Einstein, J Doe", [cand1, cand2])
+    assert match is not None
+    assert match.openalex_id == "W2"
diff --git a/tests/unit/services/domains/publications/test_dedup.py b/tests/unit/services/domains/publications/test_dedup.py
new file mode 100644
index 0000000..71542f0
--- /dev/null
+++ b/tests/unit/services/domains/publications/test_dedup.py
@@ -0,0 +1,163 @@
+"""Unit tests for the identifier-based publication dedup sweep.
+
+DB operations are mocked via AsyncMock so no database is required.
+"""
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from app.db.models import ScholarPublication
+from app.services.domains.publications.dedup import (
+    find_identifier_duplicate_pairs,
+    merge_duplicate_publication,
+    sweep_identifier_duplicates,
+)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_result(rows: list) -> MagicMock:
+    mock_result = MagicMock()
+    mock_result.scalars.return_value.all.return_value = rows
+    mock_result.__iter__ = lambda self: iter(rows)
+    return mock_result
+
+
+def _session_with_execute_sequence(results: list) -> AsyncMock:
+    session = AsyncMock()
+    session.execute = AsyncMock(side_effect=[_make_result(r) for r in results])
+    session.delete = AsyncMock()
+    session.flush = AsyncMock()
+    return session
+
+
+# ---------------------------------------------------------------------------
+# find_identifier_duplicate_pairs
+# ---------------------------------------------------------------------------
+
+@pytest.mark.asyncio
+async def test_find_identifier_duplicate_pairs_returns_pairs() -> None:
+    session = AsyncMock()
+    session.execute = AsyncMock(return_value=_make_result([(1, 2)]))
+
+    pairs = await find_identifier_duplicate_pairs(session)
+
+    assert pairs == [(1, 2)]
+    session.execute.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_find_identifier_duplicate_pairs_returns_empty_when_no_duplicates() -> None:
+    session = AsyncMock()
+    session.execute = AsyncMock(return_value=_make_result([]))
+
+    pairs = await find_identifier_duplicate_pairs(session)
+
+    assert pairs == []
+
+
+# ---------------------------------------------------------------------------
+# merge_duplicate_publication
+# ---------------------------------------------------------------------------
+
+@pytest.mark.asyncio
+async def test_merge_duplicate_migrates_orphaned_scholar_links() -> None:
+    """Scholar link that only the dup has should be migrated to winner."""
+    dup_link = MagicMock(spec=ScholarPublication)
+    dup_link.scholar_profile_id = 99
+    dup_link.publication_id = 2
+
+    session = _session_with_execute_sequence(
+        results=[
+            [dup_link],  # dup links
+            [],          # winner profile ids (no conflict)
+            [],          # execute(delete(Publication)) result
+        ]
+    )
+
+    await merge_duplicate_publication(session, winner_id=1, dup_id=2)
+
+    assert dup_link.publication_id == 1
+    session.delete.assert_not_awaited()  # not deleted; migrated instead
+
+
+@pytest.mark.asyncio
+async def test_merge_duplicate_drops_conflicting_scholar_link() -> None:
+    """When winner already has a link for the same scholar, dup's link is deleted."""
+    dup_link = MagicMock(spec=ScholarPublication)
+    dup_link.scholar_profile_id = 88
+    dup_link.publication_id = 2
+
+    session = _session_with_execute_sequence(
+        results=[
+            [dup_link],    # dup links
+            [(88,)],       # winner profiles (conflict: profile 88 already linked)
+            [],            # execute(delete(Publication)) result
+        ]
+    )
+
+    await merge_duplicate_publication(session, winner_id=1, dup_id=2)
+
+    session.delete.assert_awaited_once_with(dup_link)
+    assert dup_link.publication_id == 2  # unchanged — link was deleted, not migrated
+
+
+# ---------------------------------------------------------------------------
+# sweep_identifier_duplicates
+# ---------------------------------------------------------------------------
+
+@pytest.mark.asyncio
+async def test_sweep_returns_zero_when_no_pairs() -> None:
+    with patch(
+        "app.services.domains.publications.dedup.find_identifier_duplicate_pairs",
+        new=AsyncMock(return_value=[]),
+    ):
+        session = AsyncMock()
+        count = await sweep_identifier_duplicates(session)
+
+    assert count == 0
+    session.flush.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_sweep_returns_merge_count() -> None:
+    with (
+        patch(
+            "app.services.domains.publications.dedup.find_identifier_duplicate_pairs",
+            new=AsyncMock(return_value=[(1, 2), (3, 4)]),
+        ),
+        patch(
+            "app.services.domains.publications.dedup.merge_duplicate_publication",
+            new=AsyncMock(),
+        ) as mock_merge,
+    ):
+        session = AsyncMock()
+        count = await sweep_identifier_duplicates(session)
+
+    assert count == 2
+    assert mock_merge.await_count == 2
+    session.flush.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_sweep_merges_each_dup_only_once() -> None:
+    """A dup sharing two identifiers with the winner appears twice in pairs but merged once."""
+    with (
+        patch(
+            "app.services.domains.publications.dedup.find_identifier_duplicate_pairs",
+            new=AsyncMock(return_value=[(1, 2), (1, 2)]),
+        ),
+        patch(
+            "app.services.domains.publications.dedup.merge_duplicate_publication",
+            new=AsyncMock(),
+        ) as mock_merge,
+    ):
+        session = AsyncMock()
+        count = await sweep_identifier_duplicates(session)
+
+    assert count == 1
+    assert mock_merge.await_count == 1
diff --git a/tests/unit/test_fingerprints.py b/tests/unit/test_fingerprints.py
new file mode 100644
index 0000000..2065713
--- /dev/null
+++ b/tests/unit/test_fingerprints.py
@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import pytest
+
+from app.services.domains.ingestion.fingerprints import (
+    _dedupe_publication_candidates,
+    canonical_title_for_dedup,
+    fuzzy_titles_match,
+    normalize_title,
+)
+from app.services.domains.scholar.parser import PublicationCandidate
+
+
+def _candidate(
+    title: str,
+    *,
+    cluster_id: str | None = None,
+    year: int | None = 2024,
+    authors_text: str | None = "Smith, J",
+    venue_text: str | None = "ICML",
+) -> PublicationCandidate:
+    return PublicationCandidate(
+        title=title,
+        title_url=None,
+        cluster_id=cluster_id,
+        year=year,
+        citation_count=None,
+        authors_text=authors_text,
+        venue_text=venue_text,
+        pdf_url=None,
+    )
+
+
+class TestFuzzyTitlesMatch:
+    def test_identical_titles(self) -> None:
+        assert fuzzy_titles_match("Deep Learning for NLP", "deep learning for nlp") is True
+
+    def test_minor_word_difference(self) -> None:
+        assert fuzzy_titles_match(
+            "A Survey on Deep Learning Methods for NLP",
+            "Survey on Deep Learning Methods for NLP",
+        ) is True
+
+    def test_punctuation_difference(self) -> None:
+        assert fuzzy_titles_match(
+            "Attention Is All You Need",
+            "Attention Is All You Need.",
+        ) is True
+
+    def test_colon_vs_dash_subtitle(self) -> None:
+        assert fuzzy_titles_match(
+            "Deep Learning: A Comprehensive Survey",
+            "Deep Learning - A Comprehensive Survey",
+        ) is True
+
+    def test_completely_different_titles(self) -> None:
+        assert fuzzy_titles_match(
+            "Deep Learning for NLP",
+            "Climate Change Impact on Agriculture",
+        ) is False
+
+    def test_short_title_no_false_positive(self) -> None:
+        assert fuzzy_titles_match("On Trees", "On Forests") is False
+
+    def test_empty_title(self) -> None:
+        assert fuzzy_titles_match("", "Deep Learning") is False
+
+    def test_custom_threshold(self) -> None:
+        # Lower threshold catches more distant matches
+        assert fuzzy_titles_match(
+            "A Survey on Deep Learning",
+            "Survey on Machine Learning Approaches",
+            threshold=0.3,
+        ) is True
+        # Default threshold rejects them
+        assert fuzzy_titles_match(
+            "A Survey on Deep Learning",
+            "Survey on Machine Learning Approaches",
+        ) is False
+
+
+class TestDedupePublicationCandidates:
+    def test_exact_duplicates_by_cluster_id(self) -> None:
+        pubs = [
+            _candidate("Title A", cluster_id="c1"),
+            _candidate("Title A Copy", cluster_id="c1"),
+        ]
+        result = _dedupe_publication_candidates(pubs)
+        assert len(result) == 1
+        assert result[0].title == "Title A"
+
+    def test_fuzzy_duplicates_without_cluster_id(self) -> None:
+        pubs = [
+            _candidate("Attention Is All You Need"),
+            _candidate("Attention Is All You Need."),
+        ]
+        result = _dedupe_publication_candidates(pubs)
+        assert len(result) == 1
+
+    def test_distinct_titles_preserved(self) -> None:
+        pubs = [
+            _candidate("Deep Learning for NLP"),
+            _candidate("Reinforcement Learning for Robotics"),
+        ]
+        result = _dedupe_publication_candidates(pubs)
+        assert len(result) == 2
+
+    def test_fallback_aligned_with_db_fingerprint(self) -> None:
+        """Same title/year/first_author/first_venue should deduplicate even with
+        different full authors_text or venue_text."""
+        pubs = [
+            _candidate(
+                "My Paper",
+                authors_text="Smith, J; Jones, A",
+                venue_text="International Conference on ML",
+            ),
+            _candidate(
+                "My Paper",
+                authors_text="Smith, J; Baker, B",
+                venue_text="International Conference for ML",
+            ),
+        ]
+        result = _dedupe_publication_candidates(pubs)
+        # Both share first_author_last_name="smith" and first_venue_word="international"
+        assert len(result) == 1
+
+    def test_mixed_cluster_and_fuzzy(self) -> None:
+        pubs = [
+            _candidate("A Comprehensive Survey on Deep Learning Methods", cluster_id="c1"),
+            _candidate("Comprehensive Survey on Deep Learning Methods"),  # fuzzy match (subtitle stripped)
+            _candidate("Completely Different Study"),
+        ]
+        result = _dedupe_publication_candidates(pubs)
+        assert len(result) == 2
+        titles = [p.title for p in result]
+        assert "A Comprehensive Survey on Deep Learning Methods" in titles
+        assert "Completely Different Study" in titles
+
+    def test_scholar_noise_variants_collapse_to_one(self) -> None:
+        """The motivating case: three Scholar display variants of the Adam paper."""
+        pubs = [
+            _candidate(
+                "Adam: A method for stochastic optimization, preprint (2014)",
+                year=2014,
+                venue_text="",
+            ),
+            _candidate(
+                "Adam: A Method for Stochastic Optimization. arXiv, Jan 29, 2017. doi: 10.48550/arxiv.1412.6980",
+                year=2017,
+                venue_text="arXiv",
+            ),
+            _candidate(
+                "Adam a method for stochastic optimization. Comput. Sci",
+                year=2015,
+                venue_text="Comput. Sci",
+            ),
+        ]
+        result = _dedupe_publication_candidates(pubs)
+        assert len(result) == 1
+        assert result[0].title == pubs[0].title
+
+    def test_distinct_papers_not_merged(self) -> None:
+        """Papers with different core titles must not be collapsed."""
+        pubs = [
+            _candidate("Adam: A Method for Stochastic Optimization"),
+            _candidate("SGD: Stochastic Gradient Descent Revisited"),
+            _candidate("Attention Is All You Need"),
+        ]
+        result = _dedupe_publication_candidates(pubs)
+        assert len(result) == 3
+
+    def test_cross_page_dedup_via_seen_canonical(self) -> None:
+        """seen_canonical threads state across two separate calls (simulating two pages)."""
+        seen: set[str] = set()
+        page1 = [_candidate("Adam: A Method for Stochastic Optimization")]
+        page2 = [
+            _candidate(
+                "Adam: A method for stochastic optimization, preprint (2014)",
+                year=2014,
+            ),
+            _candidate("An Entirely Different Paper"),
+        ]
+
+        result1 = _dedupe_publication_candidates(page1, seen_canonical=seen)
+        result2 = _dedupe_publication_candidates(page2, seen_canonical=seen)
+
+        assert len(result1) == 1
+        # Noisy Adam variant from page 2 is suppressed; distinct paper survives
+        assert len(result2) == 1
+        assert result2[0].title == "An Entirely Different Paper"
+
+    def test_first_seen_wins_in_noise_collapse(self) -> None:
+        """First occurrence in page order is the kept candidate."""
+        pubs = [
+            _candidate("Adam: A Method for Stochastic Optimization", year=2015),
+            _candidate("Adam: A method for stochastic optimization, preprint (2014)", year=2014),
+        ]
+        result = _dedupe_publication_candidates(pubs)
+        assert len(result) == 1
+        assert result[0].year == 2015  # first wins
+
+
+class TestCanonicalTitleForDedup:
+    def test_strips_doi_suffix(self) -> None:
+        title = "Adam: A Method for Stochastic Optimization. doi: 10.48550/arxiv.1412.6980"
+        assert canonical_title_for_dedup(title) == normalize_title(
+            "Adam: A Method for Stochastic Optimization"
+        )
+
+    def test_strips_arxiv_metadata_suffix(self) -> None:
+        title = "Adam: A Method for Stochastic Optimization. arXiv, Jan 29, 2017"
+        assert canonical_title_for_dedup(title) == normalize_title(
+            "Adam: A Method for Stochastic Optimization"
+        )
+
+    def test_strips_preprint_parenthetical(self) -> None:
+        title = "Adam: A method for stochastic optimization, preprint (2014)"
+        assert canonical_title_for_dedup(title) == normalize_title(
+            "Adam: A method for stochastic optimization"
+        )
+
+    def test_strips_venue_sentence_suffix(self) -> None:
+        title = "Adam a method for stochastic optimization. Comput. Sci"
+        assert canonical_title_for_dedup(title) == normalize_title(
+            "Adam a method for stochastic optimization"
+        )
+
+    def test_strips_trailing_year_in_parens(self) -> None:
+        assert canonical_title_for_dedup("Deep Learning (2018)") == normalize_title("Deep Learning")
+
+    def test_preserves_clean_title(self) -> None:
+        title = "Attention Is All You Need"
+        assert canonical_title_for_dedup(title) == normalize_title(title)
+
+    def test_adam_variants_produce_identical_canonical(self) -> None:
+        variants = [
+            "Adam: A method for stochastic optimization, preprint (2014)",
+            "Adam: A Method for Stochastic Optimization. arXiv, Jan 29, 2017. doi: 10.48550/arxiv.1412.6980",
+            "Adam a method for stochastic optimization. Comput. Sci",
+        ]
+        canonicals = [canonical_title_for_dedup(v) for v in variants]
+        assert len(set(canonicals)) == 1, f"Expected one canonical, got: {canonicals}"
diff --git a/tests/unit/test_publication_identifiers.py b/tests/unit/test_publication_identifiers.py
index feab56b..88f5fcf 100644
--- a/tests/unit/test_publication_identifiers.py
+++ b/tests/unit/test_publication_identifiers.py
@@ -36,3 +36,72 @@ def test_derive_display_identifier_uses_pmcid_when_present() -> None:
     assert display is not None
     assert display.kind == "pmcid"
     assert display.value == "PMC2175868"
+
+
+def test_normalize_arxiv_id_handles_urls() -> None:
+    from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
+    
+    assert normalize_arxiv_id("https://arxiv.org/abs/1504.08025") == "1504.08025"
+    assert normalize_arxiv_id("http://arxiv.org/pdf/1504.08025v2.pdf") == "1504.08025v2"
+    assert normalize_arxiv_id("https://arxiv.org/html/1504.08025v2") == "1504.08025v2"
+    # Modern arxiv format
+    assert normalize_arxiv_id("https://arxiv.org/abs/2012.00001") == "2012.00001"
+    # Old arxiv format
+    assert normalize_arxiv_id("https://arxiv.org/abs/math/9901123") == "math/9901123"
+
+
+def test_normalize_arxiv_id_handles_raw_text() -> None:
+    from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
+    
+    assert normalize_arxiv_id("arXiv:1504.08025") == "1504.08025"
+    assert normalize_arxiv_id("arxiv: 1504.08025v1") == "1504.08025v1"
+    assert normalize_arxiv_id("Preprint at arXiv:math/9901123v2") == "math/9901123v2"
+    assert normalize_arxiv_id("Not an arxiv: 123") is None
+
+
+def test_normalize_pmcid_handles_urls_and_text() -> None:
+    from app.services.domains.publication_identifiers.normalize import normalize_pmcid
+    
+    assert normalize_pmcid("https://pmc.ncbi.nlm.nih.gov/articles/PMC2175868/") == "PMC2175868"
+    assert normalize_pmcid("http://www.ncbi.nlm.nih.gov/pmc/articles/PMC1234567") == "PMC1234567"
+    assert normalize_pmcid("PMCID: PMC1234567") == "PMC1234567"
+    assert normalize_pmcid("pmc1234567") == "PMC1234567"
+    assert normalize_pmcid("Not a PMCID 1234567") is None
+
+
+def test_normalize_pmid_handles_urls() -> None:
+    from app.services.domains.publication_identifiers.normalize import normalize_pmid
+    
+    assert normalize_pmid("https://pubmed.ncbi.nlm.nih.gov/12345678/") == "12345678"
+    assert normalize_pmid("http://pubmed.ncbi.nlm.nih.gov/12345678") == "12345678"
+    assert normalize_pmid("https://pubmed.ncbi.nlm.nih.gov/not-a-pmid/") is None
+
+
+import pytest
+from app.services.domains.arxiv import application as arxiv_service
+from app.services.domains.publications.types import UnreadPublicationItem
+
+@pytest.mark.asyncio
+async def test_discover_arxiv_id_returns_none_if_no_title() -> None:
+    item = UnreadPublicationItem(
+        publication_id=1,
+        scholar_profile_id=1,
+        scholar_label="First Last",
+        title="",
+        year=2023,
+        citation_count=0,
+        venue_text=None,
+        pub_url=None,
+        pdf_url=None,
+    )
+    result = await arxiv_service.discover_arxiv_id_for_publication(item=item)
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_build_arxiv_query() -> None:
+    query = arxiv_service._build_arxiv_query("Super AI Model", "Smith")
+    assert query == 'ti:"Super AI Model" AND au:"Smith"'
+
+    query2 = arxiv_service._build_arxiv_query("Only Title Here", None)
+    assert query2 == 'ti:"Only Title Here"'
diff --git a/tests/unit/test_publication_pdf_queue_policy.py b/tests/unit/test_publication_pdf_queue_policy.py
index 0cc3a7c..494d752 100644
--- a/tests/unit/test_publication_pdf_queue_policy.py
+++ b/tests/unit/test_publication_pdf_queue_policy.py
@@ -6,6 +6,7 @@ from types import SimpleNamespace
 import pytest
 
 from app.db.models import PublicationPdfJob
+from app.services.domains.arxiv.application import ArxivRateLimitError
 from app.services.domains.publications import pdf_queue
 from app.services.domains.publications.pdf_resolution_pipeline import PipelineOutcome
 from app.services.domains.unpaywall.application import OaResolutionOutcome
@@ -133,7 +134,7 @@ def test_pdf_queue_manual_requeue_still_blocks_when_inflight() -> None:
 
 @pytest.mark.asyncio
 async def test_fetch_outcome_for_row_uses_pipeline_outcome(monkeypatch: pytest.MonkeyPatch) -> None:
-    async def _fake_pipeline(*, row, request_email=None):
+    async def _fake_pipeline(*, row, request_email=None, openalex_api_key=None):
         assert request_email == "user@example.com"
         return PipelineOutcome(
             outcome=OaResolutionOutcome(
@@ -141,7 +142,7 @@ async def test_fetch_outcome_for_row_uses_pipeline_outcome(monkeypatch: pytest.M
                 doi=None,
                 pdf_url="https://arxiv.org/pdf/1703.06103",
                 failure_reason=None,
-                source=pdf_queue.PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE,
+                source="openalex",
                 used_crossref=False,
             ),
             scholar_candidates=None,
@@ -152,7 +153,7 @@ async def test_fetch_outcome_for_row_uses_pipeline_outcome(monkeypatch: pytest.M
     outcome = await pdf_queue._fetch_outcome_for_row(row=_row(), request_email="user@example.com")
 
     assert outcome.pdf_url == "https://arxiv.org/pdf/1703.06103"
-    assert outcome.source == pdf_queue.PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE
+    assert outcome.source == "openalex"
     assert outcome.used_crossref is False
 
 
@@ -160,7 +161,7 @@ async def test_fetch_outcome_for_row_uses_pipeline_outcome(monkeypatch: pytest.M
 async def test_fetch_outcome_for_row_returns_failed_outcome_when_pipeline_returns_none(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    async def _fake_pipeline(*, row, request_email=None):
+    async def _fake_pipeline(*, row, request_email=None, openalex_api_key=None):
         assert request_email == "user@example.com"
         return PipelineOutcome(outcome=None, scholar_candidates=None)
 
@@ -170,3 +171,66 @@ async def test_fetch_outcome_for_row_returns_failed_outcome_when_pipeline_return
 
     assert outcome.pdf_url is None
     assert outcome.failure_reason == pdf_queue.FAILURE_RESOLUTION_EXCEPTION
+
+
+@pytest.mark.asyncio
+async def test_resolve_publication_row_persists_failed_outcome_before_reraising_arxiv_rate_limit(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured: list[tuple[int, int, OaResolutionOutcome]] = []
+
+    async def _noop_mark_attempt_started(*, publication_id: int, user_id: int) -> None:
+        return None
+
+    async def _raise_rate_limit(*, row, request_email=None, openalex_api_key=None):
+        raise ArxivRateLimitError("arXiv rate limit hit (429) — stopping batch")
+
+    async def _capture_persist_outcome(*, publication_id: int, user_id: int, outcome: OaResolutionOutcome) -> None:
+        captured.append((publication_id, user_id, outcome))
+
+    monkeypatch.setattr(pdf_queue, "_mark_attempt_started", _noop_mark_attempt_started)
+    monkeypatch.setattr(pdf_queue, "_fetch_outcome_for_row", _raise_rate_limit)
+    monkeypatch.setattr(pdf_queue, "_persist_outcome", _capture_persist_outcome)
+
+    with pytest.raises(ArxivRateLimitError):
+        await pdf_queue._resolve_publication_row(
+            user_id=42,
+            request_email="user@example.com",
+            row=_row(),
+            openalex_api_key="key",
+        )
+
+    assert len(captured) == 1
+    publication_id, user_id, outcome = captured[0]
+    assert publication_id == 1
+    assert user_id == 42
+    assert outcome.pdf_url is None
+    assert outcome.failure_reason == pdf_queue.FAILURE_RESOLUTION_EXCEPTION
+
+
+@pytest.mark.asyncio
+async def test_run_resolution_task_stops_batch_on_arxiv_rate_limit(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[int] = []
+    first = _row()
+    second = SimpleNamespace(**{**first.__dict__, "publication_id": 2})
+
+    def _raise_session_factory_error():
+        raise RuntimeError("skip user settings lookup in test")
+
+    async def _fake_resolve_publication_row(*, user_id: int, request_email: str | None, row, openalex_api_key=None):
+        calls.append(int(row.publication_id))
+        if row.publication_id == 1:
+            raise ArxivRateLimitError("arXiv rate limit hit (429) — stopping batch")
+
+    monkeypatch.setattr(pdf_queue, "get_session_factory", _raise_session_factory_error)
+    monkeypatch.setattr(pdf_queue, "_resolve_publication_row", _fake_resolve_publication_row)
+
+    await pdf_queue._run_resolution_task(
+        user_id=42,
+        request_email="user@example.com",
+        rows=[first, second],
+    )
+
+    assert calls == [1]
diff --git a/tests/unit/test_publication_pdf_resolution_pipeline.py b/tests/unit/test_publication_pdf_resolution_pipeline.py
index bc7bb5c..74768c2 100644
--- a/tests/unit/test_publication_pdf_resolution_pipeline.py
+++ b/tests/unit/test_publication_pdf_resolution_pipeline.py
@@ -1,32 +1,16 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 from datetime import datetime, timezone
 from types import SimpleNamespace
 
 import pytest
 
 from app.services.domains.publications import pdf_resolution_pipeline as pipeline
+from app.services.domains.publication_identifiers.types import DisplayIdentifier
 from app.services.domains.unpaywall.application import OaResolutionOutcome
 
 
-@dataclass(frozen=True)
-class _Candidate:
-    url: str
-    confidence_score: float
-    label_present: bool
-    reason: str
-
-
-@dataclass(frozen=True)
-class _Candidates:
-    container_seen: bool
-    labeled_candidate: _Candidate | None
-    fallback_candidate: _Candidate | None
-    warnings: tuple[str, ...] = ()
-
-
-def _row(*, doi: str | None = None) -> SimpleNamespace:
+def _row(*, display_identifier: DisplayIdentifier | None = None) -> SimpleNamespace:
     return SimpleNamespace(
         publication_id=1,
         scholar_profile_id=1,
@@ -36,7 +20,7 @@ def _row(*, doi: str | None = None) -> SimpleNamespace:
         citation_count=0,
         venue_text=None,
         pub_url="https://scholar.google.com/citations?view_op=view_citation&citation_for_view=abc:xyz",
-        doi=doi,
+        display_identifier=display_identifier,
         pdf_url=None,
         is_read=False,
         is_favorite=False,
@@ -45,7 +29,20 @@ def _row(*, doi: str | None = None) -> SimpleNamespace:
     )
 
 
-def _oa_outcome(*, pdf_url: str | None, source: str = "unpaywall") -> OaResolutionOutcome:
+def _api_outcome(*, pdf_url: str | None, source: str = "unpaywall") -> OaResolutionOutcome | None:
+    if not pdf_url:
+        return None
+    return OaResolutionOutcome(
+        publication_id=1,
+        doi="10.1000/example",
+        pdf_url=pdf_url,
+        failure_reason=None if pdf_url else "no_pdf_found",
+        source=source,
+        used_crossref=False,
+    )
+
+
+def _oa_fallback_outcome(*, pdf_url: str | None, source: str = "unpaywall") -> OaResolutionOutcome:
     return OaResolutionOutcome(
         publication_id=1,
         doi="10.1000/example",
@@ -57,97 +54,63 @@ def _oa_outcome(*, pdf_url: str | None, source: str = "unpaywall") -> OaResoluti
 
 
 @pytest.mark.asyncio
-async def test_pipeline_prefers_labeled_scholar_candidate_before_oa(monkeypatch: pytest.MonkeyPatch) -> None:
-    async def _fake_candidates(_url):
-        return _Candidates(
-            container_seen=True,
-            labeled_candidate=_Candidate(
-                url="https://arxiv.org/pdf/1703.06103",
-                confidence_score=0.98,
-                label_present=True,
-                reason="scholar_link_labeled_pdf",
-            ),
-            fallback_candidate=None,
-        )
+async def test_pipeline_prefers_openalex_before_arxiv(monkeypatch: pytest.MonkeyPatch) -> None:
+    async def _fake_openalex(row, request_email: str | None = None, openalex_api_key: str | None = None):
+        return _api_outcome(pdf_url="https://oa.example.org/found.pdf", source="openalex")
 
-    async def _fail_oa(*, row, request_email):
-        raise AssertionError(f"OA should not run when labeled Scholar candidate exists: {row.publication_id} {request_email}")
+    async def _fail_arxiv(row):
+        raise AssertionError(f"arXiv should not run when OpenAlex candidate exists.")
 
-    monkeypatch.setattr(pipeline, "fetch_link_candidates_from_scholar_publication_page", _fake_candidates)
-    monkeypatch.setattr(pipeline, "_oa_outcome", _fail_oa)
-
-    result = await pipeline.resolve_publication_pdf_outcome_for_row(row=_row(), request_email="user@example.com")
-
-    assert result.outcome is not None
-    assert result.outcome.pdf_url == "https://arxiv.org/pdf/1703.06103"
-    assert result.outcome.source == pipeline.PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE
-
-
-@pytest.mark.asyncio
-async def test_pipeline_uses_oa_result_before_unlabeled_fallback(monkeypatch: pytest.MonkeyPatch) -> None:
-    async def _fake_candidates(_url):
-        return _Candidates(
-            container_seen=True,
-            labeled_candidate=None,
-            fallback_candidate=_Candidate(
-                url="https://example.org/download/42",
-                confidence_score=0.2,
-                label_present=False,
-                reason="scholar_link_unlabeled_fallback",
-            ),
-        )
-
-    async def _fake_oa(*, row, request_email):
-        assert request_email == "user@example.com"
-        return _oa_outcome(pdf_url="https://oa.example.org/found.pdf")
-
-    async def _fail_fallback(*, row, candidate):
-        raise AssertionError(f"Unlabeled fallback should not run when OA returns PDF: {row.publication_id} {candidate.url}")
-
-    monkeypatch.setattr(pipeline, "fetch_link_candidates_from_scholar_publication_page", _fake_candidates)
-    monkeypatch.setattr(pipeline, "_oa_outcome", _fake_oa)
-    monkeypatch.setattr(pipeline, "_unlabeled_fallback_outcome", _fail_fallback)
+    monkeypatch.setattr(pipeline, "_openalex_outcome", _fake_openalex)
+    monkeypatch.setattr(pipeline, "_arxiv_outcome", _fail_arxiv)
 
     result = await pipeline.resolve_publication_pdf_outcome_for_row(row=_row(), request_email="user@example.com")
 
     assert result.outcome is not None
     assert result.outcome.pdf_url == "https://oa.example.org/found.pdf"
-    assert result.outcome.source == "unpaywall"
+    assert result.outcome.source == "openalex"
 
 
 @pytest.mark.asyncio
-async def test_pipeline_uses_unlabeled_fallback_after_oa_failure(monkeypatch: pytest.MonkeyPatch) -> None:
-    fallback_candidate = _Candidate(
-        url="https://example.org/download/42",
-        confidence_score=0.2,
-        label_present=False,
-        reason="scholar_link_unlabeled_fallback",
-    )
+async def test_pipeline_uses_arxiv_after_openalex_failure(monkeypatch: pytest.MonkeyPatch) -> None:
+    async def _fake_openalex(row, request_email: str | None = None, openalex_api_key: str | None = None):
+        return None
 
-    async def _fake_candidates(_url):
-        return _Candidates(container_seen=True, labeled_candidate=None, fallback_candidate=fallback_candidate)
+    async def _fake_arxiv(row, request_email: str | None = None):
+        return _api_outcome(pdf_url="https://arxiv.org/pdf/1234.5678.pdf", source="arxiv")
+
+    async def _fail_oa(*, row, request_email):
+        raise AssertionError("Unpaywall should not run when arXiv returns PDF.")
+
+    monkeypatch.setattr(pipeline, "_openalex_outcome", _fake_openalex)
+    monkeypatch.setattr(pipeline, "_arxiv_outcome", _fake_arxiv)
+    monkeypatch.setattr(pipeline, "_oa_outcome", _fail_oa)
+
+    result = await pipeline.resolve_publication_pdf_outcome_for_row(row=_row(), request_email="user@example.com")
+
+    assert result.outcome is not None
+    assert result.outcome.pdf_url == "https://arxiv.org/pdf/1234.5678.pdf"
+    assert result.outcome.source == "arxiv"
+
+
+@pytest.mark.asyncio
+async def test_pipeline_uses_unpaywall_after_arxiv_failure(monkeypatch: pytest.MonkeyPatch) -> None:
+    async def _fake_openalex(row, request_email: str | None = None, openalex_api_key: str | None = None):
+        return None
+
+    async def _fake_arxiv(row, request_email: str | None = None):
+        return None
 
     async def _fake_oa(*, row, request_email):
         assert request_email == "user@example.com"
-        return _oa_outcome(pdf_url=None)
+        return _oa_fallback_outcome(pdf_url="https://example.org/fallback.pdf", source="unpaywall")
 
-    async def _fake_fallback(*, row, candidate):
-        assert candidate == fallback_candidate
-        return OaResolutionOutcome(
-            publication_id=row.publication_id,
-            doi=row.doi,
-            pdf_url="https://example.org/fallback.pdf",
-            failure_reason=None,
-            source=pipeline.PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE_UNLABELED,
-            used_crossref=False,
-        )
-
-    monkeypatch.setattr(pipeline, "fetch_link_candidates_from_scholar_publication_page", _fake_candidates)
+    monkeypatch.setattr(pipeline, "_openalex_outcome", _fake_openalex)
+    monkeypatch.setattr(pipeline, "_arxiv_outcome", _fake_arxiv)
     monkeypatch.setattr(pipeline, "_oa_outcome", _fake_oa)
-    monkeypatch.setattr(pipeline, "_unlabeled_fallback_outcome", _fake_fallback)
 
     result = await pipeline.resolve_publication_pdf_outcome_for_row(row=_row(), request_email="user@example.com")
 
     assert result.outcome is not None
     assert result.outcome.pdf_url == "https://example.org/fallback.pdf"
-    assert result.outcome.source == pipeline.PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE_UNLABELED
+    assert result.outcome.source == "unpaywall"
diff --git a/tests/unit/test_scholar_publication_pdf.py b/tests/unit/test_scholar_publication_pdf.py
deleted file mode 100644
index 7382b77..0000000
--- a/tests/unit/test_scholar_publication_pdf.py
+++ /dev/null
@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-from app.services.domains.scholar.parser_types import ScholarDomInvariantError
-from app.services.domains.scholar.publication_pdf import (
-    extract_link_candidates_from_publication_detail_html,
-    is_scholar_publication_detail_url,
-)
-
-
-def test_extract_link_candidates_from_publication_detail_html_reads_gsc_oci_pdf_link() -> None:
-    html = """
-    <html><body>
-      <div id="gsc_oci_title_gg">
-        <div class="gsc_oci_title_ggi">
-          <a href="https://arxiv.org/pdf/1703.06103" data-clk="x">
-            <span class="gsc_vcd_title_ggt">[PDF]</span> from arxiv.org
-          </a>
-        </div>
-      </div>
-    </body></html>
-    """
-    candidates = extract_link_candidates_from_publication_detail_html(html)
-    assert candidates.labeled_candidate is not None
-    assert candidates.labeled_candidate.url == "https://arxiv.org/pdf/1703.06103"
-
-
-def test_extract_link_candidates_from_publication_detail_html_returns_no_candidates_when_container_missing() -> None:
-    html = "<html><body><div id='gsc_oci_title'>No PDF section</div></body></html>"
-    candidates = extract_link_candidates_from_publication_detail_html(html)
-    assert candidates.container_seen is False
-    assert candidates.labeled_candidate is None
-    assert candidates.fallback_candidate is None
-
-
-def test_extract_pdf_url_from_publication_detail_html_fails_fast_on_malformed_pdf_container() -> None:
-    html = """
-    <html><body>
-      <div id="gsc_oci_title_gg">
-        <div class="gsc_oci_title_ggi">
-          <a data-clk="x"><span class="gsc_vcd_title_ggt">[PDF]</span> from example.org</a>
-        </div>
-      </div>
-    </body></html>
-    """
-    with pytest.raises(ScholarDomInvariantError) as exc:
-        extract_link_candidates_from_publication_detail_html(html)
-    assert exc.value.code == "layout_publication_link_missing_href"
-
-
-def test_extract_link_candidates_from_publication_detail_html_keeps_unlabeled_fallback() -> None:
-    html = """
-    <html><body>
-      <div id="gsc_oci_title_gg">
-        <div class="gsc_oci_title_ggi">
-          <a href="https://example.org/download?id=42">from example.org</a>
-        </div>
-      </div>
-    </body></html>
-    """
-    candidates = extract_link_candidates_from_publication_detail_html(html)
-    assert candidates.container_seen is True
-    assert candidates.labeled_candidate is None
-    assert candidates.fallback_candidate is not None
-    assert candidates.fallback_candidate.url == "https://example.org/download?id=42"
-    assert candidates.fallback_candidate.label_present is False
-    assert "scholar_publication_link_unlabeled_only" in candidates.warnings
-    assert candidates.labeled_candidate is None
-
-
-def test_is_scholar_publication_detail_url_matches_view_citation_links() -> None:
-    assert is_scholar_publication_detail_url(
-        "https://scholar.google.com/citations?view_op=view_citation&hl=en&user=8200InoAAAAJ&citation_for_view=8200InoAAAAJ:gsN89kCJA0AC"
-    ) is True
-    assert is_scholar_publication_detail_url("https://example.org/paper") is False
diff --git a/tests/unit/test_unpaywall_resolution.py b/tests/unit/test_unpaywall_resolution.py
index 651b33d..b29cc2c 100644
--- a/tests/unit/test_unpaywall_resolution.py
+++ b/tests/unit/test_unpaywall_resolution.py
@@ -6,6 +6,7 @@ from datetime import datetime, timezone
 import pytest
 
 from app.services.domains.publications.types import PublicationListItem
+from app.services.domains.publication_identifiers.types import DisplayIdentifier
 from app.services.domains.unpaywall import application as unpaywall_app
 
 
@@ -31,7 +32,7 @@ def _item(publication_id: int) -> PublicationListItem:
         citation_count=1000,
         venue_text="Cell",
         pub_url="https://doi.org/10.1016/j.cell.2007.11.019",
-        doi=None,
+        display_identifier=None,
         pdf_url=None,
         is_read=False,
         first_seen_at=datetime.now(timezone.utc),
@@ -44,7 +45,13 @@ def test_publication_doi_uses_stored_value_when_metadata_has_no_doi() -> None:
         _item(99),
         pub_url="https://scholar.google.com/citations?view_op=view_citation&citation_for_view=abc:123",
         venue_text="Cell 130 (5), 2007",
-        doi="10.1016/j.cell.2007.11.019",
+        display_identifier=DisplayIdentifier(
+            kind="doi",
+            value="10.1016/j.cell.2007.11.019",
+            label="DOI",
+            url=None,
+            confidence_score=1.0,
+        ),
     )
     assert unpaywall_app._publication_doi(item) == "10.1016/j.cell.2007.11.019"
 
@@ -54,7 +61,13 @@ def test_publication_doi_prefers_explicit_metadata_doi_over_stored_value() -> No
         _item(100),
         pub_url="https://doi.org/10.2000/fresh-value",
         venue_text="Cell",
-        doi="10.1000/stale-value",
+        display_identifier=DisplayIdentifier(
+            kind="doi",
+            value="10.1000/stale-value",
+            label="DOI",
+            url=None,
+            confidence_score=1.0,
+        ),
     )
     assert unpaywall_app._publication_doi(item) == "10.2000/fresh-value"
 
diff --git a/uv.lock b/uv.lock
index ac9d550..f4f139b 100644
--- a/uv.lock
+++ b/uv.lock
@@ -824,6 +824,69 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341 },
 ]
 
+[[package]]
+name = "rapidfuzz"
+version = "3.14.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/28/9d808fe62375b9aab5ba92fa9b29371297b067c2790b2d7cda648b1e2f8d/rapidfuzz-3.14.3.tar.gz", hash = "sha256:2491937177868bc4b1e469087601d53f925e8d270ccc21e07404b4b5814b7b5f", size = 57863900 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/8e/3c215e860b458cfbedb3ed73bc72e98eb7e0ed72f6b48099604a7a3260c2/rapidfuzz-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:685c93ea961d135893b5984a5a9851637d23767feabe414ec974f43babbd8226", size = 1945306 },
+    { url = "https://files.pythonhosted.org/packages/36/d9/31b33512015c899f4a6e6af64df8dfe8acddf4c8b40a4b3e0e6e1bcd00e5/rapidfuzz-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fa7c8f26f009f8c673fbfb443792f0cf8cf50c4e18121ff1e285b5e08a94fbdb", size = 1390788 },
+    { url = "https://files.pythonhosted.org/packages/a9/67/2ee6f8de6e2081ccd560a571d9c9063184fe467f484a17fa90311a7f4a2e/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:57f878330c8d361b2ce76cebb8e3e1dc827293b6abf404e67d53260d27b5d941", size = 1374580 },
+    { url = "https://files.pythonhosted.org/packages/30/83/80d22997acd928eda7deadc19ccd15883904622396d6571e935993e0453a/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c5f545f454871e6af05753a0172849c82feaf0f521c5ca62ba09e1b382d6382", size = 3154947 },
+    { url = "https://files.pythonhosted.org/packages/5b/cf/9f49831085a16384695f9fb096b99662f589e30b89b4a589a1ebc1a19d34/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:07aa0b5d8863e3151e05026a28e0d924accf0a7a3b605da978f0359bb804df43", size = 1223872 },
+    { url = "https://files.pythonhosted.org/packages/c8/0f/41ee8034e744b871c2e071ef0d360686f5ccfe5659f4fd96c3ec406b3c8b/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73b07566bc7e010e7b5bd490fb04bb312e820970180df6b5655e9e6224c137db", size = 2392512 },
+    { url = "https://files.pythonhosted.org/packages/da/86/280038b6b0c2ccec54fb957c732ad6b41cc1fd03b288d76545b9cf98343f/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6de00eb84c71476af7d3110cf25d8fe7c792d7f5fa86764ef0b4ca97e78ca3ed", size = 2521398 },
+    { url = "https://files.pythonhosted.org/packages/fa/7b/05c26f939607dca0006505e3216248ae2de631e39ef94dd63dbbf0860021/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d7843a1abf0091773a530636fdd2a49a41bcae22f9910b86b4f903e76ddc82dc", size = 4259416 },
+    { url = "https://files.pythonhosted.org/packages/40/eb/9e3af4103d91788f81111af1b54a28de347cdbed8eaa6c91d5e98a889aab/rapidfuzz-3.14.3-cp312-cp312-win32.whl", hash = "sha256:dea97ac3ca18cd3ba8f3d04b5c1fe4aa60e58e8d9b7793d3bd595fdb04128d7a", size = 1709527 },
+    { url = "https://files.pythonhosted.org/packages/b8/63/d06ecce90e2cf1747e29aeab9f823d21e5877a4c51b79720b2d3be7848f8/rapidfuzz-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:b5100fd6bcee4d27f28f4e0a1c6b5127bc8ba7c2a9959cad9eab0bf4a7ab3329", size = 1538989 },
+    { url = "https://files.pythonhosted.org/packages/fc/6d/beee32dcda64af8128aab3ace2ccb33d797ed58c434c6419eea015fec779/rapidfuzz-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:4e49c9e992bc5fc873bd0fff7ef16a4405130ec42f2ce3d2b735ba5d3d4eb70f", size = 811161 },
+    { url = "https://files.pythonhosted.org/packages/e4/4f/0d94d09646853bd26978cb3a7541b6233c5760687777fa97da8de0d9a6ac/rapidfuzz-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dbcb726064b12f356bf10fffdb6db4b6dce5390b23627c08652b3f6e49aa56ae", size = 1939646 },
+    { url = "https://files.pythonhosted.org/packages/b6/eb/f96aefc00f3bbdbab9c0657363ea8437a207d7545ac1c3789673e05d80bd/rapidfuzz-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1704fc70d214294e554a2421b473779bcdeef715881c5e927dc0f11e1692a0ff", size = 1385512 },
+    { url = "https://files.pythonhosted.org/packages/26/34/71c4f7749c12ee223dba90017a5947e8f03731a7cc9f489b662a8e9e643d/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc65e72790ddfd310c2c8912b45106e3800fefe160b0c2ef4d6b6fec4e826457", size = 1373571 },
+    { url = "https://files.pythonhosted.org/packages/32/00/ec8597a64f2be301ce1ee3290d067f49f6a7afb226b67d5f15b56d772ba5/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43e38c1305cffae8472572a0584d4ffc2f130865586a81038ca3965301f7c97c", size = 3156759 },
+    { url = "https://files.pythonhosted.org/packages/61/d5/b41eeb4930501cc899d5a9a7b5c9a33d85a670200d7e81658626dcc0ecc0/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:e195a77d06c03c98b3fc06b8a28576ba824392ce40de8c708f96ce04849a052e", size = 1222067 },
+    { url = "https://files.pythonhosted.org/packages/2a/7d/6d9abb4ffd1027c6ed837b425834f3bed8344472eb3a503ab55b3407c721/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1b7ef2f4b8583a744338a18f12c69693c194fb6777c0e9ada98cd4d9e8f09d10", size = 2394775 },
+    { url = "https://files.pythonhosted.org/packages/15/ce/4f3ab4c401c5a55364da1ffff8cc879fc97b4e5f4fa96033827da491a973/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:a2135b138bcdcb4c3742d417f215ac2d8c2b87bde15b0feede231ae95f09ec41", size = 2526123 },
+    { url = "https://files.pythonhosted.org/packages/c1/4b/54f804975376a328f57293bd817c12c9036171d15cf7292032e3f5820b2d/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:33a325ed0e8e1aa20c3e75f8ab057a7b248fdea7843c2a19ade0008906c14af0", size = 4262874 },
+    { url = "https://files.pythonhosted.org/packages/e9/b6/958db27d8a29a50ee6edd45d33debd3ce732e7209183a72f57544cd5fe22/rapidfuzz-3.14.3-cp313-cp313-win32.whl", hash = "sha256:8383b6d0d92f6cd008f3c9216535be215a064b2cc890398a678b56e6d280cb63", size = 1707972 },
+    { url = "https://files.pythonhosted.org/packages/07/75/fde1f334b0cec15b5946d9f84d73250fbfcc73c236b4bc1b25129d90876b/rapidfuzz-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:e6b5e3036976f0fde888687d91be86d81f9ac5f7b02e218913c38285b756be6c", size = 1537011 },
+    { url = "https://files.pythonhosted.org/packages/2e/d7/d83fe001ce599dc7ead57ba1debf923dc961b6bdce522b741e6b8c82f55c/rapidfuzz-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:7ba009977601d8b0828bfac9a110b195b3e4e79b350dcfa48c11269a9f1918a0", size = 810744 },
+    { url = "https://files.pythonhosted.org/packages/92/13/a486369e63ff3c1a58444d16b15c5feb943edd0e6c28a1d7d67cb8946b8f/rapidfuzz-3.14.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a0a28add871425c2fe94358c6300bbeb0bc2ed828ca003420ac6825408f5a424", size = 1967702 },
+    { url = "https://files.pythonhosted.org/packages/f1/82/efad25e260b7810f01d6b69122685e355bed78c94a12784bac4e0beb2afb/rapidfuzz-3.14.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:010e12e2411a4854b0434f920e72b717c43f8ec48d57e7affe5c42ecfa05dd0e", size = 1410702 },
+    { url = "https://files.pythonhosted.org/packages/ba/1a/34c977b860cde91082eae4a97ae503f43e0d84d4af301d857679b66f9869/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cfc3d57abd83c734d1714ec39c88a34dd69c85474918ebc21296f1e61eb5ca8", size = 1382337 },
+    { url = "https://files.pythonhosted.org/packages/88/74/f50ea0e24a5880a9159e8fd256b84d8f4634c2f6b4f98028bdd31891d907/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89acb8cbb52904f763e5ac238083b9fc193bed8d1f03c80568b20e4cef43a519", size = 3165563 },
+    { url = "https://files.pythonhosted.org/packages/e8/7a/e744359404d7737049c26099423fc54bcbf303de5d870d07d2fb1410f567/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_31_armv7l.whl", hash = "sha256:7d9af908c2f371bfb9c985bd134e295038e3031e666e4b2ade1e7cb7f5af2f1a", size = 1214727 },
+    { url = "https://files.pythonhosted.org/packages/d3/2e/87adfe14ce75768ec6c2b8acd0e05e85e84be4be5e3d283cdae360afc4fe/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1f1925619627f8798f8c3a391d81071336942e5fe8467bc3c567f982e7ce2897", size = 2403349 },
+    { url = "https://files.pythonhosted.org/packages/70/17/6c0b2b2bff9c8b12e12624c07aa22e922b0c72a490f180fa9183d1ef2c75/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:152555187360978119e98ce3e8263d70dd0c40c7541193fc302e9b7125cf8f58", size = 2507596 },
+    { url = "https://files.pythonhosted.org/packages/c3/d1/87852a7cbe4da7b962174c749a47433881a63a817d04f3e385ea9babcd9e/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:52619d25a09546b8db078981ca88939d72caa6b8701edd8b22e16482a38e799f", size = 4273595 },
+    { url = "https://files.pythonhosted.org/packages/c1/ab/1d0354b7d1771a28fa7fe089bc23acec2bdd3756efa2419f463e3ed80e16/rapidfuzz-3.14.3-cp313-cp313t-win32.whl", hash = "sha256:489ce98a895c98cad284f0a47960c3e264c724cb4cfd47a1430fa091c0c25204", size = 1757773 },
+    { url = "https://files.pythonhosted.org/packages/0b/0c/71ef356adc29e2bdf74cd284317b34a16b80258fa0e7e242dd92cc1e6d10/rapidfuzz-3.14.3-cp313-cp313t-win_amd64.whl", hash = "sha256:656e52b054d5b5c2524169240e50cfa080b04b1c613c5f90a2465e84888d6f15", size = 1576797 },
+    { url = "https://files.pythonhosted.org/packages/fe/d2/0e64fc27bb08d4304aa3d11154eb5480bcf5d62d60140a7ee984dc07468a/rapidfuzz-3.14.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c7e40c0a0af02ad6e57e89f62bef8604f55a04ecae90b0ceeda591bbf5923317", size = 829940 },
+    { url = "https://files.pythonhosted.org/packages/32/6f/1b88aaeade83abc5418788f9e6b01efefcd1a69d65ded37d89cd1662be41/rapidfuzz-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:442125473b247227d3f2de807a11da6c08ccf536572d1be943f8e262bae7e4ea", size = 1942086 },
+    { url = "https://files.pythonhosted.org/packages/a0/2c/b23861347436cb10f46c2bd425489ec462790faaa360a54a7ede5f78de88/rapidfuzz-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ec0c8c0c3d4f97ced46b2e191e883f8c82dbbf6d5ebc1842366d7eff13cd5a6", size = 1386993 },
+    { url = "https://files.pythonhosted.org/packages/83/86/5d72e2c060aa1fbdc1f7362d938f6b237dff91f5b9fc5dd7cc297e112250/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2dc37bc20272f388b8c3a4eba4febc6e77e50a8f450c472def4751e7678f55e4", size = 1379126 },
+    { url = "https://files.pythonhosted.org/packages/c9/bc/ef2cee3e4d8b3fc22705ff519f0d487eecc756abdc7c25d53686689d6cf2/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dee362e7e79bae940a5e2b3f6d09c6554db6a4e301cc68343886c08be99844f1", size = 3159304 },
+    { url = "https://files.pythonhosted.org/packages/a0/36/dc5f2f62bbc7bc90be1f75eeaf49ed9502094bb19290dfb4747317b17f12/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:4b39921df948388a863f0e267edf2c36302983459b021ab928d4b801cbe6a421", size = 1218207 },
+    { url = "https://files.pythonhosted.org/packages/df/7e/8f4be75c1bc62f47edf2bbbe2370ee482fae655ebcc4718ac3827ead3904/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:beda6aa9bc44d1d81242e7b291b446be352d3451f8217fcb068fc2933927d53b", size = 2401245 },
+    { url = "https://files.pythonhosted.org/packages/05/38/f7c92759e1bb188dd05b80d11c630ba59b8d7856657baf454ff56059c2ab/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:6a014ba09657abfcfeed64b7d09407acb29af436d7fc075b23a298a7e4a6b41c", size = 2518308 },
+    { url = "https://files.pythonhosted.org/packages/c7/ac/85820f70fed5ecb5f1d9a55f1e1e2090ef62985ef41db289b5ac5ec56e28/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:32eeafa3abce138bb725550c0e228fc7eaeec7059aa8093d9cbbec2b58c2371a", size = 4265011 },
+    { url = "https://files.pythonhosted.org/packages/46/a9/616930721ea9835c918af7cde22bff17f9db3639b0c1a7f96684be7f5630/rapidfuzz-3.14.3-cp314-cp314-win32.whl", hash = "sha256:adb44d996fc610c7da8c5048775b21db60dd63b1548f078e95858c05c86876a3", size = 1742245 },
+    { url = "https://files.pythonhosted.org/packages/06/8a/f2fa5e9635b1ccafda4accf0e38246003f69982d7c81f2faa150014525a4/rapidfuzz-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:f3d15d8527e2b293e38ce6e437631af0708df29eafd7c9fc48210854c94472f9", size = 1584856 },
+    { url = "https://files.pythonhosted.org/packages/ef/97/09e20663917678a6d60d8e0e29796db175b1165e2079830430342d5298be/rapidfuzz-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:576e4b9012a67e0bf54fccb69a7b6c94d4e86a9540a62f1a5144977359133583", size = 833490 },
+    { url = "https://files.pythonhosted.org/packages/03/1b/6b6084576ba87bf21877c77218a0c97ba98cb285b0c02eaaee3acd7c4513/rapidfuzz-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:cec3c0da88562727dd5a5a364bd9efeb535400ff0bfb1443156dd139a1dd7b50", size = 1968658 },
+    { url = "https://files.pythonhosted.org/packages/38/c0/fb02a0db80d95704b0a6469cc394e8c38501abf7e1c0b2afe3261d1510c2/rapidfuzz-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d1fa009f8b1100e4880868137e7bf0501422898f7674f2adcd85d5a67f041296", size = 1410742 },
+    { url = "https://files.pythonhosted.org/packages/a4/72/3fbf12819fc6afc8ec75a45204013b40979d068971e535a7f3512b05e765/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b86daa7419b5e8b180690efd1fdbac43ff19230803282521c5b5a9c83977655", size = 1382810 },
+    { url = "https://files.pythonhosted.org/packages/0f/18/0f1991d59bb7eee28922a00f79d83eafa8c7bfb4e8edebf4af2a160e7196/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7bd1816db05d6c5ffb3a4df0a2b7b56fb8c81ef584d08e37058afa217da91b1", size = 3166349 },
+    { url = "https://files.pythonhosted.org/packages/0d/f0/baa958b1989c8f88c78bbb329e969440cf330b5a01a982669986495bb980/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:33da4bbaf44e9755b0ce192597f3bde7372fe2e381ab305f41b707a95ac57aa7", size = 1214994 },
+    { url = "https://files.pythonhosted.org/packages/e4/a0/cd12ec71f9b2519a3954febc5740291cceabc64c87bc6433afcb36259f3b/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3fecce764cf5a991ee2195a844196da840aba72029b2612f95ac68a8b74946bf", size = 2403919 },
+    { url = "https://files.pythonhosted.org/packages/0b/ce/019bd2176c1644098eced4f0595cb4b3ef52e4941ac9a5854f209d0a6e16/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:ecd7453e02cf072258c3a6b8e930230d789d5d46cc849503729f9ce475d0e785", size = 2508346 },
+    { url = "https://files.pythonhosted.org/packages/23/f8/be16c68e2c9e6c4f23e8f4adbb7bccc9483200087ed28ff76c5312da9b14/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea188aa00e9bcae8c8411f006a5f2f06c4607a02f24eab0d8dc58566aa911f35", size = 4274105 },
+    { url = "https://files.pythonhosted.org/packages/a1/d1/5ab148e03f7e6ec8cd220ccf7af74d3aaa4de26dd96df58936beb7cba820/rapidfuzz-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:7ccbf68100c170e9a0581accbe9291850936711548c6688ce3bfb897b8c589ad", size = 1793465 },
+    { url = "https://files.pythonhosted.org/packages/cd/97/433b2d98e97abd9fff1c470a109b311669f44cdec8d0d5aa250aceaed1fb/rapidfuzz-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:9ec02e62ae765a318d6de38df609c57fc6dacc65c0ed1fd489036834fd8a620c", size = 1623491 },
+    { url = "https://files.pythonhosted.org/packages/e2/f6/e2176eb94f94892441bce3ddc514c179facb65db245e7ce3356965595b19/rapidfuzz-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:e805e52322ae29aa945baf7168b6c898120fbc16d2b8f940b658a5e9e3999253", size = 851487 },
+]
+
 [[package]]
 name = "requests"
 version = "2.32.5"
@@ -852,7 +915,9 @@ dependencies = [
     { name = "httpx" },
     { name = "itsdangerous" },
     { name = "python-multipart" },
+    { name = "rapidfuzz" },
     { name = "sqlalchemy" },
+    { name = "tenacity" },
     { name = "uvicorn", extra = ["standard"] },
 ]
 
@@ -874,7 +939,9 @@ requires-dist = [
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.3,<9.0" },
     { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.25,<0.26" },
     { name = "python-multipart", specifier = ">=0.0.9,<0.1" },
+    { name = "rapidfuzz", specifier = ">=3.14.3" },
     { name = "sqlalchemy", specifier = ">=2.0,<2.1" },
+    { name = "tenacity", specifier = ">=9.1.4" },
     { name = "uvicorn", extras = ["standard"], specifier = ">=0.34,<0.35" },
 ]
 provides-extras = ["dev"]
@@ -948,6 +1015,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/be/72/2db2f49247d0a18b4f1bb9a5a39a0162869acf235f3a96418363947b3d46/starlette-0.48.0-py3-none-any.whl", hash = "sha256:0764ca97b097582558ecb498132ed0c7d942f233f365b86ba37770e026510659", size = 73736 },
 ]
 
+[[package]]
+name = "tenacity"
+version = "9.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926 },
+]
+
 [[package]]
 name = "traitlets"
 version = "5.14.3"
-- 
2.49.1


From 3d4cfeff1a8bb5546174af5b6964a956274bb0c3 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Thu, 26 Feb 2026 16:09:57 +0100
Subject: [PATCH 04/38] Intermediate commit

---
 .env.example                                  |  14 +
 .../20260226_0023_add_arxiv_runtime_state.py  |  55 +++
 ...0226_0024_add_arxiv_query_cache_entries.py |  70 +++
 app/api/routers/admin_dbops.py                |  46 +-
 app/api/routers/publications.py               |   5 +-
 app/api/routers/scholars.py                   | 124 ++++-
 app/api/schemas.py                            |  64 +++
 app/db/models.py                              |  38 ++
 app/services/domains/arxiv/application.py     | 107 +----
 app/services/domains/arxiv/cache.py           | 332 +++++++++++++
 app/services/domains/arxiv/client.py          | 311 ++++++++++++
 app/services/domains/arxiv/constants.py       |  13 +
 app/services/domains/arxiv/errors.py          |  13 +
 app/services/domains/arxiv/gateway.py         | 141 ++++++
 app/services/domains/arxiv/guards.py          |  86 ++++
 app/services/domains/arxiv/parser.py          | 111 +++++
 app/services/domains/arxiv/rate_limit.py      | 247 ++++++++++
 app/services/domains/arxiv/types.py           |  34 ++
 app/services/domains/dbops/__init__.py        |  10 +-
 .../domains/dbops/near_duplicate_repair.py    | 223 +++++++++
 app/services/domains/ingestion/application.py | 165 ++++++-
 .../domains/ingestion/fingerprints.py         | 163 ++++++-
 .../publication_identifiers/__init__.py       |   2 +
 .../publication_identifiers/application.py    | 168 +++++--
 .../publication_identifiers/normalize.py      |   5 +
 app/services/domains/publications/counts.py   |  23 +-
 app/services/domains/publications/dedup.py    | 445 +++++++++++++++++-
 .../domains/publications/pdf_queue.py         |  43 +-
 .../publications/pdf_resolution_pipeline.py   |  54 ++-
 app/services/domains/publications/queries.py  |  45 +-
 app/services/domains/scholar/rate_limit.py    |  22 +-
 app/services/domains/scholar/source.py        |  22 +-
 app/settings.py                               |   8 +
 docs/developer/architecture.md                |   7 +
 docs/developer/ingestion.md                   |  12 +
 docs/operations/arxiv-runbook.md              |  46 ++
 docs/operations/overview.md                   |   1 +
 docs/reference/environment.md                 |   4 +-
 frontend/src/components/ui/AppBrandMark.vue   |   8 +-
 frontend/src/features/admin_dbops/index.ts    |  47 ++
 frontend/src/features/publications/index.ts   |   9 +-
 .../features/settings/SettingsAdminPanel.vue  | 227 +++++++++
 frontend/src/pages/DashboardPage.vue          |  41 +-
 frontend/src/pages/PublicationsPage.vue       | 101 +++-
 frontend/src/pages/ScholarsPage.vue           |  81 +++-
 frontend/src/stores/run_status.test.ts        |  67 +++
 frontend/src/stores/run_status.ts             |  64 ++-
 tests/conftest.py                             |   2 +
 tests/integration/test_api_v1.py              | 327 +++++++++++++
 tests/integration/test_migrations.py          |   4 +-
 .../unit/services/domains/arxiv/test_cache.py | 134 ++++++
 .../services/domains/arxiv/test_client.py     | 202 ++++++++
 .../services/domains/arxiv/test_gateway.py    | 126 +++++
 .../services/domains/arxiv/test_guards.py     |  63 +++
 .../services/domains/arxiv/test_parser.py     |  55 +++
 .../services/domains/arxiv/test_rate_limit.py | 167 +++++++
 .../domains/publications/test_dedup.py        | 187 ++++++--
 tests/unit/test_fingerprints.py               |  32 ++
 tests/unit/test_ingestion_arxiv_rate_limit.py |  47 ++
 .../unit/test_ingestion_progress_reporting.py |  61 +++
 tests/unit/test_publication_identifiers.py    | 148 +++++-
 .../unit/test_publication_pdf_queue_policy.py |  78 ++-
 ...est_publication_pdf_resolution_pipeline.py | 100 +++-
 tests/unit/test_scholar_source.py             |  39 +-
 tests/unit/test_scholars_create_hydration.py  | 144 ++++++
 65 files changed, 5507 insertions(+), 333 deletions(-)
 create mode 100644 alembic/versions/20260226_0023_add_arxiv_runtime_state.py
 create mode 100644 alembic/versions/20260226_0024_add_arxiv_query_cache_entries.py
 create mode 100644 app/services/domains/arxiv/cache.py
 create mode 100644 app/services/domains/arxiv/client.py
 create mode 100644 app/services/domains/arxiv/constants.py
 create mode 100644 app/services/domains/arxiv/errors.py
 create mode 100644 app/services/domains/arxiv/gateway.py
 create mode 100644 app/services/domains/arxiv/guards.py
 create mode 100644 app/services/domains/arxiv/parser.py
 create mode 100644 app/services/domains/arxiv/rate_limit.py
 create mode 100644 app/services/domains/arxiv/types.py
 create mode 100644 app/services/domains/dbops/near_duplicate_repair.py
 create mode 100644 docs/operations/arxiv-runbook.md
 create mode 100644 tests/unit/services/domains/arxiv/test_cache.py
 create mode 100644 tests/unit/services/domains/arxiv/test_client.py
 create mode 100644 tests/unit/services/domains/arxiv/test_gateway.py
 create mode 100644 tests/unit/services/domains/arxiv/test_guards.py
 create mode 100644 tests/unit/services/domains/arxiv/test_parser.py
 create mode 100644 tests/unit/services/domains/arxiv/test_rate_limit.py
 create mode 100644 tests/unit/test_ingestion_arxiv_rate_limit.py
 create mode 100644 tests/unit/test_ingestion_progress_reporting.py
 create mode 100644 tests/unit/test_scholars_create_hydration.py

diff --git a/.env.example b/.env.example
index 326e7d3..e2180ba 100644
--- a/.env.example
+++ b/.env.example
@@ -79,12 +79,15 @@ LOG_REDACT_FIELDS=
 SCHEDULER_ENABLED=1
 SCHEDULER_TICK_SECONDS=60
 SCHEDULER_QUEUE_BATCH_SIZE=10
+SCHEDULER_PDF_QUEUE_BATCH_SIZE=15
 INGESTION_AUTOMATION_ALLOWED=1
 INGESTION_MANUAL_RUN_ALLOWED=1
 INGESTION_MIN_RUN_INTERVAL_MINUTES=15
 INGESTION_MIN_REQUEST_DELAY_SECONDS=2
 INGESTION_NETWORK_ERROR_RETRIES=1
 INGESTION_RETRY_BACKOFF_SECONDS=1.0
+INGESTION_RATE_LIMIT_RETRIES=3
+INGESTION_RATE_LIMIT_BACKOFF_SECONDS=30.0
 INGESTION_MAX_PAGES_PER_SCHOLAR=30
 INGESTION_PAGE_SIZE=100
 INGESTION_ALERT_BLOCKED_FAILURE_THRESHOLD=1
@@ -125,6 +128,14 @@ UNPAYWALL_RETRY_COOLDOWN_SECONDS=1800
 UNPAYWALL_PDF_DISCOVERY_ENABLED=1
 UNPAYWALL_PDF_DISCOVERY_MAX_CANDIDATES=5
 UNPAYWALL_PDF_DISCOVERY_MAX_HTML_BYTES=500000
+ARXIV_ENABLED=1
+ARXIV_TIMEOUT_SECONDS=3.0
+ARXIV_MIN_INTERVAL_SECONDS=4.0
+ARXIV_RATE_LIMIT_COOLDOWN_SECONDS=60.0
+ARXIV_DEFAULT_MAX_RESULTS=3
+ARXIV_CACHE_TTL_SECONDS=900
+ARXIV_CACHE_MAX_ENTRIES=512
+ARXIV_MAILTO=
 PDF_AUTO_RETRY_INTERVAL_SECONDS=86400
 PDF_AUTO_RETRY_FIRST_INTERVAL_SECONDS=3600
 PDF_AUTO_RETRY_MAX_ATTEMPTS=3
@@ -133,6 +144,9 @@ CROSSREF_MAX_ROWS=10
 CROSSREF_TIMEOUT_SECONDS=8.0
 CROSSREF_MIN_INTERVAL_SECONDS=0.6
 CROSSREF_MAX_LOOKUPS_PER_REQUEST=8
+OPENALEX_API_KEY=
+CROSSREF_API_TOKEN=
+CROSSREF_API_MAILTO=
 
 # ------------------------------
 # Startup Bootstrap + DB Wait
diff --git a/alembic/versions/20260226_0023_add_arxiv_runtime_state.py b/alembic/versions/20260226_0023_add_arxiv_runtime_state.py
new file mode 100644
index 0000000..b75cd0e
--- /dev/null
+++ b/alembic/versions/20260226_0023_add_arxiv_runtime_state.py
@@ -0,0 +1,55 @@
+"""Add shared arXiv runtime state table.
+
+Revision ID: 20260226_0023
+Revises: 20260225_0022
+Create Date: 2026-02-26 12:40:00.000000
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "20260226_0023"
+down_revision: str | Sequence[str] | None = "20260225_0022"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    table_names = set(inspector.get_table_names())
+
+    if "arxiv_runtime_state" in table_names:
+        return
+
+    op.create_table(
+        "arxiv_runtime_state",
+        sa.Column("state_key", sa.String(length=64), nullable=False),
+        sa.Column("next_allowed_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("cooldown_until", sa.DateTime(timezone=True), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.PrimaryKeyConstraint("state_key", name=op.f("pk_arxiv_runtime_state")),
+    )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    table_names = set(inspector.get_table_names())
+    if "arxiv_runtime_state" in table_names:
+        op.drop_table("arxiv_runtime_state")
diff --git a/alembic/versions/20260226_0024_add_arxiv_query_cache_entries.py b/alembic/versions/20260226_0024_add_arxiv_query_cache_entries.py
new file mode 100644
index 0000000..fe2c0bc
--- /dev/null
+++ b/alembic/versions/20260226_0024_add_arxiv_query_cache_entries.py
@@ -0,0 +1,70 @@
+"""Add arXiv query cache table.
+
+Revision ID: 20260226_0024
+Revises: 20260226_0023
+Create Date: 2026-02-26 14:20:00.000000
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+
+# revision identifiers, used by Alembic.
+revision: str = "20260226_0024"
+down_revision: str | Sequence[str] | None = "20260226_0023"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    table_names = set(inspector.get_table_names())
+    if "arxiv_query_cache_entries" in table_names:
+        return
+
+    op.create_table(
+        "arxiv_query_cache_entries",
+        sa.Column("query_fingerprint", sa.String(length=64), nullable=False),
+        sa.Column("payload", postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+        sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column(
+            "cached_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.PrimaryKeyConstraint(
+            "query_fingerprint",
+            name=op.f("pk_arxiv_query_cache_entries"),
+        ),
+    )
+    op.create_index(
+        "ix_arxiv_query_cache_expires_at",
+        "arxiv_query_cache_entries",
+        ["expires_at"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_arxiv_query_cache_cached_at",
+        "arxiv_query_cache_entries",
+        ["cached_at"],
+        unique=False,
+    )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    table_names = set(inspector.get_table_names())
+    if "arxiv_query_cache_entries" in table_names:
+        op.drop_table("arxiv_query_cache_entries")
diff --git a/app/api/routers/admin_dbops.py b/app/api/routers/admin_dbops.py
index b3c1fdf..be23092 100644
--- a/app/api/routers/admin_dbops.py
+++ b/app/api/routers/admin_dbops.py
@@ -14,6 +14,8 @@ from app.api.schemas import (
     AdminPdfQueueRequeueEnvelope,
     AdminPdfQueueEnvelope,
     AdminDbRepairJobsEnvelope,
+    AdminRepairPublicationNearDuplicatesEnvelope,
+    AdminRepairPublicationNearDuplicatesRequest,
     AdminRepairPublicationLinksEnvelope,
     AdminRepairPublicationLinksRequest,
 )
@@ -22,6 +24,7 @@ from app.db.session import get_db_session
 from app.services.domains.dbops import (
     collect_integrity_report,
     list_repair_jobs,
+    run_publication_near_duplicate_repair,
     run_publication_link_repair,
 )
 from app.services.domains.publications import application as publication_service
@@ -48,7 +51,7 @@ def _serialize_repair_job(job: DataRepairJob) -> dict[str, object]:
     }
 
 
-def _requested_by_value(*, payload: AdminRepairPublicationLinksRequest, admin_user: User) -> str:
+def _requested_by_value(*, payload, admin_user: User) -> str:
     from_payload = (payload.requested_by or "").strip()
     return from_payload or admin_user.email
 
@@ -349,6 +352,47 @@ async def trigger_publication_link_repair(
     return success_payload(request, data=result)
 
 
+@router.post(
+    "/repairs/publication-near-duplicates",
+    response_model=AdminRepairPublicationNearDuplicatesEnvelope,
+)
+async def trigger_publication_near_duplicate_repair(
+    payload: AdminRepairPublicationNearDuplicatesRequest,
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    admin_user: User = Depends(get_api_admin_user),
+):
+    try:
+        result = await run_publication_near_duplicate_repair(
+            db_session,
+            dry_run=bool(payload.dry_run),
+            similarity_threshold=float(payload.similarity_threshold),
+            min_shared_tokens=int(payload.min_shared_tokens),
+            max_year_delta=int(payload.max_year_delta),
+            max_clusters=int(payload.max_clusters),
+            selected_cluster_keys=list(payload.selected_cluster_keys),
+            requested_by=_requested_by_value(payload=payload, admin_user=admin_user),
+        )
+    except ValueError as exc:
+        raise ApiException(
+            status_code=400,
+            code="invalid_near_duplicate_repair_request",
+            message=str(exc),
+        ) from exc
+    logger.info(
+        "api.admin.db.publication_near_duplicate_repair_triggered",
+        extra={
+            "event": "api.admin.db.publication_near_duplicate_repair_triggered",
+            "admin_user_id": int(admin_user.id),
+            "dry_run": bool(payload.dry_run),
+            "selected_cluster_count": len(payload.selected_cluster_keys),
+            "job_id": int(result["job_id"]),
+            "status": result["status"],
+        },
+    )
+    return success_payload(request, data=result)
+
+
 DROP_PUBLICATIONS_CONFIRMATION = "DROP ALL PUBLICATIONS"
 
 
diff --git a/app/api/routers/publications.py b/app/api/routers/publications.py
index b4a616e..7de2f12 100644
--- a/app/api/routers/publications.py
+++ b/app/api/routers/publications.py
@@ -94,6 +94,7 @@ async def _publication_counts(
     user_id: int,
     selected_scholar_id: int | None,
     favorite_only: bool,
+    search: str | None,
     snapshot_before: datetime | None,
 ) -> tuple[int, int, int, int]:
     unread_count = await publication_service.count_unread_for_user(
@@ -122,6 +123,7 @@ async def _publication_counts(
         mode=publication_service.MODE_ALL,
         scholar_profile_id=selected_scholar_id,
         favorite_only=favorite_only,
+        search=search,
         snapshot_before=snapshot_before,
     )
     return unread_count, favorites_count, latest_count, total_count
@@ -372,7 +374,7 @@ async def list_publications(
     favorite_only: bool = Query(default=False),
     scholar_profile_id: int | None = Query(default=None, ge=1),
     search: str | None = Query(default=None, min_length=1, max_length=200),
-    sort_by: Literal["first_seen", "title", "year", "citations", "scholar"] = Query(default="first_seen"),
+    sort_by: Literal["first_seen", "title", "year", "citations", "scholar", "pdf_status"] = Query(default="first_seen"),
     sort_dir: Literal["asc", "desc"] = Query(default="desc"),
     page: int = Query(default=1, ge=1),
     page_size: int = Query(default=100, ge=1, le=500),
@@ -408,6 +410,7 @@ async def list_publications(
         user_id=current_user.id,
         selected_scholar_id=selected_scholar_id,
         favorite_only=favorite_only,
+        search=normalized_search,
         snapshot_before=snapshot_before,
     )
     data = _publications_list_data(
diff --git a/app/api/routers/scholars.py b/app/api/routers/scholars.py
index f4be187..2dc0e2f 100644
--- a/app/api/routers/scholars.py
+++ b/app/api/routers/scholars.py
@@ -23,7 +23,9 @@ from app.api.schemas import (
 )
 from app.db.models import User
 from app.db.session import get_db_session
+from app.services.domains.ingestion import queue as ingestion_queue_service
 from app.services.domains.portability import application as import_export_service
+from app.services.domains.scholar import rate_limit as scholar_rate_limit
 from app.services.domains.scholars import application as scholar_service
 from app.services.domains.scholar.source import ScholarSource
 from app.settings import settings
@@ -31,6 +33,73 @@ from app.settings import settings
 logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/scholars", tags=["api-scholars"])
+CREATE_METADATA_HYDRATION_TIMEOUT_SECONDS = 5.0
+INITIAL_SCHOLAR_SCRAPE_QUEUE_DELAY_SECONDS = 0
+INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON = "scholar_added_initial_scrape"
+
+
+def _needs_metadata_hydration(profile) -> bool:
+    if not profile.profile_image_url:
+        return True
+    return not (profile.display_name or "").strip()
+
+
+def _is_create_hydration_rate_limited() -> tuple[bool, float]:
+    remaining_seconds = scholar_rate_limit.remaining_scholar_slot_seconds(
+        min_interval_seconds=float(settings.ingestion_min_request_delay_seconds),
+    )
+    return remaining_seconds > 0, remaining_seconds
+
+
+def _auto_enqueue_new_scholar_enabled() -> bool:
+    if not settings.scheduler_enabled:
+        return False
+    if not settings.ingestion_automation_allowed:
+        return False
+    return bool(settings.ingestion_continuation_queue_enabled)
+
+
+async def _enqueue_initial_scrape_job_for_scholar(
+    db_session: AsyncSession,
+    *,
+    profile,
+    user_id: int,
+) -> bool:
+    if not _auto_enqueue_new_scholar_enabled():
+        return False
+    try:
+        await ingestion_queue_service.upsert_job(
+            db_session,
+            user_id=user_id,
+            scholar_profile_id=int(profile.id),
+            resume_cstart=0,
+            reason=INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON,
+            run_id=None,
+            delay_seconds=INITIAL_SCHOLAR_SCRAPE_QUEUE_DELAY_SECONDS,
+        )
+        await db_session.commit()
+    except Exception:
+        await db_session.rollback()
+        logger.warning(
+            "api.scholars.initial_scrape_enqueue_failed",
+            extra={
+                "event": "api.scholars.initial_scrape_enqueue_failed",
+                "user_id": user_id,
+                "scholar_profile_id": profile.id,
+            },
+        )
+        return False
+
+    logger.info(
+        "api.scholars.initial_scrape_enqueued",
+        extra={
+            "event": "api.scholars.initial_scrape_enqueued",
+            "user_id": user_id,
+            "scholar_profile_id": profile.id,
+            "reason": INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON,
+        },
+    )
+    return True
 
 
 def _uploaded_image_media_path(scholar_profile_id: int) -> str:
@@ -69,16 +138,42 @@ async def _hydrate_scholar_metadata_if_needed(
     source: ScholarSource,
     user_id: int,
 ):
+    if not _needs_metadata_hydration(profile):
+        return profile
+
+    should_skip, remaining_seconds = _is_create_hydration_rate_limited()
+    if should_skip:
+        logger.info(
+            "api.scholars.create_metadata_hydration_skipped",
+            extra={
+                "event": "api.scholars.create_metadata_hydration_skipped",
+                "reason": "scholar_request_throttle_active",
+                "user_id": user_id,
+                "scholar_profile_id": profile.id,
+                "retry_after_seconds": round(remaining_seconds, 3),
+            },
+        )
+        return profile
+
     try:
-        if not profile.profile_image_url or not (profile.display_name or "").strip():
-            return await asyncio.wait_for(
-                scholar_service.hydrate_profile_metadata(
-                    db_session,
-                    profile=profile,
-                    source=source,
-                ),
-                timeout=5.0,
-            )
+        return await asyncio.wait_for(
+            scholar_service.hydrate_profile_metadata(
+                db_session,
+                profile=profile,
+                source=source,
+            ),
+            timeout=CREATE_METADATA_HYDRATION_TIMEOUT_SECONDS,
+        )
+    except TimeoutError:
+        logger.info(
+            "api.scholars.create_metadata_hydration_skipped",
+            extra={
+                "event": "api.scholars.create_metadata_hydration_skipped",
+                "reason": "create_timeout",
+                "user_id": user_id,
+                "scholar_profile_id": profile.id,
+            },
+        )
     except Exception:
         logger.warning(
             "api.scholars.create_metadata_hydration_failed",
@@ -280,12 +375,18 @@ async def create_scholar(
             "scholar_profile_id": created.id,
         },
     )
-    created = await _hydrate_scholar_metadata_if_needed(
+    did_queue_initial_scrape = await _enqueue_initial_scrape_job_for_scholar(
         db_session,
         profile=created,
-        source=source,
         user_id=current_user.id,
     )
+    if not did_queue_initial_scrape:
+        created = await _hydrate_scholar_metadata_if_needed(
+            db_session,
+            profile=created,
+            source=source,
+            user_id=current_user.id,
+        )
 
     return success_payload(
         request,
@@ -554,4 +655,3 @@ async def clear_scholar_image_customization(
         request,
         data=_serialize_scholar(updated),
     )
-
diff --git a/app/api/schemas.py b/app/api/schemas.py
index 07ccedf..e3b9ac7 100644
--- a/app/api/schemas.py
+++ b/app/api/schemas.py
@@ -703,6 +703,70 @@ class AdminRepairPublicationLinksEnvelope(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
 
+class AdminNearDuplicateClusterMemberData(BaseModel):
+    publication_id: int
+    title: str
+    year: int | None
+    citation_count: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminNearDuplicateClusterData(BaseModel):
+    cluster_key: str
+    winner_publication_id: int
+    member_count: int
+    similarity_score: float = Field(ge=0.0, le=1.0)
+    members: list[AdminNearDuplicateClusterMemberData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminRepairPublicationNearDuplicatesRequest(BaseModel):
+    dry_run: bool = True
+    similarity_threshold: float = Field(default=0.78, ge=0.5, le=1.0)
+    min_shared_tokens: int = Field(default=3, ge=1, le=8)
+    max_year_delta: int = Field(default=1, ge=0, le=5)
+    max_clusters: int = Field(default=25, ge=1, le=200)
+    selected_cluster_keys: list[str] = Field(default_factory=list, max_length=200)
+    requested_by: str | None = None
+    confirmation_text: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+    @model_validator(mode="after")
+    def validate_apply_mode(self) -> "AdminRepairPublicationNearDuplicatesRequest":
+        if self.dry_run:
+            return self
+        if not self.selected_cluster_keys:
+            raise ValueError("selected_cluster_keys is required when dry_run=false.")
+        expected = "MERGE SELECTED DUPLICATES"
+        provided = (self.confirmation_text or "").strip()
+        if provided != expected:
+            raise ValueError(
+                "confirmation_text must equal 'MERGE SELECTED DUPLICATES' "
+                "when applying near-duplicate merges."
+            )
+        return self
+
+
+class AdminRepairPublicationNearDuplicatesResultData(BaseModel):
+    job_id: int
+    status: str
+    scope: dict[str, Any] = Field(default_factory=dict)
+    summary: dict[str, Any] = Field(default_factory=dict)
+    clusters: list[AdminNearDuplicateClusterData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminRepairPublicationNearDuplicatesEnvelope(BaseModel):
+    data: AdminRepairPublicationNearDuplicatesResultData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
 class SettingsPolicyData(BaseModel):
     min_run_interval_minutes: int
     min_request_delay_seconds: int
diff --git a/app/db/models.py b/app/db/models.py
index c687547..6a51811 100644
--- a/app/db/models.py
+++ b/app/db/models.py
@@ -540,6 +540,44 @@ class AuthorSearchRuntimeState(Base):
     )
 
 
+class ArxivRuntimeState(Base):
+    __tablename__ = "arxiv_runtime_state"
+
+    state_key: Mapped[str] = mapped_column(String(64), primary_key=True)
+    next_allowed_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    cooldown_until: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
+class ArxivQueryCacheEntry(Base):
+    __tablename__ = "arxiv_query_cache_entries"
+    __table_args__ = (
+        Index("ix_arxiv_query_cache_expires_at", "expires_at"),
+        Index("ix_arxiv_query_cache_cached_at", "cached_at"),
+    )
+
+    query_fingerprint: Mapped[str] = mapped_column(String(64), primary_key=True)
+    payload: Mapped[dict] = mapped_column(
+        JSONB,
+        nullable=False,
+    )
+    expires_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        nullable=False,
+    )
+    cached_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+
 class AuthorSearchCacheEntry(Base):
     __tablename__ = "author_search_cache_entries"
     __table_args__ = (
diff --git a/app/services/domains/arxiv/application.py b/app/services/domains/arxiv/application.py
index 57b1473..8b99096 100644
--- a/app/services/domains/arxiv/application.py
+++ b/app/services/domains/arxiv/application.py
@@ -1,110 +1,29 @@
 from __future__ import annotations
 
-import asyncio
-import logging
 from typing import TYPE_CHECKING
-import xml.etree.ElementTree as ET
-
-import httpx
-
-from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
-from app.settings import settings
+from app.services.domains.arxiv.gateway import (
+    build_arxiv_query,
+    get_arxiv_gateway,
+)
+from app.services.domains.arxiv.errors import ArxivRateLimitError
 
 if TYPE_CHECKING:
     from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
 
-logger = logging.getLogger(__name__)
-
-# arXiv API terms: max 1 request per 3 seconds, single connection at a time.
-_ARXIV_LOCK = asyncio.Lock()
-_ARXIV_MIN_INTERVAL_SECONDS = 4.0
-# Global cooldown: when arXiv returns 429, all batches back off for this long.
-_ARXIV_RATE_LIMIT_COOLDOWN_SECONDS = 60.0
-_arxiv_rate_limited_until: float = 0.0  # asyncio monotonic time
-
-
-class ArxivRateLimitError(Exception):
-    """arXiv returned 429 — stop the batch to avoid hammering."""
-    pass
-
 
 def _build_arxiv_query(title: str, author_surname: str | None) -> str | None:
-    parts = []
-    if title:
-        clean_title = title.replace('"', '').replace("'", "")
-        parts.append(f'ti:"{clean_title}"')
-    if author_surname:
-        parts.append(f'au:"{author_surname}"')
-    if not parts:
-        return None
-    return " AND ".join(parts)
+    return build_arxiv_query(title, author_surname)
 
 
 async def discover_arxiv_id_for_publication(
     *,
     item: PublicationListItem | UnreadPublicationItem,
     request_email: str | None = None,
-    timeout_seconds: float = 3.0,
+    timeout_seconds: float | None = None,
 ) -> str | None:
-    title = (item.title or "").strip()
-    if not title:
-        return None
-
-    author_surname = None
-    if item.scholar_label:
-        tokens = [t for t in item.scholar_label.strip().split() if t]
-        if tokens:
-            author_surname = tokens[-1].lower()
-
-    query = _build_arxiv_query(title, author_surname)
-    if not query:
-        return None
-
-    url = "https://export.arxiv.org/api/query"
-    params = {"search_query": query, "start": 0, "max_results": 3}
-    headers = {
-        "User-Agent": (
-            f"scholar-scraper/1.0 "
-            f"(mailto:{request_email or settings.crossref_api_mailto or 'unknown@example.com'})"
-        )
-    }
-
-    try:
-        async with _ARXIV_LOCK:
-            global _arxiv_rate_limited_until
-            now = asyncio.get_running_loop().time()
-            if now < _arxiv_rate_limited_until:
-                remaining = _arxiv_rate_limited_until - now
-                raise ArxivRateLimitError(f"arXiv global cooldown active ({remaining:.0f}s remaining)")
-
-            async with httpx.AsyncClient(timeout=timeout_seconds, follow_redirects=True, headers=headers) as client:
-                response = await client.get(url, params=params)
-
-            if response.status_code == 429:
-                _arxiv_rate_limited_until = asyncio.get_running_loop().time() + _ARXIV_RATE_LIMIT_COOLDOWN_SECONDS
-                raise ArxivRateLimitError("arXiv rate limit hit (429) — stopping batch")
-
-            await asyncio.sleep(_ARXIV_MIN_INTERVAL_SECONDS)
-
-        response.raise_for_status()
-
-        root = ET.fromstring(response.text)
-        namespace = {"atom": "http://www.w3.org/2005/Atom"}
-
-        for entry in root.findall("atom:entry", namespace):
-            id_elem = entry.find("atom:id", namespace)
-            if id_elem is not None and id_elem.text:
-                candidate = str(id_elem.text)
-                if "/abs/" in candidate:
-                    candidate = candidate.split("/abs/")[-1]
-                normalized = normalize_arxiv_id(candidate)
-                if normalized:
-                    logger.debug("arxiv.id_discovered", extra={"event": "arxiv.id_discovered", "arxiv_id": normalized})
-                    return normalized
-
-    except ArxivRateLimitError:
-        raise  # propagate so the batch loop can stop
-    except Exception as exc:
-        logger.debug(f"Failed to query arXiv API: {exc}")
-
-    return None
+    gateway = get_arxiv_gateway()
+    return await gateway.discover_arxiv_id_for_publication(
+        item=item,
+        request_email=request_email,
+        timeout_seconds=timeout_seconds,
+    )
diff --git a/app/services/domains/arxiv/cache.py b/app/services/domains/arxiv/cache.py
new file mode 100644
index 0000000..de16416
--- /dev/null
+++ b/app/services/domains/arxiv/cache.py
@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import asdict
+from datetime import datetime, timedelta, timezone
+import hashlib
+import json
+from typing import Any
+
+from sqlalchemy import delete, func, select
+
+from app.db.models import ArxivQueryCacheEntry
+from app.db.session import get_session_factory
+from app.services.domains.arxiv.constants import ARXIV_CACHE_FINGERPRINT_VERSION
+from app.services.domains.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
+
+_INFLIGHT_LOCK = asyncio.Lock()
+_INFLIGHT_FEEDS: dict[str, asyncio.Future[ArxivFeed]] = {}
+
+
+def build_query_fingerprint(*, params: Mapping[str, object]) -> str:
+    canonical = _canonical_cache_payload(params=params)
+    encoded = json.dumps(canonical, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
+    payload = f"{ARXIV_CACHE_FINGERPRINT_VERSION}:{encoded}"
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+async def get_cached_feed(
+    *,
+    query_fingerprint: str,
+    now_utc: datetime | None = None,
+) -> ArxivFeed | None:
+    timestamp = _as_utc(now_utc)
+    session_factory = get_session_factory()
+    async with session_factory() as db_session:
+        async with db_session.begin():
+            result = await db_session.execute(
+                select(ArxivQueryCacheEntry).where(
+                    ArxivQueryCacheEntry.query_fingerprint == query_fingerprint
+                )
+            )
+            entry = result.scalar_one_or_none()
+            return await _validate_cached_entry(db_session, entry=entry, now_utc=timestamp)
+
+
+async def set_cached_feed(
+    *,
+    query_fingerprint: str,
+    feed: ArxivFeed,
+    ttl_seconds: float,
+    max_entries: int,
+    now_utc: datetime | None = None,
+) -> None:
+    timestamp = _as_utc(now_utc)
+    session_factory = get_session_factory()
+    async with session_factory() as db_session:
+        async with db_session.begin():
+            await _write_cached_entry(
+                db_session,
+                query_fingerprint=query_fingerprint,
+                feed=feed,
+                ttl_seconds=ttl_seconds,
+                max_entries=max_entries,
+                now_utc=timestamp,
+            )
+
+
+async def run_with_inflight_dedupe(
+    *,
+    query_fingerprint: str,
+    fetch_feed: Callable[[], Awaitable[ArxivFeed]],
+) -> ArxivFeed:
+    future, is_owner = await _reserve_inflight_future(query_fingerprint=query_fingerprint)
+    if not is_owner:
+        return await asyncio.shield(future)
+    try:
+        result = await fetch_feed()
+    except Exception as exc:
+        _complete_future(future, error=exc)
+        raise
+    finally:
+        await _release_inflight_future(query_fingerprint=query_fingerprint, future=future)
+    _complete_future(future, result=result)
+    return result
+
+
+def _canonical_cache_payload(*, params: Mapping[str, object]) -> dict[str, object]:
+    payload: dict[str, object] = {}
+    for key in sorted(params.keys()):
+        payload[str(key)] = _normalize_param_value(str(key), params[key])
+    return payload
+
+
+def _normalize_param_value(key: str, value: object) -> object:
+    if key == "search_query":
+        return _normalize_search_query(str(value or ""))
+    if key == "id_list":
+        return _normalize_id_list(str(value or ""))
+    if isinstance(value, str):
+        return " ".join(value.strip().split())
+    if isinstance(value, (int, float, bool)) or value is None:
+        return value
+    return str(value).strip()
+
+
+def _normalize_search_query(value: str) -> str:
+    return " ".join(value.strip().lower().split())
+
+
+def _normalize_id_list(value: str) -> str:
+    normalized = [item.strip().lower() for item in value.split(",") if item.strip()]
+    return ",".join(sorted(normalized))
+
+
+async def _validate_cached_entry(
+    db_session,
+    *,
+    entry: ArxivQueryCacheEntry | None,
+    now_utc: datetime,
+) -> ArxivFeed | None:
+    if entry is None:
+        return None
+    if _as_utc(entry.expires_at) <= now_utc:
+        await db_session.delete(entry)
+        return None
+    parsed = _deserialize_feed(entry.payload)
+    if parsed is None:
+        await db_session.delete(entry)
+        return None
+    return parsed
+
+
+async def _write_cached_entry(
+    db_session,
+    *,
+    query_fingerprint: str,
+    feed: ArxivFeed,
+    ttl_seconds: float,
+    max_entries: int,
+    now_utc: datetime,
+) -> None:
+    ttl = max(float(ttl_seconds), 0.0)
+    result = await db_session.execute(
+        select(ArxivQueryCacheEntry).where(
+            ArxivQueryCacheEntry.query_fingerprint == query_fingerprint
+        )
+    )
+    existing = result.scalar_one_or_none()
+    if ttl <= 0.0:
+        if existing is not None:
+            await db_session.delete(existing)
+        return
+    expires_at = now_utc + timedelta(seconds=ttl)
+    payload = _serialize_feed(feed)
+    if existing is None:
+        db_session.add(
+            ArxivQueryCacheEntry(
+                query_fingerprint=query_fingerprint,
+                payload=payload,
+                expires_at=expires_at,
+                cached_at=now_utc,
+                updated_at=now_utc,
+            )
+        )
+    else:
+        existing.payload = payload
+        existing.expires_at = expires_at
+        existing.cached_at = now_utc
+        existing.updated_at = now_utc
+    await _prune_cache_entries(db_session, now_utc=now_utc, max_entries=max_entries)
+
+
+async def _prune_cache_entries(
+    db_session,
+    *,
+    now_utc: datetime,
+    max_entries: int,
+) -> None:
+    await db_session.execute(
+        delete(ArxivQueryCacheEntry).where(ArxivQueryCacheEntry.expires_at <= now_utc)
+    )
+    bounded_max_entries = int(max_entries)
+    if bounded_max_entries <= 0:
+        return
+    count_result = await db_session.execute(
+        select(func.count()).select_from(ArxivQueryCacheEntry)
+    )
+    entry_count = int(count_result.scalar_one() or 0)
+    overflow = max(0, entry_count - bounded_max_entries)
+    if overflow <= 0:
+        return
+    stale_result = await db_session.execute(
+        select(ArxivQueryCacheEntry.query_fingerprint)
+        .order_by(ArxivQueryCacheEntry.cached_at.asc())
+        .limit(overflow)
+    )
+    stale_keys = [str(row[0]) for row in stale_result.all()]
+    if stale_keys:
+        await db_session.execute(
+            delete(ArxivQueryCacheEntry).where(
+                ArxivQueryCacheEntry.query_fingerprint.in_(stale_keys)
+            )
+        )
+
+
+def _serialize_feed(feed: ArxivFeed) -> dict[str, Any]:
+    return asdict(feed)
+
+
+def _deserialize_feed(payload: object) -> ArxivFeed | None:
+    if not isinstance(payload, dict):
+        return None
+    entries_payload = payload.get("entries")
+    opensearch_payload = payload.get("opensearch")
+    if not isinstance(entries_payload, list):
+        return None
+    entries: list[ArxivEntry] = []
+    for value in entries_payload:
+        entry = _deserialize_entry(value)
+        if entry is None:
+            return None
+        entries.append(entry)
+    opensearch = _deserialize_opensearch(opensearch_payload)
+    if opensearch is None:
+        return None
+    return ArxivFeed(entries=entries, opensearch=opensearch)
+
+
+def _deserialize_entry(value: object) -> ArxivEntry | None:
+    if not isinstance(value, dict):
+        return None
+    try:
+        return ArxivEntry(
+            entry_id_url=str(value["entry_id_url"]),
+            arxiv_id=_as_optional_string(value.get("arxiv_id")),
+            title=str(value["title"]),
+            summary=str(value["summary"]),
+            published=_as_optional_string(value.get("published")),
+            updated=_as_optional_string(value.get("updated")),
+            authors=_as_string_list(value.get("authors")),
+            links=_as_string_list(value.get("links")),
+            categories=_as_string_list(value.get("categories")),
+            primary_category=_as_optional_string(value.get("primary_category")),
+        )
+    except KeyError:
+        return None
+
+
+def _deserialize_opensearch(value: object) -> ArxivOpenSearchMeta | None:
+    if not isinstance(value, dict):
+        return None
+    try:
+        return ArxivOpenSearchMeta(
+            total_results=int(value.get("total_results", 0)),
+            start_index=int(value.get("start_index", 0)),
+            items_per_page=int(value.get("items_per_page", 0)),
+        )
+    except (TypeError, ValueError):
+        return None
+
+
+def _as_optional_string(value: object) -> str | None:
+    if value is None:
+        return None
+    normalized = str(value).strip()
+    return normalized or None
+
+
+def _as_string_list(value: object) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(item) for item in value]
+
+
+def _as_utc(value: datetime | None) -> datetime:
+    if value is None:
+        return datetime.now(timezone.utc)
+    if value.tzinfo is None:
+        return value.replace(tzinfo=timezone.utc)
+    return value
+
+
+async def _reserve_inflight_future(
+    *,
+    query_fingerprint: str,
+) -> tuple[asyncio.Future[ArxivFeed], bool]:
+    async with _INFLIGHT_LOCK:
+        existing = _INFLIGHT_FEEDS.get(query_fingerprint)
+        if existing is not None:
+            return existing, False
+        loop = asyncio.get_running_loop()
+        created = loop.create_future()
+        created.add_done_callback(_consume_unretrieved_future_exception)
+        _INFLIGHT_FEEDS[query_fingerprint] = created
+        return created, True
+
+
+async def _release_inflight_future(
+    *,
+    query_fingerprint: str,
+    future: asyncio.Future[ArxivFeed],
+) -> None:
+    async with _INFLIGHT_LOCK:
+        current = _INFLIGHT_FEEDS.get(query_fingerprint)
+        if current is future:
+            _INFLIGHT_FEEDS.pop(query_fingerprint, None)
+
+
+def _complete_future(
+    future: asyncio.Future[ArxivFeed],
+    *,
+    result: ArxivFeed | None = None,
+    error: Exception | None = None,
+) -> None:
+    if future.done():
+        return
+    if error is not None:
+        future.set_exception(error)
+        return
+    if result is None:
+        raise RuntimeError("in-flight future completion requires result or error")
+    future.set_result(result)
+
+
+def _consume_unretrieved_future_exception(future: asyncio.Future[ArxivFeed]) -> None:
+    if future.cancelled():
+        return
+    try:
+        _ = future.exception()
+    except Exception:
+        return
diff --git a/app/services/domains/arxiv/client.py b/app/services/domains/arxiv/client.py
new file mode 100644
index 0000000..278ca0f
--- /dev/null
+++ b/app/services/domains/arxiv/client.py
@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+import logging
+
+import httpx
+
+from app.services.domains.arxiv.cache import (
+    build_query_fingerprint,
+    get_cached_feed,
+    run_with_inflight_dedupe,
+    set_cached_feed,
+)
+from app.services.domains.arxiv.constants import (
+    ARXIV_SOURCE_PATH_LOOKUP_IDS,
+    ARXIV_SOURCE_PATH_SEARCH,
+    ARXIV_SOURCE_PATH_UNKNOWN,
+)
+from app.services.domains.arxiv.errors import ArxivClientValidationError, ArxivRateLimitError
+from app.services.domains.arxiv.parser import parse_arxiv_feed
+from app.services.domains.arxiv.rate_limit import get_arxiv_cooldown_status, run_with_global_arxiv_limit
+from app.services.domains.arxiv.types import ArxivFeed
+from app.settings import settings
+
+_ARXIV_API_URL = "https://export.arxiv.org/api/query"
+_ARXIV_QUERY_START = 0
+_ARXIV_MAX_RESULTS_LIMIT = 30_000
+_ARXIV_SORT_BY_ALLOWED = {"relevance", "lastUpdatedDate", "submittedDate"}
+_ARXIV_SORT_ORDER_ALLOWED = {"ascending", "descending"}
+_FALLBACK_CONTACT_EMAIL = "unknown@example.com"
+
+ArxivRequestFn = Callable[..., Awaitable[httpx.Response]]
+logger = logging.getLogger(__name__)
+
+
+class ArxivClient:
+    def __init__(
+        self,
+        *,
+        request_fn: ArxivRequestFn | None = None,
+        cache_enabled: bool | None = None,
+    ) -> None:
+        self._request_fn = request_fn or _request_arxiv_feed
+        self._cache_enabled = _resolve_cache_enabled(
+            cache_enabled=cache_enabled,
+            request_fn=request_fn,
+        )
+        self._cache_ttl_seconds = _cache_ttl_seconds()
+        self._cache_max_entries = _cache_max_entries()
+
+    async def search(
+        self,
+        *,
+        query: str,
+        start: int = _ARXIV_QUERY_START,
+        max_results: int | None = None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+        request_email: str | None = None,
+        timeout_seconds: float | None = None,
+    ) -> ArxivFeed:
+        params = _search_params(
+            query=query,
+            start=start,
+            max_results=max_results,
+            sort_by=sort_by,
+            sort_order=sort_order,
+        )
+        return await self._fetch_feed(
+            params=params,
+            request_email=request_email,
+            timeout_seconds=timeout_seconds,
+            source_path=ARXIV_SOURCE_PATH_SEARCH,
+        )
+
+    async def lookup_ids(
+        self,
+        *,
+        id_list: list[str],
+        start: int = _ARXIV_QUERY_START,
+        max_results: int | None = None,
+        request_email: str | None = None,
+        timeout_seconds: float | None = None,
+    ) -> ArxivFeed:
+        params = _lookup_params(id_list=id_list, start=start, max_results=max_results)
+        return await self._fetch_feed(
+            params=params,
+            request_email=request_email,
+            timeout_seconds=timeout_seconds,
+            source_path=ARXIV_SOURCE_PATH_LOOKUP_IDS,
+        )
+
+    async def _fetch_feed(
+        self,
+        *,
+        params: dict[str, object],
+        request_email: str | None,
+        timeout_seconds: float | None,
+        source_path: str,
+    ) -> ArxivFeed:
+        query_fingerprint = build_query_fingerprint(params=params)
+        if self._cache_enabled:
+            cached = await get_cached_feed(query_fingerprint=query_fingerprint)
+            if cached is not None:
+                _log_cache_event(
+                    event_name="arxiv.cache_hit",
+                    query_fingerprint=query_fingerprint,
+                    source_path=source_path,
+                )
+                return cached
+            _log_cache_event(
+                event_name="arxiv.cache_miss",
+                query_fingerprint=query_fingerprint,
+                source_path=source_path,
+            )
+        return await run_with_inflight_dedupe(
+            query_fingerprint=query_fingerprint,
+            fetch_feed=lambda: self._fetch_live_feed(
+                params=params,
+                request_email=request_email,
+                timeout_seconds=timeout_seconds,
+                query_fingerprint=query_fingerprint,
+            ),
+        )
+
+    async def _fetch_live_feed(
+        self,
+        *,
+        params: dict[str, object],
+        request_email: str | None,
+        timeout_seconds: float | None,
+        query_fingerprint: str,
+    ) -> ArxivFeed:
+        response = await self._request_fn(
+            params=params,
+            request_email=request_email,
+            timeout_seconds=timeout_seconds,
+        )
+        response.raise_for_status()
+        feed = parse_arxiv_feed(response.text)
+        if self._cache_enabled:
+            await set_cached_feed(
+                query_fingerprint=query_fingerprint,
+                feed=feed,
+                ttl_seconds=self._cache_ttl_seconds,
+                max_entries=self._cache_max_entries,
+            )
+        return feed
+
+
+def _search_params(
+    *,
+    query: str,
+    start: int,
+    max_results: int | None,
+    sort_by: str | None,
+    sort_order: str | None,
+) -> dict[str, object]:
+    clean_query = query.strip()
+    if not clean_query:
+        raise ArxivClientValidationError("search query must not be empty")
+    params: dict[str, object] = {
+        "search_query": clean_query,
+        "start": _validate_start(start),
+        "max_results": _validate_max_results(max_results),
+    }
+    if sort_by is not None:
+        params["sortBy"] = _validate_sort_by(sort_by)
+    if sort_order is not None:
+        params["sortOrder"] = _validate_sort_order(sort_order)
+    return params
+
+
+def _lookup_params(*, id_list: list[str], start: int, max_results: int | None) -> dict[str, object]:
+    normalized_ids = [value.strip() for value in id_list if value and value.strip()]
+    if not normalized_ids:
+        raise ArxivClientValidationError("id_list must include at least one id")
+    return {
+        "id_list": ",".join(normalized_ids),
+        "start": _validate_start(start),
+        "max_results": _validate_max_results(max_results),
+    }
+
+
+def _validate_start(value: int) -> int:
+    start = int(value)
+    if start < 0:
+        raise ArxivClientValidationError("start must be >= 0")
+    return start
+
+
+def _validate_max_results(value: int | None) -> int:
+    if value is None:
+        default_value = int(settings.arxiv_default_max_results)
+        return max(default_value, 1)
+    parsed = int(value)
+    if parsed < 1:
+        raise ArxivClientValidationError("max_results must be >= 1")
+    if parsed > _ARXIV_MAX_RESULTS_LIMIT:
+        raise ArxivClientValidationError(f"max_results must be <= {_ARXIV_MAX_RESULTS_LIMIT}")
+    return parsed
+
+
+def _validate_sort_by(value: str) -> str:
+    if value not in _ARXIV_SORT_BY_ALLOWED:
+        raise ArxivClientValidationError(f"sort_by must be one of: {sorted(_ARXIV_SORT_BY_ALLOWED)!r}")
+    return value
+
+
+def _validate_sort_order(value: str) -> str:
+    if value not in _ARXIV_SORT_ORDER_ALLOWED:
+        raise ArxivClientValidationError(f"sort_order must be one of: {sorted(_ARXIV_SORT_ORDER_ALLOWED)!r}")
+    return value
+
+
+async def _request_arxiv_feed(
+    *,
+    params: dict[str, object],
+    request_email: str | None,
+    timeout_seconds: float | None,
+) -> httpx.Response:
+    source_path = _source_path_from_params(params)
+    cooldown_status = await get_arxiv_cooldown_status()
+    if cooldown_status.is_active:
+        _log_request_skipped_for_cooldown(
+            source_path=source_path,
+            cooldown_remaining_seconds=cooldown_status.remaining_seconds,
+        )
+        raise ArxivRateLimitError(
+            f"arXiv global cooldown active ({cooldown_status.remaining_seconds:.0f}s remaining)"
+        )
+
+    async def _fetch() -> httpx.Response:
+        timeout_value = _timeout_seconds(timeout_seconds)
+        headers = {"User-Agent": f"scholar-scraper/1.0 (mailto:{_contact_email(request_email)})"}
+        async with httpx.AsyncClient(timeout=timeout_value, follow_redirects=True, headers=headers) as client:
+            return await client.get(_ARXIV_API_URL, params=params)
+
+    return await run_with_global_arxiv_limit(
+        fetch=_fetch,
+        source_path=source_path,
+    )
+
+
+def _timeout_seconds(timeout_seconds: float | None) -> float:
+    if timeout_seconds is not None:
+        return max(float(timeout_seconds), 0.5)
+    return max(float(settings.arxiv_timeout_seconds), 0.5)
+
+
+def _contact_email(request_email: str | None) -> str:
+    return request_email or settings.arxiv_mailto or settings.crossref_api_mailto or _FALLBACK_CONTACT_EMAIL
+
+
+def _resolve_cache_enabled(
+    *,
+    cache_enabled: bool | None,
+    request_fn: ArxivRequestFn | None,
+) -> bool:
+    if cache_enabled is not None:
+        return bool(cache_enabled)
+    if request_fn is not None:
+        return False
+    return _cache_ttl_seconds() > 0.0
+
+
+def _cache_ttl_seconds() -> float:
+    return max(float(settings.arxiv_cache_ttl_seconds), 0.0)
+
+
+def _cache_max_entries() -> int:
+    return max(int(settings.arxiv_cache_max_entries), 0)
+
+
+def _source_path_from_params(params: dict[str, object]) -> str:
+    if "search_query" in params:
+        return ARXIV_SOURCE_PATH_SEARCH
+    if "id_list" in params:
+        return ARXIV_SOURCE_PATH_LOOKUP_IDS
+    return ARXIV_SOURCE_PATH_UNKNOWN
+
+
+def _log_cache_event(
+    *,
+    event_name: str,
+    query_fingerprint: str,
+    source_path: str,
+) -> None:
+    logger.info(
+        event_name,
+        extra={
+            "event": event_name,
+            "query_fingerprint": query_fingerprint,
+            "source_path": source_path,
+        },
+    )
+
+
+def _log_request_skipped_for_cooldown(
+    *,
+    source_path: str,
+    cooldown_remaining_seconds: float,
+) -> None:
+    logger.warning(
+        "arxiv.request_skipped_cooldown",
+        extra={
+            "event": "arxiv.request_skipped_cooldown",
+            "source_path": source_path,
+            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
+        },
+    )
diff --git a/app/services/domains/arxiv/constants.py b/app/services/domains/arxiv/constants.py
new file mode 100644
index 0000000..eab9293
--- /dev/null
+++ b/app/services/domains/arxiv/constants.py
@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+ARXIV_RUNTIME_STATE_KEY = "global"
+ARXIV_RATE_LIMIT_LOCK_NAMESPACE = 91_100
+ARXIV_RATE_LIMIT_LOCK_KEY = 1
+ARXIV_SOURCE_PATH_SEARCH = "search"
+ARXIV_SOURCE_PATH_LOOKUP_IDS = "lookup_ids"
+ARXIV_SOURCE_PATH_UNKNOWN = "unknown"
+ARXIV_CACHE_FINGERPRINT_VERSION = "v1"
+ARXIV_TITLE_TOKEN_MIN_LENGTH = 3
+ARXIV_TITLE_MIN_TOKENS = 3
+ARXIV_TITLE_MIN_ALPHA_TOKENS = 2
+ARXIV_STRONG_IDENTIFIER_CONFIDENCE = 0.9
diff --git a/app/services/domains/arxiv/errors.py b/app/services/domains/arxiv/errors.py
new file mode 100644
index 0000000..3561f61
--- /dev/null
+++ b/app/services/domains/arxiv/errors.py
@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+
+class ArxivRateLimitError(Exception):
+    """arXiv returned 429 or cooldown is active."""
+
+
+class ArxivClientValidationError(ValueError):
+    """arXiv client inputs are invalid."""
+
+
+class ArxivParseError(ValueError):
+    """arXiv API payload could not be parsed."""
diff --git a/app/services/domains/arxiv/gateway.py b/app/services/domains/arxiv/gateway.py
new file mode 100644
index 0000000..6782025
--- /dev/null
+++ b/app/services/domains/arxiv/gateway.py
@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import logging
+import re
+from typing import TYPE_CHECKING, Protocol
+import unicodedata
+
+from app.services.domains.arxiv.client import ArxivClient
+from app.services.domains.arxiv.errors import ArxivRateLimitError
+from app.services.domains.arxiv.types import ArxivFeed
+from app.settings import settings
+
+if TYPE_CHECKING:
+    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+
+logger = logging.getLogger(__name__)
+
+_default_gateway: ArxivGateway | None = None
+_MOJIBAKE_HINT_RE = re.compile(r"[ÃÂâ]")
+_NON_ALNUM_RE = re.compile(r"[^\w\s]+", re.UNICODE)
+_WHITESPACE_RE = re.compile(r"\s+")
+
+
+class ArxivGateway(Protocol):
+    async def discover_arxiv_id_for_publication(
+        self,
+        *,
+        item: PublicationListItem | UnreadPublicationItem,
+        request_email: str | None = None,
+        timeout_seconds: float | None = None,
+        max_results: int | None = None,
+    ) -> str | None: ...
+
+
+def build_arxiv_query(title: str, author_surname: str | None) -> str | None:
+    parts: list[str] = []
+    if title:
+        clean_title = _normalize_query_title(title)
+        if clean_title:
+            parts.append(f'ti:"{clean_title}"')
+    if author_surname:
+        clean_author = _normalize_query_title(author_surname)
+        if clean_author:
+            parts.append(f'au:"{clean_author}"')
+    if not parts:
+        return None
+    return " AND ".join(parts)
+
+
+def _normalize_query_title(value: str) -> str:
+    repaired = _repair_mojibake(value.strip())
+    normalized = unicodedata.normalize("NFKC", repaired)
+    stripped = _NON_ALNUM_RE.sub(" ", _MOJIBAKE_HINT_RE.sub(" ", normalized))
+    return _WHITESPACE_RE.sub(" ", stripped).strip()
+
+
+def _repair_mojibake(value: str) -> str:
+    if not value or not _MOJIBAKE_HINT_RE.search(value):
+        return value
+    try:
+        repaired = value.encode("latin1").decode("utf-8")
+    except UnicodeError:
+        return value
+    return repaired if _mojibake_score(repaired) < _mojibake_score(value) else value
+
+
+def _mojibake_score(value: str) -> int:
+    return len(_MOJIBAKE_HINT_RE.findall(value))
+
+
+def get_arxiv_gateway() -> ArxivGateway:
+    global _default_gateway
+    if _default_gateway is None:
+        _default_gateway = HttpArxivGateway()
+    return _default_gateway
+
+
+def set_arxiv_gateway(gateway: ArxivGateway | None) -> ArxivGateway | None:
+    global _default_gateway
+    previous = _default_gateway
+    _default_gateway = gateway
+    return previous
+
+
+class HttpArxivGateway:
+    def __init__(self, *, client: ArxivClient | None = None) -> None:
+        self._client = client or ArxivClient()
+
+    async def discover_arxiv_id_for_publication(
+        self,
+        *,
+        item: PublicationListItem | UnreadPublicationItem,
+        request_email: str | None = None,
+        timeout_seconds: float | None = None,
+        max_results: int | None = None,
+    ) -> str | None:
+        if not settings.arxiv_enabled:
+            return None
+        query = _query_for_item(item)
+        if query is None:
+            return None
+
+        try:
+            result = await self._client.search(
+                query=query,
+                start=0,
+                request_email=request_email,
+                timeout_seconds=timeout_seconds,
+                max_results=max_results,
+            )
+            return _first_discovered_id(result)
+        except ArxivRateLimitError:
+            raise
+        except Exception as exc:
+            logger.debug("arxiv.query_failed", extra={"event": "arxiv.query_failed", "error": str(exc)})
+            return None
+
+
+def _query_for_item(item: PublicationListItem | UnreadPublicationItem) -> str | None:
+    title = (item.title or "").strip()
+    if not title:
+        return None
+    author_surname = _author_surname(item.scholar_label)
+    return build_arxiv_query(title, author_surname)
+
+
+def _author_surname(scholar_label: str | None) -> str | None:
+    if not scholar_label:
+        return None
+    tokens = [token for token in scholar_label.strip().split() if token]
+    if not tokens:
+        return None
+    return tokens[-1].lower()
+
+
+def _first_discovered_id(result: ArxivFeed) -> str | None:
+    for entry in result.entries:
+        if entry.arxiv_id:
+            logger.debug("arxiv.id_discovered", extra={"event": "arxiv.id_discovered", "arxiv_id": entry.arxiv_id})
+            return entry.arxiv_id
+    return None
diff --git a/app/services/domains/arxiv/guards.py b/app/services/domains/arxiv/guards.py
new file mode 100644
index 0000000..9f7a35f
--- /dev/null
+++ b/app/services/domains/arxiv/guards.py
@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from app.services.domains.arxiv.constants import (
+    ARXIV_STRONG_IDENTIFIER_CONFIDENCE,
+    ARXIV_TITLE_MIN_ALPHA_TOKENS,
+    ARXIV_TITLE_MIN_TOKENS,
+    ARXIV_TITLE_TOKEN_MIN_LENGTH,
+)
+from app.services.domains.doi.normalize import normalize_doi
+from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
+
+if TYPE_CHECKING:
+    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+
+_TITLE_TOKEN_RE = re.compile(r"[a-z0-9]+")
+
+
+def arxiv_skip_reason_for_item(
+    *,
+    item: PublicationListItem | UnreadPublicationItem,
+    has_strong_doi: bool = False,
+    has_existing_arxiv: bool = False,
+) -> str | None:
+    if has_existing_arxiv or _has_arxiv_identifier_evidence(item):
+        return "arxiv_identifier_present"
+    if has_strong_doi or _has_strong_doi_evidence(item):
+        return "strong_doi_present"
+    if not _title_passes_quality_guard(item.title):
+        return "title_quality_below_threshold"
+    return None
+
+
+def _has_arxiv_identifier_evidence(item: PublicationListItem | UnreadPublicationItem) -> bool:
+    if _display_identifier_matches(item, expected_kind="arxiv"):
+        return True
+    return _has_normalized_identifier(item, normalizer=normalize_arxiv_id)
+
+
+def _has_strong_doi_evidence(item: PublicationListItem | UnreadPublicationItem) -> bool:
+    if _display_identifier_matches(item, expected_kind="doi"):
+        return True
+    return _has_normalized_identifier(item, normalizer=normalize_doi)
+
+
+def _display_identifier_matches(
+    item: PublicationListItem | UnreadPublicationItem,
+    *,
+    expected_kind: str,
+) -> bool:
+    display = getattr(item, "display_identifier", None)
+    if display is None:
+        return False
+    if str(display.kind).lower() != expected_kind:
+        return False
+    return float(display.confidence_score) >= ARXIV_STRONG_IDENTIFIER_CONFIDENCE
+
+
+def _has_normalized_identifier(
+    item: PublicationListItem | UnreadPublicationItem,
+    *,
+    normalizer,
+) -> bool:
+    if normalizer(item.pub_url):
+        return True
+    return normalizer(item.pdf_url) is not None
+
+
+def _title_passes_quality_guard(title: str | None) -> bool:
+    tokens = _normalized_tokens(title or "")
+    if len(tokens) < ARXIV_TITLE_MIN_TOKENS:
+        return False
+    alpha_tokens = [token for token in tokens if _is_alpha_token(token)]
+    return len(alpha_tokens) >= ARXIV_TITLE_MIN_ALPHA_TOKENS
+
+
+def _normalized_tokens(value: str) -> list[str]:
+    return [token for token in _TITLE_TOKEN_RE.findall(value.lower()) if token]
+
+
+def _is_alpha_token(token: str) -> bool:
+    if len(token) < ARXIV_TITLE_TOKEN_MIN_LENGTH:
+        return False
+    return any(char.isalpha() for char in token)
diff --git a/app/services/domains/arxiv/parser.py b/app/services/domains/arxiv/parser.py
new file mode 100644
index 0000000..bc1d7ee
--- /dev/null
+++ b/app/services/domains/arxiv/parser.py
@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+
+from app.services.domains.arxiv.errors import ArxivParseError
+from app.services.domains.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
+from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
+
+_NAMESPACES = {
+    "atom": "http://www.w3.org/2005/Atom",
+    "opensearch": "http://a9.com/-/spec/opensearch/1.1/",
+    "arxiv": "http://arxiv.org/schemas/atom",
+}
+
+
+def parse_arxiv_feed(payload: str) -> ArxivFeed:
+    root = _parse_xml_root(payload)
+    opensearch = ArxivOpenSearchMeta(
+        total_results=_opensearch_int(root, "opensearch:totalResults"),
+        start_index=_opensearch_int(root, "opensearch:startIndex"),
+        items_per_page=_opensearch_int(root, "opensearch:itemsPerPage"),
+    )
+    entries = [_parse_entry(entry_elem) for entry_elem in root.findall("atom:entry", _NAMESPACES)]
+    return ArxivFeed(entries=entries, opensearch=opensearch)
+
+
+def _parse_xml_root(payload: str) -> ET.Element:
+    try:
+        return ET.fromstring(payload)
+    except ET.ParseError as exc:
+        raise ArxivParseError(f"Invalid arXiv XML payload: {exc}") from exc
+
+
+def _opensearch_int(root: ET.Element, path: str) -> int:
+    text = _optional_text(root, path)
+    if text is None:
+        return 0
+    try:
+        return int(text.strip())
+    except ValueError as exc:
+        raise ArxivParseError(f"Invalid integer value at {path}: {text!r}") from exc
+
+
+def _parse_entry(entry_elem: ET.Element) -> ArxivEntry:
+    entry_id_url = _required_text(entry_elem, "atom:id").strip()
+    arxiv_id = normalize_arxiv_id(entry_id_url)
+    title = _required_text(entry_elem, "atom:title").strip()
+    summary = (_optional_text(entry_elem, "atom:summary") or "").strip()
+    published = _optional_text(entry_elem, "atom:published")
+    updated = _optional_text(entry_elem, "atom:updated")
+    return ArxivEntry(
+        entry_id_url=entry_id_url,
+        arxiv_id=arxiv_id,
+        title=title,
+        summary=summary,
+        published=published,
+        updated=updated,
+        authors=_authors(entry_elem),
+        links=_links(entry_elem),
+        categories=_categories(entry_elem),
+        primary_category=_primary_category(entry_elem),
+    )
+
+
+def _required_text(elem: ET.Element, path: str) -> str:
+    text = _optional_text(elem, path)
+    if text is None or not text.strip():
+        raise ArxivParseError(f"Missing required field: {path}")
+    return text
+
+
+def _optional_text(elem: ET.Element, path: str) -> str | None:
+    node = elem.find(path, _NAMESPACES)
+    if node is None or node.text is None:
+        return None
+    return str(node.text)
+
+
+def _authors(entry_elem: ET.Element) -> list[str]:
+    authors: list[str] = []
+    for author in entry_elem.findall("atom:author", _NAMESPACES):
+        name = _optional_text(author, "atom:name")
+        if name:
+            authors.append(name.strip())
+    return authors
+
+
+def _links(entry_elem: ET.Element) -> list[str]:
+    values: list[str] = []
+    for link in entry_elem.findall("atom:link", _NAMESPACES):
+        href = str(link.attrib.get("href") or "").strip()
+        if href:
+            values.append(href)
+    return values
+
+
+def _categories(entry_elem: ET.Element) -> list[str]:
+    values: list[str] = []
+    for cat in entry_elem.findall("atom:category", _NAMESPACES):
+        term = str(cat.attrib.get("term") or "").strip()
+        if term:
+            values.append(term)
+    return values
+
+
+def _primary_category(entry_elem: ET.Element) -> str | None:
+    node = entry_elem.find("arxiv:primary_category", _NAMESPACES)
+    if node is None:
+        return None
+    value = str(node.attrib.get("term") or "").strip()
+    return value or None
diff --git a/app/services/domains/arxiv/rate_limit.py b/app/services/domains/arxiv/rate_limit.py
new file mode 100644
index 0000000..6506035
--- /dev/null
+++ b/app/services/domains/arxiv/rate_limit.py
@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+import logging
+
+import httpx
+from sqlalchemy import select, text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import ArxivRuntimeState
+from app.db.session import get_session_factory
+from app.services.domains.arxiv.constants import (
+    ARXIV_RATE_LIMIT_LOCK_KEY,
+    ARXIV_RATE_LIMIT_LOCK_NAMESPACE,
+    ARXIV_RUNTIME_STATE_KEY,
+    ARXIV_SOURCE_PATH_UNKNOWN,
+)
+from app.services.domains.arxiv.errors import ArxivRateLimitError
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class ArxivCooldownStatus:
+    is_active: bool
+    remaining_seconds: float
+    cooldown_until: datetime | None
+
+
+async def run_with_global_arxiv_limit(
+    *,
+    fetch: Callable[[], Awaitable[httpx.Response]],
+    source_path: str = ARXIV_SOURCE_PATH_UNKNOWN,
+) -> httpx.Response:
+    response, hit_rate_limit = await _run_serialized_fetch(
+        fetch=fetch,
+        source_path=source_path,
+    )
+    if hit_rate_limit:
+        raise ArxivRateLimitError("arXiv rate limit hit (429) — stopping batch")
+    return response
+
+
+async def get_arxiv_cooldown_status(*, now_utc: datetime | None = None) -> ArxivCooldownStatus:
+    timestamp = _normalize_datetime(now_utc) or datetime.now(timezone.utc)
+    session_factory = get_session_factory()
+    async with session_factory() as db_session:
+        result = await db_session.execute(
+            select(ArxivRuntimeState.cooldown_until).where(
+                ArxivRuntimeState.state_key == ARXIV_RUNTIME_STATE_KEY
+            )
+        )
+    cooldown_until = _normalize_datetime(result.scalar_one_or_none())
+    remaining_seconds = _cooldown_remaining_seconds(cooldown_until, now_utc=timestamp)
+    return ArxivCooldownStatus(
+        is_active=remaining_seconds > 0.0,
+        remaining_seconds=float(remaining_seconds),
+        cooldown_until=cooldown_until,
+    )
+
+
+async def _run_serialized_fetch(
+    *,
+    fetch: Callable[[], Awaitable[httpx.Response]],
+    source_path: str,
+) -> tuple[httpx.Response, bool]:
+    session_factory = get_session_factory()
+    async with session_factory() as db_session:
+        async with db_session.begin():
+            await _acquire_arxiv_lock(db_session)
+            runtime_state = await _load_runtime_state_for_update(db_session)
+            wait_seconds = await _wait_for_allowed_slot_or_raise(
+                runtime_state,
+                source_path=source_path,
+            )
+            response = await fetch()
+            hit_rate_limit = _record_post_response_state(
+                runtime_state,
+                response_status=int(response.status_code),
+                source_path=source_path,
+            )
+            _log_request_completed(
+                response_status=int(response.status_code),
+                wait_seconds=wait_seconds,
+                source_path=source_path,
+                cooldown_remaining_seconds=_cooldown_remaining_seconds(
+                    runtime_state.cooldown_until,
+                    now_utc=datetime.now(timezone.utc),
+                ),
+            )
+            return response, hit_rate_limit
+
+
+async def _acquire_arxiv_lock(db_session: AsyncSession) -> None:
+    await db_session.execute(
+        text("SELECT pg_advisory_xact_lock(:namespace, :lock_key)"),
+        {
+            "namespace": ARXIV_RATE_LIMIT_LOCK_NAMESPACE,
+            "lock_key": ARXIV_RATE_LIMIT_LOCK_KEY,
+        },
+    )
+
+
+async def _load_runtime_state_for_update(db_session: AsyncSession) -> ArxivRuntimeState:
+    result = await db_session.execute(
+        select(ArxivRuntimeState)
+        .where(ArxivRuntimeState.state_key == ARXIV_RUNTIME_STATE_KEY)
+        .with_for_update()
+    )
+    state = result.scalar_one_or_none()
+    if state is not None:
+        return state
+    state = ArxivRuntimeState(state_key=ARXIV_RUNTIME_STATE_KEY)
+    db_session.add(state)
+    await db_session.flush()
+    return state
+
+
+async def _wait_for_allowed_slot_or_raise(
+    runtime_state: ArxivRuntimeState,
+    *,
+    source_path: str,
+) -> float:
+    now_utc = datetime.now(timezone.utc)
+    cooldown_seconds = _cooldown_remaining_seconds(runtime_state.cooldown_until, now_utc=now_utc)
+    if cooldown_seconds > 0:
+        _log_request_scheduled(
+            wait_seconds=0.0,
+            source_path=source_path,
+            cooldown_remaining_seconds=cooldown_seconds,
+        )
+        raise ArxivRateLimitError(f"arXiv global cooldown active ({cooldown_seconds:.0f}s remaining)")
+    wait_seconds = _next_allowed_wait_seconds(runtime_state.next_allowed_at, now_utc=now_utc)
+    _log_request_scheduled(
+        wait_seconds=wait_seconds,
+        source_path=source_path,
+        cooldown_remaining_seconds=0.0,
+    )
+    if wait_seconds > 0:
+        await asyncio.sleep(wait_seconds)
+    return wait_seconds
+
+
+def _record_post_response_state(
+    runtime_state: ArxivRuntimeState,
+    *,
+    response_status: int,
+    source_path: str,
+) -> bool:
+    now_utc = datetime.now(timezone.utc)
+    runtime_state.next_allowed_at = now_utc + timedelta(seconds=_min_interval_seconds())
+    if response_status == 429:
+        cooldown_seconds = _cooldown_seconds()
+        runtime_state.cooldown_until = now_utc + timedelta(seconds=cooldown_seconds)
+        _log_cooldown_activated(
+            source_path=source_path,
+            cooldown_remaining_seconds=cooldown_seconds,
+        )
+        return True
+    if _cooldown_remaining_seconds(runtime_state.cooldown_until, now_utc=now_utc) <= 0:
+        runtime_state.cooldown_until = None
+    return False
+
+
+def _cooldown_remaining_seconds(cooldown_until: datetime | None, *, now_utc: datetime) -> float:
+    bounded = _normalize_datetime(cooldown_until)
+    if bounded is None:
+        return 0.0
+    return max((bounded - now_utc).total_seconds(), 0.0)
+
+
+def _next_allowed_wait_seconds(next_allowed_at: datetime | None, *, now_utc: datetime) -> float:
+    bounded = _normalize_datetime(next_allowed_at)
+    if bounded is None:
+        return 0.0
+    return max((bounded - now_utc).total_seconds(), 0.0)
+
+
+def _normalize_datetime(value: datetime | None) -> datetime | None:
+    if value is None:
+        return None
+    if value.tzinfo is None:
+        return value.replace(tzinfo=timezone.utc)
+    return value
+
+
+def _min_interval_seconds() -> float:
+    return max(float(settings.arxiv_min_interval_seconds), 0.0)
+
+
+def _cooldown_seconds() -> float:
+    return max(float(settings.arxiv_rate_limit_cooldown_seconds), 0.0)
+
+
+def _log_request_scheduled(
+    *,
+    wait_seconds: float,
+    source_path: str,
+    cooldown_remaining_seconds: float,
+) -> None:
+    logger.info(
+        "arxiv.request_scheduled",
+        extra={
+            "event": "arxiv.request_scheduled",
+            "wait_seconds": float(wait_seconds),
+            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
+            "source_path": source_path,
+        },
+    )
+
+
+def _log_request_completed(
+    *,
+    response_status: int,
+    wait_seconds: float,
+    source_path: str,
+    cooldown_remaining_seconds: float,
+) -> None:
+    logger.info(
+        "arxiv.request_completed",
+        extra={
+            "event": "arxiv.request_completed",
+            "status_code": int(response_status),
+            "wait_seconds": float(wait_seconds),
+            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
+            "source_path": source_path,
+        },
+    )
+
+
+def _log_cooldown_activated(
+    *,
+    source_path: str,
+    cooldown_remaining_seconds: float,
+) -> None:
+    logger.warning(
+        "arxiv.cooldown_activated",
+        extra={
+            "event": "arxiv.cooldown_activated",
+            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
+            "source_path": source_path,
+        },
+    )
diff --git a/app/services/domains/arxiv/types.py b/app/services/domains/arxiv/types.py
new file mode 100644
index 0000000..574ed93
--- /dev/null
+++ b/app/services/domains/arxiv/types.py
@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+ArxivSortBy = Literal["relevance", "lastUpdatedDate", "submittedDate"]
+ArxivSortOrder = Literal["ascending", "descending"]
+
+
+@dataclass(frozen=True)
+class ArxivOpenSearchMeta:
+    total_results: int = 0
+    start_index: int = 0
+    items_per_page: int = 0
+
+
+@dataclass(frozen=True)
+class ArxivEntry:
+    entry_id_url: str
+    arxiv_id: str | None
+    title: str
+    summary: str
+    published: str | None
+    updated: str | None
+    authors: list[str] = field(default_factory=list)
+    links: list[str] = field(default_factory=list)
+    categories: list[str] = field(default_factory=list)
+    primary_category: str | None = None
+
+
+@dataclass(frozen=True)
+class ArxivFeed:
+    entries: list[ArxivEntry] = field(default_factory=list)
+    opensearch: ArxivOpenSearchMeta = field(default_factory=ArxivOpenSearchMeta)
diff --git a/app/services/domains/dbops/__init__.py b/app/services/domains/dbops/__init__.py
index f5b02e4..cdc5177 100644
--- a/app/services/domains/dbops/__init__.py
+++ b/app/services/domains/dbops/__init__.py
@@ -1,5 +1,13 @@
 from app.services.domains.dbops.application import run_publication_link_repair
+from app.services.domains.dbops.near_duplicate_repair import (
+    run_publication_near_duplicate_repair,
+)
 from app.services.domains.dbops.integrity import collect_integrity_report
 from app.services.domains.dbops.query import list_repair_jobs
 
-__all__ = ["collect_integrity_report", "list_repair_jobs", "run_publication_link_repair"]
+__all__ = [
+    "collect_integrity_report",
+    "list_repair_jobs",
+    "run_publication_link_repair",
+    "run_publication_near_duplicate_repair",
+]
diff --git a/app/services/domains/dbops/near_duplicate_repair.py b/app/services/domains/dbops/near_duplicate_repair.py
new file mode 100644
index 0000000..ab86c70
--- /dev/null
+++ b/app/services/domains/dbops/near_duplicate_repair.py
@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import DataRepairJob
+from app.services.domains.publications import dedup as dedup_service
+
+REPAIR_STATUS_PLANNED = "planned"
+REPAIR_STATUS_RUNNING = "running"
+REPAIR_STATUS_COMPLETED = "completed"
+REPAIR_STATUS_FAILED = "failed"
+NEAR_DUP_JOB_NAME = "repair_publication_near_duplicates"
+NEAR_DUP_DEFAULT_MAX_CLUSTERS = 25
+
+
+def _utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _normalized_cluster_keys(values: list[str] | None) -> list[str]:
+    if not values:
+        return []
+    seen: set[str] = set()
+    normalized: list[str] = []
+    for value in values:
+        key = str(value or "").strip().lower()
+        if not key or key in seen:
+            continue
+        seen.add(key)
+        normalized.append(key)
+    return normalized
+
+
+def _normalized_max_clusters(value: int) -> int:
+    return max(1, min(int(value), 200))
+
+
+def _scope_payload(
+    *,
+    similarity_threshold: float,
+    min_shared_tokens: int,
+    max_year_delta: int,
+    max_clusters: int,
+    selected_cluster_keys: list[str],
+) -> dict[str, Any]:
+    return {
+        "similarity_threshold": float(similarity_threshold),
+        "min_shared_tokens": int(min_shared_tokens),
+        "max_year_delta": int(max_year_delta),
+        "max_clusters": int(max_clusters),
+        "selected_cluster_keys": selected_cluster_keys,
+    }
+
+
+async def _create_job(
+    db_session: AsyncSession,
+    *,
+    requested_by: str | None,
+    scope: dict[str, Any],
+    dry_run: bool,
+) -> DataRepairJob:
+    job = DataRepairJob(
+        job_name=NEAR_DUP_JOB_NAME,
+        requested_by=(requested_by or "").strip() or None,
+        scope=scope,
+        dry_run=bool(dry_run),
+        status=REPAIR_STATUS_PLANNED,
+        summary={},
+    )
+    db_session.add(job)
+    await db_session.flush()
+    job.status = REPAIR_STATUS_RUNNING
+    job.started_at = _utcnow()
+    return job
+
+
+def _selected_clusters(
+    *,
+    clusters: list[dedup_service.NearDuplicateCluster],
+    selected_cluster_keys: list[str],
+) -> tuple[list[dedup_service.NearDuplicateCluster], list[str]]:
+    if not selected_cluster_keys:
+        return [], []
+    by_key = {cluster.cluster_key.lower(): cluster for cluster in clusters}
+    selected: list[dedup_service.NearDuplicateCluster] = []
+    missing: list[str] = []
+    for key in selected_cluster_keys:
+        cluster = by_key.get(key)
+        if cluster is None:
+            missing.append(key)
+            continue
+        selected.append(cluster)
+    return selected, missing
+
+
+async def _merge_selected_clusters(
+    db_session: AsyncSession,
+    *,
+    selected_clusters: list[dedup_service.NearDuplicateCluster],
+) -> int:
+    merged_publications = 0
+    for cluster in selected_clusters:
+        merged_publications += await dedup_service.merge_near_duplicate_cluster(
+            db_session,
+            cluster=cluster,
+        )
+    return merged_publications
+
+
+def _clusters_payload(
+    *,
+    clusters: list[dedup_service.NearDuplicateCluster],
+    max_clusters: int,
+) -> list[dict[str, object]]:
+    preview = clusters[:max_clusters]
+    return [dedup_service.near_duplicate_cluster_payload(cluster) for cluster in preview]
+
+
+def _summary_payload(
+    *,
+    dry_run: bool,
+    cluster_count: int,
+    selected_count: int,
+    missing_count: int,
+    merged_publications: int,
+    max_clusters: int,
+) -> dict[str, Any]:
+    return {
+        "dry_run": bool(dry_run),
+        "candidate_cluster_count": int(cluster_count),
+        "selected_cluster_count": int(selected_count),
+        "missing_selected_cluster_count": int(missing_count),
+        "merged_publications": int(merged_publications),
+        "preview_cluster_count": int(min(cluster_count, max_clusters)),
+    }
+
+
+async def _complete_job(
+    db_session: AsyncSession,
+    *,
+    job: DataRepairJob,
+    scope: dict[str, Any],
+    summary: dict[str, Any],
+    clusters: list[dict[str, object]],
+) -> dict[str, Any]:
+    job.status = REPAIR_STATUS_COMPLETED
+    job.finished_at = _utcnow()
+    job.summary = summary
+    await db_session.commit()
+    return {
+        "job_id": int(job.id),
+        "status": job.status,
+        "scope": scope,
+        "summary": summary,
+        "clusters": clusters,
+    }
+
+
+async def _fail_job(db_session: AsyncSession, *, job: DataRepairJob, error: Exception) -> None:
+    await db_session.rollback()
+    job.status = REPAIR_STATUS_FAILED
+    job.error_text = str(error)
+    job.finished_at = _utcnow()
+    db_session.add(job)
+    await db_session.commit()
+
+
+async def run_publication_near_duplicate_repair(
+    db_session: AsyncSession,
+    *,
+    dry_run: bool = True,
+    similarity_threshold: float = dedup_service.NEAR_DUP_DEFAULT_SIMILARITY_THRESHOLD,
+    min_shared_tokens: int = dedup_service.NEAR_DUP_DEFAULT_MIN_SHARED_TOKENS,
+    max_year_delta: int = dedup_service.NEAR_DUP_DEFAULT_MAX_YEAR_DELTA,
+    max_clusters: int = NEAR_DUP_DEFAULT_MAX_CLUSTERS,
+    selected_cluster_keys: list[str] | None = None,
+    requested_by: str | None = None,
+) -> dict[str, Any]:
+    normalized_keys = _normalized_cluster_keys(selected_cluster_keys)
+    bounded_clusters = _normalized_max_clusters(max_clusters)
+    scope = _scope_payload(
+        similarity_threshold=similarity_threshold,
+        min_shared_tokens=min_shared_tokens,
+        max_year_delta=max_year_delta,
+        max_clusters=bounded_clusters,
+        selected_cluster_keys=normalized_keys,
+    )
+    job = await _create_job(db_session, requested_by=requested_by, scope=scope, dry_run=dry_run)
+    try:
+        clusters = await dedup_service.find_near_duplicate_clusters(
+            db_session,
+            similarity_threshold=similarity_threshold,
+            min_shared_tokens=min_shared_tokens,
+            max_year_delta=max_year_delta,
+        )
+        selected, missing = _selected_clusters(clusters=clusters, selected_cluster_keys=normalized_keys)
+        merged_publications = 0
+        if not dry_run:
+            if not selected:
+                raise ValueError("No selected near-duplicate clusters matched current data.")
+            merged_publications = await _merge_selected_clusters(db_session, selected_clusters=selected)
+        preview = _clusters_payload(clusters=clusters, max_clusters=bounded_clusters)
+        summary = _summary_payload(
+            dry_run=dry_run,
+            cluster_count=len(clusters),
+            selected_count=len(selected),
+            missing_count=len(missing),
+            merged_publications=merged_publications,
+            max_clusters=bounded_clusters,
+        )
+        return await _complete_job(
+            db_session,
+            job=job,
+            scope=scope,
+            summary=summary,
+            clusters=preview,
+        )
+    except Exception as exc:
+        await _fail_job(db_session, job=job, error=exc)
+        raise
diff --git a/app/services/domains/ingestion/application.py b/app/services/domains/ingestion/application.py
index a313a6f..cedd165 100644
--- a/app/services/domains/ingestion/application.py
+++ b/app/services/domains/ingestion/application.py
@@ -30,6 +30,7 @@ from app.services.domains.ingestion.constants import (
     RESUMABLE_PARTIAL_REASONS,
     RUN_LOCK_NAMESPACE,
 )
+from app.services.domains.arxiv.errors import ArxivRateLimitError
 from app.services.domains.doi.normalize import first_doi_from_texts
 from app.services.domains.publication_identifiers import application as identifier_service
 from app.services.domains.ingestion.fingerprints import (
@@ -830,17 +831,79 @@ class ScholarIngestionService:
             result_entry=result_entry,
         )
 
+    @staticmethod
+    def _result_counters(result_entry: dict[str, Any]) -> tuple[int, int, int]:
+        outcome = str(result_entry.get("outcome", "")).strip().lower()
+        if outcome == "success":
+            return 1, 0, 0
+        if outcome == "partial":
+            return 1, 0, 1
+        if outcome == "failed":
+            return 0, 1, 0
+        raise RuntimeError(f"Unexpected scholar outcome label: {outcome!r}")
+
+    @staticmethod
+    def _find_scholar_result_index(
+        *,
+        scholar_results: list[dict[str, Any]],
+        scholar_profile_id: int,
+    ) -> int | None:
+        for index, result_entry in enumerate(scholar_results):
+            current_scholar_id = _int_or_default(result_entry.get("scholar_profile_id"), 0)
+            if current_scholar_id == scholar_profile_id:
+                return index
+        return None
+
+    @staticmethod
+    def _adjust_progress_counts(
+        *,
+        progress: RunProgress,
+        succeeded_delta: int,
+        failed_delta: int,
+        partial_delta: int,
+    ) -> None:
+        progress.succeeded_count += succeeded_delta
+        progress.failed_count += failed_delta
+        progress.partial_count += partial_delta
+        if progress.succeeded_count < 0 or progress.failed_count < 0 or progress.partial_count < 0:
+            raise RuntimeError("RunProgress counters entered invalid negative state.")
+
     @staticmethod
     def _apply_outcome_to_progress(
         *,
         progress: RunProgress,
-        run: CrawlRun,
         outcome: ScholarProcessingOutcome,
     ) -> None:
-        progress.succeeded_count += outcome.succeeded_count_delta
-        progress.failed_count += outcome.failed_count_delta
-        progress.partial_count += outcome.partial_count_delta
-        progress.scholar_results.append(outcome.result_entry)
+        scholar_profile_id = _int_or_default(outcome.result_entry.get("scholar_profile_id"), 0)
+        if scholar_profile_id <= 0:
+            raise RuntimeError("Scholar outcome missing valid scholar_profile_id.")
+        prior_index = ScholarIngestionService._find_scholar_result_index(
+            scholar_results=progress.scholar_results,
+            scholar_profile_id=scholar_profile_id,
+        )
+        next_succeeded, next_failed, next_partial = ScholarIngestionService._result_counters(
+            outcome.result_entry
+        )
+        if prior_index is None:
+            progress.scholar_results.append(outcome.result_entry)
+            ScholarIngestionService._adjust_progress_counts(
+                progress=progress,
+                succeeded_delta=next_succeeded,
+                failed_delta=next_failed,
+                partial_delta=next_partial,
+            )
+            return
+        previous_entry = progress.scholar_results[prior_index]
+        prev_succeeded, prev_failed, prev_partial = ScholarIngestionService._result_counters(
+            previous_entry
+        )
+        progress.scholar_results[prior_index] = outcome.result_entry
+        ScholarIngestionService._adjust_progress_counts(
+            progress=progress,
+            succeeded_delta=next_succeeded - prev_succeeded,
+            failed_delta=next_failed - prev_failed,
+            partial_delta=next_partial - prev_partial,
+        )
 
     def _unexpected_scholar_exception_outcome(
         self,
@@ -1327,7 +1390,7 @@ class ScholarIngestionService:
                 auto_queue_continuations=False,
                 queue_delay_seconds=queue_delay_seconds,
             )
-            self._apply_outcome_to_progress(progress=progress, run=run, outcome=outcome)
+            self._apply_outcome_to_progress(progress=progress, outcome=outcome)
             # Track where to resume from for the deep pass
             resume_cstart = outcome.result_entry.get("continuation_cstart")
             if resume_cstart is not None and int(resume_cstart) > start_cstart:
@@ -1366,7 +1429,7 @@ class ScholarIngestionService:
                 auto_queue_continuations=auto_queue_continuations,
                 queue_delay_seconds=queue_delay_seconds,
             )
-            self._apply_outcome_to_progress(progress=progress, run=run, outcome=outcome)
+            self._apply_outcome_to_progress(progress=progress, outcome=outcome)
         return progress
 
     def _complete_run_for_user(
@@ -2448,6 +2511,7 @@ class ScholarIngestionService:
         resolved_key = openalex_api_key or settings.openalex_api_key
         client = OpenAlexClient(api_key=resolved_key, mailto=settings.crossref_api_mailto)
         batch_size = 25
+        arxiv_lookup_allowed = True
 
         for i in range(0, len(publications), batch_size):
             if await self._run_is_canceled(db_session, run_id=run_id):
@@ -2494,12 +2558,11 @@ class ScholarIngestionService:
                     return
 
                 p.openalex_last_attempt_at = now
-                
-                # Perform identifier discovery (moved from synchronous ingest loop)
-                await identifier_service.discover_and_sync_identifiers_for_publication(
+                arxiv_lookup_allowed = await self._discover_identifiers_for_enrichment(
                     db_session,
                     publication=p,
-                    scholar_label=p.author_text or "",
+                    run_id=run_id,
+                    allow_arxiv_lookup=arxiv_lookup_allowed,
                 )
 
                 match = find_best_match(
@@ -2529,6 +2592,86 @@ class ScholarIngestionService:
                 },
             )
 
+    async def _discover_identifiers_for_enrichment(
+        self,
+        db_session: AsyncSession,
+        *,
+        publication: Publication,
+        run_id: int,
+        allow_arxiv_lookup: bool,
+    ) -> bool:
+        if not allow_arxiv_lookup:
+            await identifier_service.sync_identifiers_for_publication_fields(
+                db_session,
+                publication=publication,
+            )
+            await self._publish_identifier_update_event(
+                db_session,
+                run_id=run_id,
+                publication_id=int(publication.id),
+            )
+            return False
+        try:
+            await identifier_service.discover_and_sync_identifiers_for_publication(
+                db_session,
+                publication=publication,
+                scholar_label=publication.author_text or "",
+            )
+            await self._publish_identifier_update_event(
+                db_session,
+                run_id=run_id,
+                publication_id=int(publication.id),
+            )
+            return True
+        except ArxivRateLimitError:
+            logger.warning(
+                "ingestion.arxiv_rate_limited",
+                extra={
+                    "event": "ingestion.arxiv_rate_limited",
+                    "run_id": run_id,
+                    "publication_id": int(publication.id),
+                    "detail": "arXiv temporarily disabled for remaining enrichment pass",
+                },
+            )
+            await identifier_service.sync_identifiers_for_publication_fields(
+                db_session,
+                publication=publication,
+            )
+            await self._publish_identifier_update_event(
+                db_session,
+                run_id=run_id,
+                publication_id=int(publication.id),
+            )
+            return False
+
+    async def _publish_identifier_update_event(
+        self,
+        db_session: AsyncSession,
+        *,
+        run_id: int,
+        publication_id: int,
+    ) -> None:
+        display = await identifier_service.display_identifier_for_publication_id(
+            db_session,
+            publication_id=publication_id,
+        )
+        if display is None:
+            return
+        await run_events.publish(
+            run_id=run_id,
+            event_type="identifier_updated",
+            data={
+                "publication_id": int(publication_id),
+                "display_identifier": {
+                    "kind": display.kind,
+                    "value": display.value,
+                    "label": display.label,
+                    "url": display.url,
+                    "confidence_score": float(display.confidence_score),
+                },
+            },
+        )
+
     async def _enrich_publications_with_openalex(
         self,
         scholar: ScholarProfile,
diff --git a/app/services/domains/ingestion/fingerprints.py b/app/services/domains/ingestion/fingerprints.py
index 30745b0..9f67f0f 100644
--- a/app/services/domains/ingestion/fingerprints.py
+++ b/app/services/domains/ingestion/fingerprints.py
@@ -4,6 +4,7 @@ import hashlib
 import json
 import re
 from typing import Any
+import unicodedata
 from urllib.parse import urljoin
 
 from app.services.domains.ingestion.constants import (
@@ -24,37 +25,177 @@ _NOISE_PREPRINT_RE = re.compile(
     re.IGNORECASE,
 )
 _NOISE_TRAILING_YEAR_RE = re.compile(r"\s*[,(]\s*\d{4}\s*[),]?\s*$")
+_NOISE_TRAILING_MONTH_YEAR_RE = re.compile(
+    r"\s*[,(]\s*(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\.?\s+\d{4}\s*[),]?\s*$",
+    re.IGNORECASE,
+)
+_NOISE_TRAILING_PUBLICATION_TYPE_RE = re.compile(
+    r"[,.\s]+(?:conference\s+paper|journal\s+article)\s*$",
+    re.IGNORECASE,
+)
+_NOISE_IN_PROCEEDINGS_SUFFIX_RE = re.compile(r"\s+in:\s+proceedings\b.*$", re.IGNORECASE)
 # Strips ". Capitalised sentence" appended as venue: ". Comput. Sci…", ". Journal of…"
 _NOISE_VENUE_SENTENCE_RE = re.compile(r"(?<=\w{3})\.\s+[A-Z][a-z].*$")
+_MOJIBAKE_HINT_RE = re.compile(r"[ÃÂâ]")
+_MOJIBAKE_CHAR_RE = re.compile(r"[Ó”€™]")
+_METADATA_ORDINAL_RE = re.compile(r"^\d+(st|nd|rd|th)$")
+_NOISE_LEADING_DATE_PREFIX_RE = re.compile(
+    r"^(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\s+\d{1,2}(?:\s*[-–]\s*\d{1,2})?\)?[,\.\s:;-]+",
+    re.IGNORECASE,
+)
+_NOISE_LEADING_AUTHOR_FRAGMENT_RE = re.compile(r"^(?:and|&)\s+[a-z.\s]{1,40}:\s*", re.IGNORECASE)
+_METADATA_SEPARATORS = (" - ", " — ", ",", ";", ". ")
+_VENUE_HINT_TOKENS = {
+    "aaai",
+    "conference",
+    "conf",
+    "cvpr",
+    "eccv",
+    "iclr",
+    "icml",
+    "journal",
+    "nips",
+    "neurips",
+    "proceedings",
+    "proc",
+    "symposium",
+    "workshop",
+}
+_PUBLICATION_TYPE_TOKENS = {"conference", "paper", "journal", "article"}
+_MIN_METADATA_HINT_TOKENS = 2
+_MIN_METADATA_CONTEXT_TOKENS = 4
 
 _CANONICAL_DEDUP_THRESHOLD = 0.82
 
 
 def normalize_title(value: str) -> str:
-    lowered = value.lower()
+    lowered = _normalized_text(value).lower()
     return TITLE_ALNUM_RE.sub("", lowered)
 
 
 def canonical_title_for_dedup(title: str) -> str:
     """Strip Scholar-specific noise suffixes then normalize for dedup comparison."""
-    t = title.strip()
-    t = _NOISE_DOI_RE.sub("", t)
-    t = _NOISE_ARXIV_RE.sub("", t)
-    t = _NOISE_PREPRINT_RE.sub("", t)
-    t = _NOISE_TRAILING_YEAR_RE.sub("", t)
-    t = _NOISE_VENUE_SENTENCE_RE.sub("", t)
-    return normalize_title(t.strip())
+    return normalize_title(_canonical_title_text(title))
+
+
+def canonical_title_text_for_dedup(title: str) -> str:
+    """Noise-stripped lowercase title with spaces preserved for token-level matching."""
+    return _stripped_title_for_canonical(title)
+
+
+def canonical_title_tokens_for_dedup(title: str) -> set[str]:
+    """Word tokens of the noise-stripped title."""
+    return _canonical_title_tokens(title)
 
 
 def _stripped_title_for_canonical(title: str) -> str:
     """Apply noise-stripping and lowercase but PRESERVE spaces (for later tokenization)."""
-    t = title.strip()
+    t = _canonical_title_text(title)
+    return t.lower().strip()
+
+
+def _canonical_title_text(title: str) -> str:
+    t = _normalized_text(title)
+    t = _strip_noise_suffixes(t)
+    t = _strip_venue_metadata_suffixes(t)
+    return _NOISE_VENUE_SENTENCE_RE.sub("", t).strip()
+
+
+def _strip_noise_suffixes(value: str) -> str:
+    t = _strip_leading_noise_prefixes(value.strip())
     t = _NOISE_DOI_RE.sub("", t)
     t = _NOISE_ARXIV_RE.sub("", t)
     t = _NOISE_PREPRINT_RE.sub("", t)
     t = _NOISE_TRAILING_YEAR_RE.sub("", t)
-    t = _NOISE_VENUE_SENTENCE_RE.sub("", t)
-    return t.lower().strip()
+    t = _NOISE_TRAILING_MONTH_YEAR_RE.sub("", t)
+    t = _NOISE_TRAILING_PUBLICATION_TYPE_RE.sub("", t)
+    t = _NOISE_IN_PROCEEDINGS_SUFFIX_RE.sub("", t)
+    return t.strip()
+
+
+def _strip_venue_metadata_suffixes(value: str) -> str:
+    stripped = value.strip()
+    while True:
+        cut_index = _metadata_cut_index(stripped)
+        if cut_index is None:
+            return stripped
+        stripped = stripped[:cut_index].strip()
+
+
+def _metadata_cut_index(value: str) -> int | None:
+    candidates: list[int] = []
+    for candidate in _METADATA_SEPARATORS:
+        start = 0
+        while True:
+            index = value.find(candidate, start)
+            if index <= 0:
+                break
+            suffix = value[index + len(candidate) :].strip()
+            if suffix and _looks_like_venue_metadata(suffix):
+                candidates.append(index)
+            start = index + len(candidate)
+    if not candidates:
+        return None
+    return min(candidates)
+
+
+def _looks_like_venue_metadata(value: str) -> bool:
+    tokens = WORD_RE.findall(value.lower())
+    if len(tokens) < _MIN_METADATA_HINT_TOKENS:
+        return False
+    has_hint = any(_is_venue_hint_token(token) for token in tokens)
+    if not has_hint:
+        return False
+    has_year = any(_is_year_token(token) for token in tokens)
+    has_ordinal = any(_METADATA_ORDINAL_RE.match(token) for token in tokens)
+    publication_type_only = all(token in _PUBLICATION_TYPE_TOKENS for token in tokens)
+    return has_year or has_ordinal or publication_type_only or len(tokens) >= _MIN_METADATA_CONTEXT_TOKENS
+
+
+def _strip_leading_noise_prefixes(value: str) -> str:
+    stripped = value
+    while True:
+        next_value = _NOISE_LEADING_DATE_PREFIX_RE.sub("", stripped).strip()
+        next_value = _NOISE_LEADING_AUTHOR_FRAGMENT_RE.sub("", next_value).strip()
+        if next_value == stripped:
+            return stripped
+        stripped = next_value
+
+
+def _is_venue_hint_token(token: str) -> bool:
+    if token in _VENUE_HINT_TOKENS:
+        return True
+    return token.startswith("conf") or token.startswith("proceed")
+
+
+def _is_year_token(token: str) -> bool:
+    if len(token) != 4 or not token.isdigit():
+        return False
+    year = int(token)
+    return 1900 <= year <= 2100
+
+
+def _normalized_text(value: str) -> str:
+    repaired = _repair_mojibake(value.strip())
+    normalized = unicodedata.normalize("NFKC", repaired)
+    cleaned = _MOJIBAKE_CHAR_RE.sub(" ", normalized)
+    return SPACE_RE.sub(" ", cleaned).strip()
+
+
+def _repair_mojibake(value: str) -> str:
+    if not value or not _MOJIBAKE_HINT_RE.search(value):
+        return value
+    try:
+        repaired = value.encode("latin1").decode("utf-8")
+    except UnicodeError:
+        return value
+    if _mojibake_score(repaired) < _mojibake_score(value):
+        return repaired
+    return value
+
+
+def _mojibake_score(value: str) -> int:
+    return len(_MOJIBAKE_HINT_RE.findall(value))
 
 
 def _canonical_title_tokens(title: str) -> set[str]:
diff --git a/app/services/domains/publication_identifiers/__init__.py b/app/services/domains/publication_identifiers/__init__.py
index 3a35c66..9331dc0 100644
--- a/app/services/domains/publication_identifiers/__init__.py
+++ b/app/services/domains/publication_identifiers/__init__.py
@@ -1,5 +1,6 @@
 from app.services.domains.publication_identifiers.application import (
     DisplayIdentifier,
+    display_identifier_for_publication_id,
     derive_display_identifier_from_values,
     overlay_pdf_queue_items_with_display_identifiers,
     overlay_publication_items_with_display_identifiers,
@@ -9,6 +10,7 @@ from app.services.domains.publication_identifiers.application import (
 
 __all__ = [
     "DisplayIdentifier",
+    "display_identifier_for_publication_id",
     "derive_display_identifier_from_values",
     "overlay_pdf_queue_items_with_display_identifiers",
     "overlay_publication_items_with_display_identifiers",
diff --git a/app/services/domains/publication_identifiers/application.py b/app/services/domains/publication_identifiers/application.py
index ca57d57..31f506c 100644
--- a/app/services/domains/publication_identifiers/application.py
+++ b/app/services/domains/publication_identifiers/application.py
@@ -7,6 +7,7 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import Publication, PublicationIdentifier
+from app.services.domains.arxiv.guards import arxiv_skip_reason_for_item
 from app.services.domains.doi.normalize import normalize_doi
 from app.services.domains.publication_identifiers.normalize import (
     normalize_arxiv_id,
@@ -124,19 +125,45 @@ async def discover_and_sync_identifiers_for_publication(
     scholar_label: str,
 ) -> None:
     await sync_identifiers_for_publication_fields(db_session, publication=publication)
-    
-    existing_doi = await _existing_identifier_by_kind(
+
+    publication_id = int(publication.id)
+    if await _has_confident_identifier(
         db_session,
-        publication_id=int(publication.id),
+        publication_id=publication_id,
         kind=IdentifierKind.DOI.value,
-    )
-    if existing_doi is not None:
+        confidence_floor=0.0,
+    ):
         return
 
-    from app.services.domains.crossref import application as crossref_service
+    item = _identifier_lookup_item(publication=publication, scholar_label=scholar_label)
+    has_strong_doi = await _discover_crossref_doi(
+        db_session,
+        publication_id=publication_id,
+        item=item,
+    )
+    existing_arxiv = await _existing_identifier_by_kind(
+        db_session,
+        publication_id=publication_id,
+        kind=IdentifierKind.ARXIV.value,
+    )
+    skip_reason = arxiv_skip_reason_for_item(
+        item=item,
+        has_strong_doi=has_strong_doi,
+        has_existing_arxiv=existing_arxiv is not None,
+    )
+    if skip_reason is not None:
+        return
+    await _discover_arxiv_identifier(db_session, publication_id=publication_id, item=item)
+
+
+def _identifier_lookup_item(
+    *,
+    publication: Publication,
+    scholar_label: str,
+) -> UnreadPublicationItem:
     from app.services.domains.publications.types import UnreadPublicationItem
-    
-    item = UnreadPublicationItem(
+
+    return UnreadPublicationItem(
         publication_id=int(publication.id),
         scholar_profile_id=0,
         scholar_label=scholar_label,
@@ -147,41 +174,78 @@ async def discover_and_sync_identifiers_for_publication(
         pub_url=publication.pub_url,
         pdf_url=publication.pdf_url,
     )
-    
-    discovered_doi = await crossref_service.discover_doi_for_publication(item=item)
-    if discovered_doi:
-        normalized_doi = normalize_doi(discovered_doi)
-        if normalized_doi:
-            candidate = _candidate(
-                IdentifierKind.DOI,
-                discovered_doi,
-                normalized_doi,
-                "crossref_api",
-                CONFIDENCE_MEDIUM,
-                None,
-            )
-            await _upsert_publication_candidate(db_session, publication_id=int(publication.id), candidate=candidate)
 
-    existing_arxiv = await _existing_identifier_by_kind(
-        db_session,
-        publication_id=int(publication.id),
-        kind=IdentifierKind.ARXIV.value,
+
+async def _discover_crossref_doi(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    item: UnreadPublicationItem,
+) -> bool:
+    from app.services.domains.crossref import application as crossref_service
+
+    discovered_doi = await crossref_service.discover_doi_for_publication(item=item)
+    normalized_doi = normalize_doi(discovered_doi)
+    if normalized_doi is None:
+        return False
+    candidate = _candidate(
+        IdentifierKind.DOI,
+        discovered_doi,
+        normalized_doi,
+        "crossref_api",
+        CONFIDENCE_MEDIUM,
+        None,
     )
-    if existing_arxiv is None:
-        from app.services.domains.arxiv import application as arxiv_service
-        discovered_arxiv = await arxiv_service.discover_arxiv_id_for_publication(item=item)
-        if discovered_arxiv:
-            normalized_arxiv = normalize_arxiv_id(discovered_arxiv)
-            if normalized_arxiv:
-                candidate = _candidate(
-                    IdentifierKind.ARXIV,
-                    discovered_arxiv,
-                    normalized_arxiv,
-                    "arxiv_api",
-                    CONFIDENCE_MEDIUM,
-                    None,
-                )
-                await _upsert_publication_candidate(db_session, publication_id=int(publication.id), candidate=candidate)
+    await _upsert_publication_candidate(
+        db_session,
+        publication_id=publication_id,
+        candidate=candidate,
+    )
+    return candidate.confidence_score >= CONFIDENCE_MEDIUM
+
+
+async def _discover_arxiv_identifier(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    item: UnreadPublicationItem,
+) -> None:
+    from app.services.domains.arxiv import application as arxiv_service
+
+    discovered_arxiv = await arxiv_service.discover_arxiv_id_for_publication(item=item)
+    normalized_arxiv = normalize_arxiv_id(discovered_arxiv)
+    if normalized_arxiv is None:
+        return
+    candidate = _candidate(
+        IdentifierKind.ARXIV,
+        discovered_arxiv,
+        normalized_arxiv,
+        "arxiv_api",
+        CONFIDENCE_MEDIUM,
+        None,
+    )
+    await _upsert_publication_candidate(
+        db_session,
+        publication_id=publication_id,
+        candidate=candidate,
+    )
+
+
+async def _has_confident_identifier(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    kind: str,
+    confidence_floor: float,
+) -> bool:
+    existing = await _existing_identifier_by_kind(
+        db_session,
+        publication_id=publication_id,
+        kind=kind,
+    )
+    if existing is None:
+        return False
+    return float(existing.confidence_score) >= float(confidence_floor)
 
 
 def _publication_field_candidates(publication: Publication) -> list[IdentifierCandidate]:
@@ -339,6 +403,28 @@ def _overlay_queue_item(
     return replace(item, display_identifier=fallback)
 
 
+async def display_identifier_for_publication_id(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+) -> DisplayIdentifier | None:
+    normalized_id = int(publication_id)
+    if normalized_id <= 0:
+        raise ValueError("publication_id must be positive.")
+    mapping = await _display_identifier_map(db_session, publication_ids=[normalized_id])
+    display = mapping.get(normalized_id)
+    if display is not None:
+        return display
+    publication = await db_session.get(Publication, normalized_id)
+    if publication is None:
+        return None
+    return derive_display_identifier_from_values(
+        doi=None,
+        pub_url=publication.pub_url,
+        pdf_url=publication.pdf_url,
+    )
+
+
 async def _display_identifier_map(
     db_session: AsyncSession,
     *,
diff --git a/app/services/domains/publication_identifiers/normalize.py b/app/services/domains/publication_identifiers/normalize.py
index 9f7484a..9743092 100644
--- a/app/services/domains/publication_identifiers/normalize.py
+++ b/app/services/domains/publication_identifiers/normalize.py
@@ -7,6 +7,7 @@ from app.services.domains.doi.normalize import normalize_doi
 from app.services.domains.publication_identifiers.types import IdentifierKind
 
 ARXIV_ABS_RE = re.compile(r"\barxiv:\s*([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?\b", re.I)
+ARXIV_RAW_RE = re.compile(r"^([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?$", re.I)
 ARXIV_PATH_RE = re.compile(r"^/(?:abs|pdf|html|ps|format)/([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?(?:\.pdf)?/?$", re.I)
 PMCID_RE = re.compile(r"\b(PMC\d+)\b", re.I)
 PUBMED_PATH_RE = re.compile(r"^/(\d+)/?$")
@@ -31,6 +32,10 @@ def normalize_arxiv_id(value: str | None) -> str | None:
     parsed = urlparse(text)
     if parsed.scheme in {"http", "https"} and "arxiv.org" in parsed.netloc.lower():
         return _arxiv_from_path(parsed.path)
+    raw_match = ARXIV_RAW_RE.match(text)
+    if raw_match:
+        version = (raw_match.group(2) or "").lower()
+        return f"{raw_match.group(1).lower()}{version}"
     match = ARXIV_ABS_RE.search(text)
     if not match:
         return None
diff --git a/app/services/domains/publications/counts.py b/app/services/domains/publications/counts.py
index 51a524d..700043a 100644
--- a/app/services/domains/publications/counts.py
+++ b/app/services/domains/publications/counts.py
@@ -5,7 +5,7 @@ from datetime import datetime
 from sqlalchemy import distinct, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.db.models import ScholarProfile, ScholarPublication
+from app.db.models import Publication, ScholarProfile, ScholarPublication
 from app.services.domains.publications.modes import (
     MODE_ALL,
     MODE_LATEST,
@@ -22,6 +22,7 @@ async def count_for_user(
     mode: str = MODE_ALL,
     scholar_profile_id: int | None = None,
     favorite_only: bool = False,
+    search: str | None = None,
     snapshot_before: datetime | None = None,
 ) -> int:
     resolved_mode = resolve_publication_view_mode(mode)
@@ -30,8 +31,10 @@ async def count_for_user(
         select(func.count(distinct(ScholarPublication.publication_id)))
         .select_from(ScholarPublication)
         .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
+        .join(Publication, Publication.id == ScholarPublication.publication_id)
         .where(ScholarProfile.user_id == user_id)
     )
+    stmt = _apply_search_filter(stmt, search=search)
     if scholar_profile_id is not None:
         stmt = stmt.where(ScholarProfile.id == scholar_profile_id)
     if favorite_only:
@@ -48,12 +51,25 @@ async def count_for_user(
     return int(result.scalar_one() or 0)
 
 
+def _apply_search_filter(stmt, *, search: str | None):
+    if not search:
+        return stmt
+    safe_search = search.replace("%", r"\%").replace("_", r"\_")
+    pattern = f"%{safe_search}%"
+    return stmt.where(
+        Publication.title_raw.ilike(pattern)
+        | ScholarProfile.display_name.ilike(pattern)
+        | Publication.venue_text.ilike(pattern)
+    )
+
+
 async def count_unread_for_user(
     db_session: AsyncSession,
     *,
     user_id: int,
     scholar_profile_id: int | None = None,
     favorite_only: bool = False,
+    search: str | None = None,
     snapshot_before: datetime | None = None,
 ) -> int:
     return await count_for_user(
@@ -62,6 +78,7 @@ async def count_unread_for_user(
         mode=MODE_UNREAD,
         scholar_profile_id=scholar_profile_id,
         favorite_only=favorite_only,
+        search=search,
         snapshot_before=snapshot_before,
     )
 
@@ -72,6 +89,7 @@ async def count_latest_for_user(
     user_id: int,
     scholar_profile_id: int | None = None,
     favorite_only: bool = False,
+    search: str | None = None,
     snapshot_before: datetime | None = None,
 ) -> int:
     return await count_for_user(
@@ -80,6 +98,7 @@ async def count_latest_for_user(
         mode=MODE_LATEST,
         scholar_profile_id=scholar_profile_id,
         favorite_only=favorite_only,
+        search=search,
         snapshot_before=snapshot_before,
     )
 
@@ -89,6 +108,7 @@ async def count_favorite_for_user(
     *,
     user_id: int,
     scholar_profile_id: int | None = None,
+    search: str | None = None,
     snapshot_before: datetime | None = None,
 ) -> int:
     return await count_for_user(
@@ -97,5 +117,6 @@ async def count_favorite_for_user(
         mode=MODE_ALL,
         scholar_profile_id=scholar_profile_id,
         favorite_only=True,
+        search=search,
         snapshot_before=snapshot_before,
     )
diff --git a/app/services/domains/publications/dedup.py b/app/services/domains/publications/dedup.py
index 8f3c7b7..6615d3b 100644
--- a/app/services/domains/publications/dedup.py
+++ b/app/services/domains/publications/dedup.py
@@ -1,24 +1,77 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
+import hashlib
 import logging
+from typing import Iterable
 
 from sqlalchemy import delete, select
-from sqlalchemy.orm import aliased
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import aliased
 
 from app.db.models import Publication, PublicationIdentifier, ScholarPublication
+from app.services.domains.ingestion.fingerprints import (
+    canonical_title_text_for_dedup,
+    canonical_title_tokens_for_dedup,
+    normalize_title,
+)
 
 logger = logging.getLogger(__name__)
 
+NEAR_DUP_DEFAULT_SIMILARITY_THRESHOLD = 0.78
+NEAR_DUP_DEFAULT_CONTAINMENT_THRESHOLD = 0.92
+NEAR_DUP_DEFAULT_MIN_SHARED_TOKENS = 3
+NEAR_DUP_DEFAULT_MAX_YEAR_DELTA = 1
+NEAR_DUP_MIN_TOKEN_LENGTH = 3
+NEAR_DUP_CLUSTER_KEY_LENGTH = 16
+NEAR_DUP_STOPWORDS = {
+    "a",
+    "an",
+    "and",
+    "approach",
+    "for",
+    "in",
+    "method",
+    "of",
+    "on",
+    "the",
+    "to",
+    "using",
+    "via",
+    "with",
+}
+
+
+@dataclass(frozen=True)
+class NearDuplicateMember:
+    publication_id: int
+    title: str
+    year: int | None
+    citation_count: int
+
+
+@dataclass(frozen=True)
+class NearDuplicateCluster:
+    cluster_key: str
+    winner_publication_id: int
+    similarity_score: float
+    members: tuple[NearDuplicateMember, ...]
+
+
+@dataclass(frozen=True)
+class _NearDuplicateCandidate:
+    publication_id: int
+    title: str
+    year: int | None
+    citation_count: int
+    canonical_text: str
+    tokens: frozenset[str]
+
 
 async def find_identifier_duplicate_pairs(
     db_session: AsyncSession,
 ) -> list[tuple[int, int]]:
-    """Return (winner_id, dup_id) pairs where two publications share the same identifier.
-
-    Winner is always the lower publication_id (earlier-created). Uses the existing
-    ix_publication_identifiers_kind_value index for the self-join.
-    """
+    """Return (winner_id, dup_id) pairs where two publications share the same identifier."""
     pi1 = aliased(PublicationIdentifier, name="pi1")
     pi2 = aliased(PublicationIdentifier, name="pi2")
     rows = await db_session.execute(
@@ -40,11 +93,17 @@ async def merge_duplicate_publication(
     winner_id: int,
     dup_id: int,
 ) -> None:
-    """Merge dup_id into winner_id: migrate scholar links, then delete the dup."""
+    """Merge dup_id into winner_id: migrate metadata/links/identifiers, then delete dup."""
+    if winner_id == dup_id:
+        raise ValueError("winner_id and dup_id must differ.")
+    winner = await _load_publication(db_session, publication_id=winner_id)
+    dup = await _load_publication(db_session, publication_id=dup_id)
+    if winner is None or dup is None:
+        raise ValueError("winner_id and dup_id must both exist.")
+    _merge_publication_metadata(winner=winner, dup=dup)
     await _migrate_scholar_links(db_session, winner_id=winner_id, dup_id=dup_id)
-    await db_session.execute(
-        delete(Publication).where(Publication.id == dup_id)
-    )
+    await _migrate_identifiers(db_session, winner_id=winner_id, dup_id=dup_id)
+    await db_session.execute(delete(Publication).where(Publication.id == dup_id))
     logger.info(
         "publications.identifier_merge",
         extra={
@@ -55,6 +114,45 @@ async def merge_duplicate_publication(
     )
 
 
+async def _load_publication(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+) -> Publication | None:
+    result = await db_session.execute(
+        select(Publication).where(Publication.id == publication_id)
+    )
+    return result.scalar_one_or_none()
+
+
+def _merge_publication_metadata(*, winner: Publication, dup: Publication) -> None:
+    if winner.year is None and dup.year is not None:
+        winner.year = dup.year
+    winner.citation_count = max(int(winner.citation_count or 0), int(dup.citation_count or 0))
+    if not winner.author_text and dup.author_text:
+        winner.author_text = dup.author_text
+    if not winner.venue_text and dup.venue_text:
+        winner.venue_text = dup.venue_text
+    if not winner.pub_url and dup.pub_url:
+        winner.pub_url = dup.pub_url
+    if not winner.pdf_url and dup.pdf_url:
+        winner.pdf_url = dup.pdf_url
+    if not winner.cluster_id and dup.cluster_id:
+        winner.cluster_id = dup.cluster_id
+    if not winner.canonical_title_hash and dup.canonical_title_hash:
+        winner.canonical_title_hash = dup.canonical_title_hash
+    winner.title_raw = _preferred_title_text(winner=winner.title_raw, dup=dup.title_raw)
+    winner.title_normalized = normalize_title(winner.title_raw)
+
+
+def _preferred_title_text(*, winner: str, dup: str) -> str:
+    winner_score = len(canonical_title_text_for_dedup(winner))
+    dup_score = len(canonical_title_text_for_dedup(dup))
+    if dup_score > winner_score:
+        return dup
+    return winner
+
+
 async def _migrate_scholar_links(
     db_session: AsyncSession,
     *,
@@ -81,17 +179,64 @@ async def _migrate_scholar_links(
             link.publication_id = winner_id
 
 
-async def sweep_identifier_duplicates(db_session: AsyncSession) -> int:
-    """Find publications sharing an identifier and merge duplicates into the winner.
+async def _migrate_identifiers(
+    db_session: AsyncSession,
+    *,
+    winner_id: int,
+    dup_id: int,
+) -> None:
+    result = await db_session.execute(
+        select(PublicationIdentifier).where(PublicationIdentifier.publication_id == dup_id)
+    )
+    dup_identifiers = result.scalars().all()
+    for identifier in dup_identifiers:
+        existing = await _find_identifier(
+            db_session,
+            publication_id=winner_id,
+            kind=identifier.kind,
+            value_normalized=identifier.value_normalized,
+        )
+        if existing is None:
+            identifier.publication_id = winner_id
+            continue
+        _merge_identifier(existing=existing, dup=identifier)
+        await db_session.delete(identifier)
 
-    Returns the number of duplicate publications removed.
-    """
+
+async def _find_identifier(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+    kind: str,
+    value_normalized: str,
+) -> PublicationIdentifier | None:
+    result = await db_session.execute(
+        select(PublicationIdentifier).where(
+            PublicationIdentifier.publication_id == publication_id,
+            PublicationIdentifier.kind == kind,
+            PublicationIdentifier.value_normalized == value_normalized,
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+def _merge_identifier(*, existing: PublicationIdentifier, dup: PublicationIdentifier) -> None:
+    existing.confidence_score = max(
+        float(existing.confidence_score),
+        float(dup.confidence_score),
+    )
+    if not existing.evidence_url and dup.evidence_url:
+        existing.evidence_url = dup.evidence_url
+    if not existing.value_raw and dup.value_raw:
+        existing.value_raw = dup.value_raw
+
+
+async def sweep_identifier_duplicates(db_session: AsyncSession) -> int:
+    """Find publications sharing an identifier and merge duplicates into the winner."""
     pairs = await find_identifier_duplicate_pairs(db_session)
     if not pairs:
         return 0
 
-    # Deduplicate the pairs — a dup may appear multiple times if it shares
-    # several identifiers with the winner; process each dup only once.
     processed_dups: set[int] = set()
     for winner_id, dup_id in pairs:
         if dup_id in processed_dups:
@@ -101,3 +246,271 @@ async def sweep_identifier_duplicates(db_session: AsyncSession) -> int:
 
     await db_session.flush()
     return len(processed_dups)
+
+
+async def find_near_duplicate_clusters(
+    db_session: AsyncSession,
+    *,
+    similarity_threshold: float = NEAR_DUP_DEFAULT_SIMILARITY_THRESHOLD,
+    min_shared_tokens: int = NEAR_DUP_DEFAULT_MIN_SHARED_TOKENS,
+    max_year_delta: int = NEAR_DUP_DEFAULT_MAX_YEAR_DELTA,
+) -> list[NearDuplicateCluster]:
+    candidates = await _load_near_duplicate_candidates(db_session)
+    if len(candidates) < 2:
+        return []
+    groups = _cluster_candidate_groups(
+        candidates,
+        similarity_threshold=similarity_threshold,
+        min_shared_tokens=min_shared_tokens,
+        max_year_delta=max_year_delta,
+    )
+    clusters = [_near_duplicate_cluster(group) for group in groups]
+    return sorted(clusters, key=lambda item: (-len(item.members), item.winner_publication_id))
+
+
+async def merge_near_duplicate_cluster(
+    db_session: AsyncSession,
+    *,
+    cluster: NearDuplicateCluster,
+) -> int:
+    winner_id = int(cluster.winner_publication_id)
+    merged = 0
+    for member in cluster.members:
+        if int(member.publication_id) == winner_id:
+            continue
+        await merge_duplicate_publication(
+            db_session,
+            winner_id=winner_id,
+            dup_id=int(member.publication_id),
+        )
+        merged += 1
+    return merged
+
+
+def near_duplicate_cluster_payload(cluster: NearDuplicateCluster) -> dict[str, object]:
+    members = [
+        {
+            "publication_id": int(member.publication_id),
+            "title": member.title,
+            "year": member.year,
+            "citation_count": int(member.citation_count),
+        }
+        for member in cluster.members
+    ]
+    return {
+        "cluster_key": cluster.cluster_key,
+        "winner_publication_id": int(cluster.winner_publication_id),
+        "member_count": len(cluster.members),
+        "similarity_score": float(cluster.similarity_score),
+        "members": members,
+    }
+
+
+async def _load_near_duplicate_candidates(
+    db_session: AsyncSession,
+) -> list[_NearDuplicateCandidate]:
+    result = await db_session.execute(
+        select(
+            Publication.id,
+            Publication.title_raw,
+            Publication.year,
+            Publication.citation_count,
+        )
+    )
+    records = [
+        _candidate_from_row(
+            publication_id=int(publication_id),
+            title=str(title_raw or ""),
+            year=year,
+            citation_count=int(citation_count or 0),
+        )
+        for publication_id, title_raw, year, citation_count in result.all()
+    ]
+    return [record for record in records if record is not None]
+
+
+def _candidate_from_row(
+    *,
+    publication_id: int,
+    title: str,
+    year: int | None,
+    citation_count: int,
+) -> _NearDuplicateCandidate | None:
+    canonical = canonical_title_text_for_dedup(title)
+    raw_tokens = canonical_title_tokens_for_dedup(title)
+    tokens = _normalized_tokens(raw_tokens)
+    if not canonical or not tokens:
+        return None
+    return _NearDuplicateCandidate(
+        publication_id=publication_id,
+        title=title,
+        year=year,
+        citation_count=citation_count,
+        canonical_text=canonical,
+        tokens=frozenset(tokens),
+    )
+
+
+def _normalized_tokens(tokens: Iterable[str]) -> set[str]:
+    return {
+        token
+        for token in tokens
+        if len(token) >= NEAR_DUP_MIN_TOKEN_LENGTH and token not in NEAR_DUP_STOPWORDS
+    }
+
+
+def _cluster_candidate_groups(
+    candidates: list[_NearDuplicateCandidate],
+    *,
+    similarity_threshold: float,
+    min_shared_tokens: int,
+    max_year_delta: int,
+) -> list[list[_NearDuplicateCandidate]]:
+    by_id = {candidate.publication_id: candidate for candidate in candidates}
+    token_index = _candidate_token_index(candidates)
+    parent = {candidate.publication_id: candidate.publication_id for candidate in candidates}
+    for candidate in candidates:
+        peers = _candidate_peer_ids(candidate=candidate, token_index=token_index)
+        for peer_id in sorted(peers):
+            if peer_id <= candidate.publication_id:
+                continue
+            peer = by_id[peer_id]
+            if _is_near_duplicate_pair(
+                candidate,
+                peer,
+                similarity_threshold=similarity_threshold,
+                min_shared_tokens=min_shared_tokens,
+                max_year_delta=max_year_delta,
+            ):
+                _union(parent, candidate.publication_id, peer_id)
+    return _grouped_candidates(candidates, parent)
+
+
+def _candidate_token_index(
+    candidates: list[_NearDuplicateCandidate],
+) -> dict[str, set[int]]:
+    index: dict[str, set[int]] = {}
+    for candidate in candidates:
+        for token in candidate.tokens:
+            index.setdefault(token, set()).add(candidate.publication_id)
+    return index
+
+
+def _candidate_peer_ids(
+    *,
+    candidate: _NearDuplicateCandidate,
+    token_index: dict[str, set[int]],
+) -> set[int]:
+    peers: set[int] = set()
+    for token in candidate.tokens:
+        peers.update(token_index.get(token, set()))
+    peers.discard(candidate.publication_id)
+    return peers
+
+
+def _is_near_duplicate_pair(
+    left: _NearDuplicateCandidate,
+    right: _NearDuplicateCandidate,
+    *,
+    similarity_threshold: float,
+    min_shared_tokens: int,
+    max_year_delta: int,
+) -> bool:
+    if left.canonical_text == right.canonical_text:
+        return True
+    if not _years_compatible(left.year, right.year, max_year_delta=max_year_delta):
+        return False
+    shared_tokens = len(left.tokens & right.tokens)
+    if shared_tokens < min_shared_tokens:
+        return False
+    jaccard = _jaccard(left.tokens, right.tokens)
+    containment = shared_tokens / max(1, min(len(left.tokens), len(right.tokens)))
+    return jaccard >= similarity_threshold or containment >= NEAR_DUP_DEFAULT_CONTAINMENT_THRESHOLD
+
+
+def _years_compatible(left: int | None, right: int | None, *, max_year_delta: int) -> bool:
+    if left is None or right is None:
+        return True
+    return abs(int(left) - int(right)) <= int(max_year_delta)
+
+
+def _jaccard(left: frozenset[str], right: frozenset[str]) -> float:
+    if not left or not right:
+        return 0.0
+    return len(left & right) / len(left | right)
+
+
+def _find_root(parent: dict[int, int], value: int) -> int:
+    root = parent[value]
+    while root != parent[root]:
+        root = parent[root]
+    while value != root:
+        next_value = parent[value]
+        parent[value] = root
+        value = next_value
+    return root
+
+
+def _union(parent: dict[int, int], left: int, right: int) -> None:
+    left_root = _find_root(parent, left)
+    right_root = _find_root(parent, right)
+    if left_root == right_root:
+        return
+    if left_root < right_root:
+        parent[right_root] = left_root
+        return
+    parent[left_root] = right_root
+
+
+def _grouped_candidates(
+    candidates: list[_NearDuplicateCandidate],
+    parent: dict[int, int],
+) -> list[list[_NearDuplicateCandidate]]:
+    groups: dict[int, list[_NearDuplicateCandidate]] = {}
+    for candidate in candidates:
+        root = _find_root(parent, candidate.publication_id)
+        groups.setdefault(root, []).append(candidate)
+    clustered = [members for members in groups.values() if len(members) > 1]
+    for members in clustered:
+        members.sort(key=lambda item: item.publication_id)
+    return clustered
+
+
+def _near_duplicate_cluster(members: list[_NearDuplicateCandidate]) -> NearDuplicateCluster:
+    winner = _winner_candidate(members)
+    member_ids = [member.publication_id for member in members]
+    joined = ",".join(str(publication_id) for publication_id in member_ids)
+    cluster_key = hashlib.sha256(joined.encode("utf-8")).hexdigest()[:NEAR_DUP_CLUSTER_KEY_LENGTH]
+    similarity_score = _cluster_similarity_score(members)
+    return NearDuplicateCluster(
+        cluster_key=cluster_key,
+        winner_publication_id=winner.publication_id,
+        similarity_score=similarity_score,
+        members=tuple(
+            NearDuplicateMember(
+                publication_id=member.publication_id,
+                title=member.title,
+                year=member.year,
+                citation_count=member.citation_count,
+            )
+            for member in members
+        ),
+    )
+
+
+def _winner_candidate(members: list[_NearDuplicateCandidate]) -> _NearDuplicateCandidate:
+    return min(
+        members,
+        key=lambda member: (-int(member.citation_count), member.publication_id),
+    )
+
+
+def _cluster_similarity_score(members: list[_NearDuplicateCandidate]) -> float:
+    best = 0.0
+    for index, left in enumerate(members):
+        for right in members[index + 1 :]:
+            shared_tokens = len(left.tokens & right.tokens)
+            jaccard = _jaccard(left.tokens, right.tokens)
+            containment = shared_tokens / max(1, min(len(left.tokens), len(right.tokens)))
+            best = max(best, jaccard, containment)
+    return round(best, 4)
diff --git a/app/services/domains/publications/pdf_queue.py b/app/services/domains/publications/pdf_queue.py
index 7503138..3cb0de4 100644
--- a/app/services/domains/publications/pdf_queue.py
+++ b/app/services/domains/publications/pdf_queue.py
@@ -370,16 +370,18 @@ async def _fetch_outcome_for_row(
     row: PublicationListItem,
     request_email: str | None,
     openalex_api_key: str | None = None,
-) -> OaResolutionOutcome:
+    allow_arxiv_lookup: bool = True,
+) -> tuple[OaResolutionOutcome, bool]:
     pipeline_result = await resolve_publication_pdf_outcome_for_row(
         row=row,
         request_email=request_email,
         openalex_api_key=openalex_api_key,
+        allow_arxiv_lookup=allow_arxiv_lookup,
     )
     outcome = pipeline_result.outcome
     if outcome is not None:
-        return outcome
-    return _failed_outcome(row=row)
+        return outcome, bool(pipeline_result.arxiv_rate_limited)
+    return _failed_outcome(row=row), bool(pipeline_result.arxiv_rate_limited)
 
 
 def _apply_publication_update(
@@ -450,17 +452,19 @@ async def _resolve_publication_row(
     request_email: str | None,
     row: PublicationListItem,
     openalex_api_key: str | None = None,
-) -> None:
+    allow_arxiv_lookup: bool = True,
+) -> bool:
     from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
-    from app.services.domains.arxiv.application import ArxivRateLimitError
+
     await _mark_attempt_started(publication_id=row.publication_id, user_id=user_id)
     try:
-        outcome = await _fetch_outcome_for_row(
+        outcome, arxiv_rate_limited = await _fetch_outcome_for_row(
             row=row,
             request_email=request_email,
             openalex_api_key=openalex_api_key,
+            allow_arxiv_lookup=allow_arxiv_lookup,
         )
-    except (OpenAlexBudgetExhaustedError, ArxivRateLimitError):
+    except OpenAlexBudgetExhaustedError:
         # Persist a terminal outcome so jobs do not remain stuck in "running".
         await _persist_outcome(
             publication_id=row.publication_id,
@@ -479,11 +483,13 @@ async def _resolve_publication_row(
             },
         )
         outcome = _failed_outcome(row=row)
+        arxiv_rate_limited = False
     await _persist_outcome(
         publication_id=row.publication_id,
         user_id=user_id,
         outcome=outcome,
     )
+    return bool(arxiv_rate_limited)
 
 
 async def _run_resolution_task(
@@ -493,7 +499,6 @@ async def _run_resolution_task(
     rows: list[PublicationListItem],
 ) -> None:
     from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
-    from app.services.domains.arxiv.application import ArxivRateLimitError
     from app.services.domains.settings import application as user_settings_service
 
     # Resolve the best available API key: per-user setting → env var fallback.
@@ -506,14 +511,25 @@ async def _run_resolution_task(
     except Exception:
         openalex_api_key = settings.openalex_api_key
 
+    arxiv_lookup_allowed = True
     for row in rows:
         try:
-            await _resolve_publication_row(
+            arxiv_rate_limited = await _resolve_publication_row(
                 user_id=user_id,
                 request_email=request_email,
                 row=row,
                 openalex_api_key=openalex_api_key,
+                allow_arxiv_lookup=arxiv_lookup_allowed,
             )
+            if arxiv_rate_limited and arxiv_lookup_allowed:
+                arxiv_lookup_allowed = False
+                logger.warning(
+                    "publications.pdf_queue.arxiv_batch_disabled",
+                    extra={
+                        "event": "publications.pdf_queue.arxiv_batch_disabled",
+                        "detail": "arXiv temporarily disabled for remaining batch after rate limit",
+                    },
+                )
         except OpenAlexBudgetExhaustedError:
             logger.warning(
                 "publications.pdf_queue.budget_exhausted",
@@ -521,15 +537,6 @@ async def _run_resolution_task(
                        "detail": "Stopping PDF resolution batch — OpenAlex daily budget exhausted"},
             )
             break
-        except ArxivRateLimitError:
-            logger.warning(
-                "publications.pdf_queue.arxiv_rate_limited",
-                extra={
-                    "event": "publications.pdf_queue.arxiv_rate_limited",
-                    "detail": "Stopping PDF resolution batch — arXiv rate limit hit (429)",
-                },
-            )
-            break
 
 
 def _schedule_rows(
diff --git a/app/services/domains/publications/pdf_resolution_pipeline.py b/app/services/domains/publications/pdf_resolution_pipeline.py
index 0dc133c..7ad1f8d 100644
--- a/app/services/domains/publications/pdf_resolution_pipeline.py
+++ b/app/services/domains/publications/pdf_resolution_pipeline.py
@@ -5,6 +5,7 @@ import logging
 from typing import Any
 
 from app.services.domains.arxiv.application import ArxivRateLimitError
+from app.services.domains.arxiv.guards import arxiv_skip_reason_for_item
 from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
 from app.services.domains.publications.types import PublicationListItem
 from app.services.domains.unpaywall.application import OaResolutionOutcome, resolve_publication_oa_outcomes
@@ -17,6 +18,7 @@ logger = logging.getLogger(__name__)
 class PipelineOutcome:
     outcome: OaResolutionOutcome | None
     scholar_candidates: Any | None  # Kept for backward compatibility with calling signatures
+    arxiv_rate_limited: bool = False
 
 
 async def resolve_publication_pdf_outcome_for_row(
@@ -24,6 +26,7 @@ async def resolve_publication_pdf_outcome_for_row(
     row: PublicationListItem,
     request_email: str | None,
     openalex_api_key: str | None = None,
+    allow_arxiv_lookup: bool = True,
 ) -> PipelineOutcome:
     # 1. OpenAlex OA — raises OpenAlexBudgetExhaustedError if budget is gone
     openalex_outcome = await _openalex_outcome(row, request_email=request_email, openalex_api_key=openalex_api_key)
@@ -31,13 +34,29 @@ async def resolve_publication_pdf_outcome_for_row(
         return PipelineOutcome(openalex_outcome, None)
 
     # 2. arXiv
-    arxiv_outcome = await _arxiv_outcome(row, request_email=request_email)
+    arxiv_rate_limited = False
+    try:
+        arxiv_outcome = await _arxiv_outcome(
+            row,
+            request_email=request_email,
+            allow_lookup=allow_arxiv_lookup,
+        )
+    except ArxivRateLimitError:
+        arxiv_rate_limited = True
+        arxiv_outcome = None
+        logger.warning(
+            "publications.pdf_resolution.arxiv_rate_limited",
+            extra={
+                "event": "publications.pdf_resolution.arxiv_rate_limited",
+                "publication_id": int(row.publication_id),
+            },
+        )
     if arxiv_outcome and arxiv_outcome.pdf_url:
-        return PipelineOutcome(arxiv_outcome, None)
+        return PipelineOutcome(arxiv_outcome, None, arxiv_rate_limited=arxiv_rate_limited)
 
     # 3. Unpaywall (which falls back to Crossref)
     oa_outcome = await _oa_outcome(row=row, request_email=request_email)
-    return PipelineOutcome(oa_outcome, None)
+    return PipelineOutcome(oa_outcome, None, arxiv_rate_limited=arxiv_rate_limited)
 
 
 async def _openalex_outcome(
@@ -87,9 +106,23 @@ async def _openalex_outcome(
     return None
 
 
-async def _arxiv_outcome(row: PublicationListItem, request_email: str | None) -> OaResolutionOutcome | None:
+async def _arxiv_outcome(
+    row: PublicationListItem,
+    *,
+    request_email: str | None,
+    allow_lookup: bool = True,
+) -> OaResolutionOutcome | None:
     from app.services.domains.arxiv.application import discover_arxiv_id_for_publication
 
+    if not allow_lookup:
+        _log_arxiv_skip(row=row, skip_reason="batch_arxiv_cooldown_active")
+        return None
+
+    skip_reason = arxiv_skip_reason_for_item(item=row)
+    if skip_reason is not None:
+        _log_arxiv_skip(row=row, skip_reason=skip_reason)
+        return None
+
     try:
         arxiv_id = await discover_arxiv_id_for_publication(item=row, request_email=request_email)
         if arxiv_id:
@@ -103,7 +136,7 @@ async def _arxiv_outcome(row: PublicationListItem, request_email: str | None) ->
                 used_crossref=False,
             )
     except ArxivRateLimitError:
-        raise  # propagate so the batch loop can stop
+        raise  # propagate so orchestration can switch to non-arXiv fallback
     except Exception as exc:
         logger.warning(
             "publications.pdf_resolution.arxiv_failed",
@@ -112,6 +145,17 @@ async def _arxiv_outcome(row: PublicationListItem, request_email: str | None) ->
     return None
 
 
+def _log_arxiv_skip(*, row: PublicationListItem, skip_reason: str) -> None:
+    logger.info(
+        "publications.pdf_resolution.arxiv_skipped",
+        extra={
+            "event": "publications.pdf_resolution.arxiv_skipped",
+            "publication_id": int(row.publication_id),
+            "skip_reason": skip_reason,
+        },
+    )
+
+
 async def _oa_outcome(
     *,
     row: PublicationListItem,
diff --git a/app/services/domains/publications/queries.py b/app/services/domains/publications/queries.py
index 6f57cab..d642a73 100644
--- a/app/services/domains/publications/queries.py
+++ b/app/services/domains/publications/queries.py
@@ -2,10 +2,17 @@ from __future__ import annotations
 
 from datetime import datetime
 
-from sqlalchemy import Select, func, select
+from sqlalchemy import Select, case, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.db.models import CrawlRun, Publication, RunStatus, ScholarProfile, ScholarPublication
+from app.db.models import (
+    CrawlRun,
+    Publication,
+    PublicationPdfJob,
+    RunStatus,
+    ScholarProfile,
+    ScholarPublication,
+)
 from app.services.domains.publications.modes import MODE_LATEST, MODE_UNREAD
 from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
 
@@ -17,6 +24,29 @@ def _normalized_citation_count(value: object) -> int:
         return 0
 
 
+def _pdf_status_sort_rank():
+    return case(
+        (Publication.pdf_url.is_not(None), 4),
+        (PublicationPdfJob.status == "resolved", 4),
+        (PublicationPdfJob.status == "running", 3),
+        (PublicationPdfJob.status == "queued", 2),
+        (PublicationPdfJob.status == "failed", 0),
+        else_=1,
+    )
+
+
+def _sort_column(sort_by: str):
+    sort_columns = {
+        "first_seen": ScholarPublication.created_at,
+        "title": Publication.title_raw,
+        "year": Publication.year,
+        "citations": Publication.citation_count,
+        "scholar": ScholarProfile.display_name,
+        "pdf_status": _pdf_status_sort_rank(),
+    }
+    return sort_columns.get(sort_by, ScholarPublication.created_at)
+
+
 async def get_latest_run_id_for_user(
     db_session: AsyncSession,
     *,
@@ -55,14 +85,6 @@ def publications_query(
     sort_dir: str = "desc",
     snapshot_before: datetime | None = None,
 ) -> Select[tuple]:
-    _SORT_COLUMNS = {
-        "first_seen": ScholarPublication.created_at,
-        "title": Publication.title_raw,
-        "year": Publication.year,
-        "citations": Publication.citation_count,
-        "scholar": ScholarProfile.display_name,
-    }
-
     scholar_label = ScholarProfile.display_name
     stmt = (
         select(
@@ -83,6 +105,7 @@ def publications_query(
         )
         .join(ScholarPublication, ScholarPublication.publication_id == Publication.id)
         .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
+        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
         .where(ScholarProfile.user_id == user_id)
     )
     if search:
@@ -106,7 +129,7 @@ def publications_query(
     if snapshot_before is not None:
         stmt = stmt.where(ScholarPublication.created_at <= snapshot_before)
 
-    sort_col = _SORT_COLUMNS.get(sort_by, ScholarPublication.created_at)
+    sort_col = _sort_column(sort_by)
     order = sort_col.desc() if sort_dir == "desc" else sort_col.asc()
     stmt = stmt.order_by(order, Publication.id.desc())
 
diff --git a/app/services/domains/scholar/rate_limit.py b/app/services/domains/scholar/rate_limit.py
index 947c91f..fa708b6 100644
--- a/app/services/domains/scholar/rate_limit.py
+++ b/app/services/domains/scholar/rate_limit.py
@@ -7,12 +7,28 @@ _REQUEST_LOCK = asyncio.Lock()
 _LAST_REQUEST_AT = 0.0
 
 
+def _normalize_interval_seconds(value: float) -> float:
+    return max(float(value), 0.0)
+
+
+def remaining_scholar_slot_seconds(*, min_interval_seconds: float) -> float:
+    interval_seconds = _normalize_interval_seconds(min_interval_seconds)
+    if interval_seconds <= 0:
+        return 0.0
+    elapsed_seconds = time.monotonic() - _LAST_REQUEST_AT
+    return max(interval_seconds - elapsed_seconds, 0.0)
+
+
 async def wait_for_scholar_slot(*, min_interval_seconds: float) -> None:
     global _LAST_REQUEST_AT
-    interval = max(float(min_interval_seconds), 0.0)
+    interval = _normalize_interval_seconds(min_interval_seconds)
     async with _REQUEST_LOCK:
-        elapsed = time.monotonic() - _LAST_REQUEST_AT
-        remaining = interval - elapsed
+        remaining = remaining_scholar_slot_seconds(min_interval_seconds=interval)
         if remaining > 0:
             await asyncio.sleep(remaining)
         _LAST_REQUEST_AT = time.monotonic()
+
+
+def reset_scholar_rate_limit_state_for_tests() -> None:
+    global _LAST_REQUEST_AT
+    _LAST_REQUEST_AT = 0.0
diff --git a/app/services/domains/scholar/source.py b/app/services/domains/scholar/source.py
index 92c6702..cf2ea0a 100644
--- a/app/services/domains/scholar/source.py
+++ b/app/services/domains/scholar/source.py
@@ -9,6 +9,9 @@ from urllib.error import HTTPError, URLError
 from urllib.parse import urlencode
 from urllib.request import Request, urlopen
 
+from app.services.domains.scholar import rate_limit as scholar_rate_limit
+from app.settings import settings
+
 SCHOLAR_PROFILE_URL = "https://scholar.google.com/citations"
 DEFAULT_PAGE_SIZE = 100
 
@@ -66,9 +69,16 @@ class LiveScholarSource:
         self,
         *,
         timeout_seconds: float = 25.0,
+        min_interval_seconds: float | None = None,
         user_agents: list[str] | None = None,
     ) -> None:
         self._timeout_seconds = timeout_seconds
+        configured_interval = (
+            float(settings.ingestion_min_request_delay_seconds)
+            if min_interval_seconds is None
+            else float(min_interval_seconds)
+        )
+        self._min_interval_seconds = max(configured_interval, 0.0)
         self._user_agents = user_agents or DEFAULT_USER_AGENTS
 
     async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
@@ -100,7 +110,7 @@ class LiveScholarSource:
                 "pagesize": pagesize,
             },
         )
-        return await asyncio.to_thread(self._fetch_sync, requested_url)
+        return await self._fetch_with_global_throttle(requested_url)
 
     async def fetch_author_search_html(
         self,
@@ -121,7 +131,7 @@ class LiveScholarSource:
                 "start": start,
             },
         )
-        return await asyncio.to_thread(self._fetch_sync, requested_url)
+        return await self._fetch_with_global_throttle(requested_url)
 
     async def fetch_publication_html(self, publication_url: str) -> FetchResult:
         logger.debug(
@@ -131,7 +141,13 @@ class LiveScholarSource:
                 "requested_url": publication_url,
             },
         )
-        return await asyncio.to_thread(self._fetch_sync, publication_url)
+        return await self._fetch_with_global_throttle(publication_url)
+
+    async def _fetch_with_global_throttle(self, requested_url: str) -> FetchResult:
+        await scholar_rate_limit.wait_for_scholar_slot(
+            min_interval_seconds=self._min_interval_seconds,
+        )
+        return await asyncio.to_thread(self._fetch_sync, requested_url)
 
     def _build_request(self, requested_url: str) -> Request:
         return Request(
diff --git a/app/settings.py b/app/settings.py
index 15b0c19..51ebcf4 100644
--- a/app/settings.py
+++ b/app/settings.py
@@ -253,6 +253,14 @@ class Settings:
     unpaywall_pdf_discovery_enabled: bool = _env_bool("UNPAYWALL_PDF_DISCOVERY_ENABLED", True)
     unpaywall_pdf_discovery_max_candidates: int = _env_int("UNPAYWALL_PDF_DISCOVERY_MAX_CANDIDATES", 5)
     unpaywall_pdf_discovery_max_html_bytes: int = _env_int("UNPAYWALL_PDF_DISCOVERY_MAX_HTML_BYTES", 500_000)
+    arxiv_enabled: bool = _env_bool("ARXIV_ENABLED", True)
+    arxiv_timeout_seconds: float = _env_float("ARXIV_TIMEOUT_SECONDS", 3.0)
+    arxiv_min_interval_seconds: float = _env_float("ARXIV_MIN_INTERVAL_SECONDS", 4.0)
+    arxiv_rate_limit_cooldown_seconds: float = _env_float("ARXIV_RATE_LIMIT_COOLDOWN_SECONDS", 60.0)
+    arxiv_default_max_results: int = _env_int("ARXIV_DEFAULT_MAX_RESULTS", 3)
+    arxiv_cache_ttl_seconds: float = _env_float("ARXIV_CACHE_TTL_SECONDS", 900.0)
+    arxiv_cache_max_entries: int = _env_int("ARXIV_CACHE_MAX_ENTRIES", 512)
+    arxiv_mailto: str = _env_str("ARXIV_MAILTO", "")
     crossref_enabled: bool = _env_bool("CROSSREF_ENABLED", True)
     crossref_max_rows: int = _env_int("CROSSREF_MAX_ROWS", 10)
     crossref_timeout_seconds: float = _env_float("CROSSREF_TIMEOUT_SECONDS", 8.0)
diff --git a/docs/developer/architecture.md b/docs/developer/architecture.md
index afa6b05..4330830 100644
--- a/docs/developer/architecture.md
+++ b/docs/developer/architecture.md
@@ -14,6 +14,7 @@ Canonical business logic belongs in `app/services/domains/*`.
 - `app/services/domains/scholar/*`: fail-fast scholar parsing and source fetch adapters.
 - `app/services/domains/scholars/*`: scholar CRUD, profile image, and name-search controls.
 - `app/services/domains/publications/*`: listing/read-state, favorite toggles, enrichment scheduling, and retry paths.
+- `app/services/domains/arxiv/*`: typed API client, global DB-backed throttle, query cache, and in-flight request coalescing.
 - `app/services/domains/crossref/*` + `app/services/domains/unpaywall/*`: DOI/OA enrichment with bounded pacing.
 - `app/services/domains/runs/*`: run history and continuation queue operations.
 - `app/services/domains/portability/*`: import/export workflows.
@@ -49,3 +50,9 @@ graph TD
 
 ### Identifier Engine Philosophy
 The platform previously treated the `DOI` as a hardcoded 1:1 property of a publication. It now utilizes a decoupled *Identifier Gathering* module (`PublicationIdentifier` table). A single publication can have multiple identifiers (ex. `doi`, `arxiv`, `pmid`, `pmcid`). This creates high resilience when integrating with external APIs, allowing systems like Unpaywall to be fed explicitly with high-confidence DOIs, rather than relying on unstructured search heuristics.
+
+### arXiv Safety and Efficiency
+- arXiv requests are globally serialized via a PostgreSQL advisory lock and shared runtime row (`arxiv_runtime_state`).
+- identical request payloads are fingerprinted and cached in `arxiv_query_cache_entries` with TTL + optional max-entry pruning.
+- concurrent identical misses are coalesced in-process, so one outbound call serves all waiters.
+- structured logs provide auditability for scheduling/completion/cooldown/cache behavior.
diff --git a/docs/developer/ingestion.md b/docs/developer/ingestion.md
index b906f15..26ee8e7 100644
--- a/docs/developer/ingestion.md
+++ b/docs/developer/ingestion.md
@@ -24,3 +24,15 @@ Once a publication is built, the `gather_identifiers_for_publication` module iso
   - `crossref.restful` APIs (Queries by Title and Author strings).
 
 These identifiers are accumulated in `publication_identifiers` instead of being bound as hard-coded properties, maximizing matching resilience in the automated Unpaywall PDF acquisition stage.
+
+## arXiv Request Controls
+- **Global throttle state**: arXiv calls share `arxiv_runtime_state` so all workers respect one cooldown/interval clock.
+- **Query cache**: identical request parameters map to a stable fingerprint and are stored in `arxiv_query_cache_entries`.
+- **In-flight coalescing**: duplicate concurrent misses join one outbound request instead of fan-out.
+- **Caller load-shedding**: arXiv lookups are skipped when high-confidence DOI/arXiv evidence already exists, or when title quality is below threshold.
+
+## arXiv Observability Events
+- `arxiv.request_scheduled`: emitted before a gated request; includes `wait_seconds`, `cooldown_remaining_seconds`, `source_path`.
+- `arxiv.request_completed`: emitted after response; includes `status_code`, `wait_seconds`, `cooldown_remaining_seconds`, `source_path`.
+- `arxiv.cooldown_activated`: emitted when status `429` triggers cooldown.
+- `arxiv.cache_hit` / `arxiv.cache_miss`: emitted on query cache lookup with `source_path`.
diff --git a/docs/operations/arxiv-runbook.md b/docs/operations/arxiv-runbook.md
new file mode 100644
index 0000000..b3183be
--- /dev/null
+++ b/docs/operations/arxiv-runbook.md
@@ -0,0 +1,46 @@
+# arXiv Operations Runbook
+
+Use this runbook when arXiv lookups are slow, rate-limited, or behaving unexpectedly.
+
+## Signals To Check
+- logs for `arxiv.request_scheduled`, `arxiv.request_completed`, `arxiv.cooldown_activated`, `arxiv.cache_hit`, `arxiv.cache_miss`
+- `arxiv_runtime_state` row for cooldown and next-allowed timestamps
+- `arxiv_query_cache_entries` size and expiry churn
+
+## Event Field Guide
+- `wait_seconds`: enforced pre-request delay from the global limiter.
+- `status_code`: upstream response code from arXiv.
+- `cooldown_remaining_seconds`: remaining cooldown when blocked or after 429.
+- `source_path`: caller path (`search` or `lookup_ids`).
+
+## Quick SQL Checks
+```sql
+SELECT state_key, next_allowed_at, cooldown_until, updated_at
+FROM arxiv_runtime_state;
+```
+
+```sql
+SELECT count(*) AS cache_rows, min(expires_at) AS earliest_expiry, max(expires_at) AS latest_expiry
+FROM arxiv_query_cache_entries;
+```
+
+## Common Scenarios
+1. Repeated `arxiv.cooldown_activated` events:
+- Confirm recent `429` statuses in `arxiv.request_completed`.
+- Reduce caller pressure (check new title-quality/identifier guards are active).
+- Temporarily raise `ARXIV_RATE_LIMIT_COOLDOWN_SECONDS` if upstream remains strict.
+
+2. High request latency with few completions:
+- Inspect `wait_seconds` in `arxiv.request_scheduled`.
+- Verify only one process path is repeatedly hitting arXiv (`source_path`).
+- Confirm cache is enabled (`ARXIV_CACHE_TTL_SECONDS > 0`) and effective (`cache_hit` appears).
+
+3. Low cache effectiveness:
+- Validate normalized query behavior and caller churn.
+- Increase `ARXIV_CACHE_TTL_SECONDS` for stable workloads.
+- Increase `ARXIV_CACHE_MAX_ENTRIES` if heavy eviction is observed.
+
+## Safe Recovery
+1. Pause automated ingestion if rate-limit storms persist.
+2. Let cooldown expire naturally; avoid manual burst retries.
+3. Resume and monitor event rates before restoring full load.
diff --git a/docs/operations/overview.md b/docs/operations/overview.md
index 36cae41..f208a7d 100644
--- a/docs/operations/overview.md
+++ b/docs/operations/overview.md
@@ -3,5 +3,6 @@
 Use this section for production operations and incident/runbook workflows.
 
 - [Scrape Safety Runbook](./scrape-safety-runbook.md)
+- [arXiv Runbook](./arxiv-runbook.md)
 - [Database Runbook](./database-runbook.md)
 - [Migration Rollout Checklist](./migration-checklist.md)
diff --git a/docs/reference/environment.md b/docs/reference/environment.md
index 0dafb9b..75cc192 100644
--- a/docs/reference/environment.md
+++ b/docs/reference/environment.md
@@ -40,7 +40,7 @@ This document is the source-of-truth audit for what remains configurable versus
 
 ### Scheduler + Ingestion Safety
 
-`SCHEDULER_ENABLED`, `SCHEDULER_TICK_SECONDS`, `SCHEDULER_QUEUE_BATCH_SIZE`, `INGESTION_AUTOMATION_ALLOWED`, `INGESTION_MANUAL_RUN_ALLOWED`, `INGESTION_MIN_RUN_INTERVAL_MINUTES`, `INGESTION_MIN_REQUEST_DELAY_SECONDS`, `INGESTION_NETWORK_ERROR_RETRIES`, `INGESTION_RETRY_BACKOFF_SECONDS`, `INGESTION_MAX_PAGES_PER_SCHOLAR`, `INGESTION_PAGE_SIZE`, `INGESTION_ALERT_BLOCKED_FAILURE_THRESHOLD`, `INGESTION_ALERT_NETWORK_FAILURE_THRESHOLD`, `INGESTION_ALERT_RETRY_SCHEDULED_THRESHOLD`, `INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS`, `INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS`, `INGESTION_CONTINUATION_QUEUE_ENABLED`, `INGESTION_CONTINUATION_BASE_DELAY_SECONDS`, `INGESTION_CONTINUATION_MAX_DELAY_SECONDS`, `INGESTION_CONTINUATION_MAX_ATTEMPTS`
+`SCHEDULER_ENABLED`, `SCHEDULER_TICK_SECONDS`, `SCHEDULER_QUEUE_BATCH_SIZE`, `SCHEDULER_PDF_QUEUE_BATCH_SIZE`, `INGESTION_AUTOMATION_ALLOWED`, `INGESTION_MANUAL_RUN_ALLOWED`, `INGESTION_MIN_RUN_INTERVAL_MINUTES`, `INGESTION_MIN_REQUEST_DELAY_SECONDS`, `INGESTION_NETWORK_ERROR_RETRIES`, `INGESTION_RETRY_BACKOFF_SECONDS`, `INGESTION_RATE_LIMIT_RETRIES`, `INGESTION_RATE_LIMIT_BACKOFF_SECONDS`, `INGESTION_MAX_PAGES_PER_SCHOLAR`, `INGESTION_PAGE_SIZE`, `INGESTION_ALERT_BLOCKED_FAILURE_THRESHOLD`, `INGESTION_ALERT_NETWORK_FAILURE_THRESHOLD`, `INGESTION_ALERT_RETRY_SCHEDULED_THRESHOLD`, `INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS`, `INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS`, `INGESTION_CONTINUATION_QUEUE_ENABLED`, `INGESTION_CONTINUATION_BASE_DELAY_SECONDS`, `INGESTION_CONTINUATION_MAX_DELAY_SECONDS`, `INGESTION_CONTINUATION_MAX_ATTEMPTS`
 
 ### Scholar Images + Name Search Safety
 
@@ -48,7 +48,7 @@ This document is the source-of-truth audit for what remains configurable versus
 
 ### OA Enrichment + PDF Resolution
 
-`UNPAYWALL_ENABLED`, `UNPAYWALL_EMAIL`, `UNPAYWALL_TIMEOUT_SECONDS`, `UNPAYWALL_MIN_INTERVAL_SECONDS`, `UNPAYWALL_MAX_ITEMS_PER_REQUEST`, `UNPAYWALL_RETRY_COOLDOWN_SECONDS`, `UNPAYWALL_PDF_DISCOVERY_ENABLED`, `UNPAYWALL_PDF_DISCOVERY_MAX_CANDIDATES`, `UNPAYWALL_PDF_DISCOVERY_MAX_HTML_BYTES`, `PDF_AUTO_RETRY_INTERVAL_SECONDS`, `PDF_AUTO_RETRY_FIRST_INTERVAL_SECONDS`, `PDF_AUTO_RETRY_MAX_ATTEMPTS`, `CROSSREF_ENABLED`, `CROSSREF_MAX_ROWS`, `CROSSREF_TIMEOUT_SECONDS`, `CROSSREF_MIN_INTERVAL_SECONDS`, `CROSSREF_MAX_LOOKUPS_PER_REQUEST`
+`UNPAYWALL_ENABLED`, `UNPAYWALL_EMAIL`, `UNPAYWALL_TIMEOUT_SECONDS`, `UNPAYWALL_MIN_INTERVAL_SECONDS`, `UNPAYWALL_MAX_ITEMS_PER_REQUEST`, `UNPAYWALL_RETRY_COOLDOWN_SECONDS`, `UNPAYWALL_PDF_DISCOVERY_ENABLED`, `UNPAYWALL_PDF_DISCOVERY_MAX_CANDIDATES`, `UNPAYWALL_PDF_DISCOVERY_MAX_HTML_BYTES`, `ARXIV_ENABLED`, `ARXIV_TIMEOUT_SECONDS`, `ARXIV_MIN_INTERVAL_SECONDS`, `ARXIV_RATE_LIMIT_COOLDOWN_SECONDS`, `ARXIV_DEFAULT_MAX_RESULTS`, `ARXIV_CACHE_TTL_SECONDS`, `ARXIV_CACHE_MAX_ENTRIES`, `ARXIV_MAILTO`, `PDF_AUTO_RETRY_INTERVAL_SECONDS`, `PDF_AUTO_RETRY_FIRST_INTERVAL_SECONDS`, `PDF_AUTO_RETRY_MAX_ATTEMPTS`, `CROSSREF_ENABLED`, `CROSSREF_MAX_ROWS`, `CROSSREF_TIMEOUT_SECONDS`, `CROSSREF_MIN_INTERVAL_SECONDS`, `CROSSREF_MAX_LOOKUPS_PER_REQUEST`, `OPENALEX_API_KEY`, `CROSSREF_API_TOKEN`, `CROSSREF_API_MAILTO`
 
 ### Startup Bootstrap + DB Wait
 
diff --git a/frontend/src/components/ui/AppBrandMark.vue b/frontend/src/components/ui/AppBrandMark.vue
index 0061ca4..f60e405 100644
--- a/frontend/src/components/ui/AppBrandMark.vue
+++ b/frontend/src/components/ui/AppBrandMark.vue
@@ -12,15 +12,15 @@ const props = withDefaults(
 
 const sizeClass = computed(() => {
   if (props.size === "sm") {
-    return "h-5 w-5";
+    return "h-7 w-7";
   }
   if (props.size === "lg") {
-    return "h-8 w-8";
+    return "h-10 w-10";
   }
   if (props.size === "xl") {
-    return "h-12 w-12";
+    return "h-14 w-14";
   }
-  return "h-6 w-6";
+  return "h-7 w-7";
 });
 
 const logoMaskStyle: Record<string, string> = {
diff --git a/frontend/src/features/admin_dbops/index.ts b/frontend/src/features/admin_dbops/index.ts
index 0b16b3a..aa4a312 100644
--- a/frontend/src/features/admin_dbops/index.ts
+++ b/frontend/src/features/admin_dbops/index.ts
@@ -95,6 +95,40 @@ export interface TriggerPublicationLinkRepairResult {
   summary: Record<string, unknown>;
 }
 
+export interface NearDuplicateClusterMember {
+  publication_id: number;
+  title: string;
+  year: number | null;
+  citation_count: number;
+}
+
+export interface NearDuplicateCluster {
+  cluster_key: string;
+  winner_publication_id: number;
+  member_count: number;
+  similarity_score: number;
+  members: NearDuplicateClusterMember[];
+}
+
+export interface TriggerPublicationNearDuplicateRepairPayload {
+  dry_run?: boolean;
+  similarity_threshold?: number;
+  min_shared_tokens?: number;
+  max_year_delta?: number;
+  max_clusters?: number;
+  selected_cluster_keys?: string[];
+  requested_by?: string;
+  confirmation_text?: string;
+}
+
+export interface TriggerPublicationNearDuplicateRepairResult {
+  job_id: number;
+  status: string;
+  scope: Record<string, unknown>;
+  summary: Record<string, unknown>;
+  clusters: NearDuplicateCluster[];
+}
+
 export async function getAdminDbIntegrityReport(): Promise<AdminDbIntegrityReport> {
   const response = await apiRequest<AdminDbIntegrityReport>("/admin/db/integrity", { method: "GET" });
   return response.data;
@@ -122,6 +156,19 @@ export async function triggerPublicationLinkRepair(
   return response.data;
 }
 
+export async function triggerPublicationNearDuplicateRepair(
+  payload: TriggerPublicationNearDuplicateRepairPayload,
+): Promise<TriggerPublicationNearDuplicateRepairResult> {
+  const response = await apiRequest<TriggerPublicationNearDuplicateRepairResult>(
+    "/admin/db/repairs/publication-near-duplicates",
+    {
+      method: "POST",
+      body: payload,
+    },
+  );
+  return response.data;
+}
+
 export async function listAdminPdfQueue(
   page = 1,
   pageSize = 100,
diff --git a/frontend/src/features/publications/index.ts b/frontend/src/features/publications/index.ts
index 3f80806..a689ba9 100644
--- a/frontend/src/features/publications/index.ts
+++ b/frontend/src/features/publications/index.ts
@@ -1,6 +1,13 @@
 import { apiRequest } from "@/lib/api/client";
 
 export type PublicationMode = "all" | "unread" | "latest";
+export type PublicationSortBy =
+  | "first_seen"
+  | "title"
+  | "year"
+  | "citations"
+  | "scholar"
+  | "pdf_status";
 
 export interface DisplayIdentifier {
   kind: string;
@@ -54,7 +61,7 @@ export interface PublicationsQuery {
   favoriteOnly?: boolean;
   scholarProfileId?: number;
   search?: string;
-  sortBy?: string;
+  sortBy?: PublicationSortBy;
   sortDir?: "asc" | "desc";
   page?: number;
   pageSize?: number;
diff --git a/frontend/src/features/settings/SettingsAdminPanel.vue b/frontend/src/features/settings/SettingsAdminPanel.vue
index e5edfb4..9225ba5 100644
--- a/frontend/src/features/settings/SettingsAdminPanel.vue
+++ b/frontend/src/features/settings/SettingsAdminPanel.vue
@@ -20,11 +20,14 @@ import {
   listAdminPdfQueue,
   requeueAdminPdfLookup,
   requeueAllAdminPdfLookups,
+  triggerPublicationNearDuplicateRepair,
   triggerPublicationLinkRepair,
   type AdminDbIntegrityCheck,
   type AdminDbIntegrityReport,
   type AdminDbRepairJob,
   type AdminPdfQueueItem,
+  type NearDuplicateCluster,
+  type TriggerPublicationNearDuplicateRepairResult,
   type TriggerPublicationLinkRepairResult,
 } from "@/features/admin_dbops";
 import {
@@ -43,6 +46,7 @@ const SECTION_PDF = "pdf";
 const SCOPE_SINGLE_USER = "single_user";
 const SCOPE_ALL_USERS = "all_users";
 const APPLY_ALL_USERS_CONFIRM_TEXT = "REPAIR ALL USERS";
+const APPLY_NEAR_DUPLICATES_CONFIRM_TEXT = "MERGE SELECTED DUPLICATES";
 const DROP_PUBLICATIONS_CONFIRM_TEXT = "DROP ALL PUBLICATIONS";
 
 type RepairScopeMode = typeof SCOPE_SINGLE_USER | typeof SCOPE_ALL_USERS;
@@ -82,6 +86,17 @@ const repairRequestedBy = ref("");
 const repairDryRun = ref(true);
 const repairGcOrphans = ref(false);
 const repairConfirmationText = ref("");
+const runningNearDuplicateScan = ref(false);
+const applyingNearDuplicateRepair = ref(false);
+const nearDuplicateRequestedBy = ref("");
+const nearDuplicateSimilarityThreshold = ref("0.78");
+const nearDuplicateMinSharedTokens = ref("3");
+const nearDuplicateMaxYearDelta = ref("1");
+const nearDuplicateMaxClusters = ref("25");
+const nearDuplicateConfirmationText = ref("");
+const nearDuplicateSelectedClusterKeys = ref<Set<string>>(new Set());
+const nearDuplicateClusters = ref<NearDuplicateCluster[]>([]);
+const lastNearDuplicateResult = ref<TriggerPublicationNearDuplicateRepairResult | null>(null);
 
 const droppingPublications = ref(false);
 const dropConfirmationText = ref("");
@@ -105,6 +120,7 @@ const activeUser = computed(() => users.value.find((user) => user.id === activeU
 const typedConfirmationRequired = computed(
   () => repairScopeMode.value === SCOPE_ALL_USERS && !repairDryRun.value,
 );
+const nearDuplicateApplyEnabled = computed(() => nearDuplicateSelectedClusterKeys.value.size > 0);
 const pdfQueuePageSizeValue = computed(() => {
   const parsed = Number(pdfQueuePageSize.value);
   if (!Number.isFinite(parsed)) {
@@ -213,6 +229,64 @@ function validateTypedConfirmation(): string {
   return normalized;
 }
 
+function parseBoundedNumber(
+  raw: string,
+  options: { minimum: number; maximum: number; fallback: number },
+): number {
+  const { minimum, maximum, fallback } = options;
+  const parsed = Number(raw.trim());
+  if (!Number.isFinite(parsed)) {
+    return fallback;
+  }
+  return Math.max(minimum, Math.min(maximum, parsed));
+}
+
+function nearDuplicatePayloadBase(): {
+  similarity_threshold: number;
+  min_shared_tokens: number;
+  max_year_delta: number;
+  max_clusters: number;
+  requested_by: string | undefined;
+} {
+  return {
+    similarity_threshold: parseBoundedNumber(nearDuplicateSimilarityThreshold.value, {
+      minimum: 0.5,
+      maximum: 1.0,
+      fallback: 0.78,
+    }),
+    min_shared_tokens: Math.trunc(
+      parseBoundedNumber(nearDuplicateMinSharedTokens.value, {
+        minimum: 1,
+        maximum: 8,
+        fallback: 3,
+      }),
+    ),
+    max_year_delta: Math.trunc(
+      parseBoundedNumber(nearDuplicateMaxYearDelta.value, {
+        minimum: 0,
+        maximum: 5,
+        fallback: 1,
+      }),
+    ),
+    max_clusters: Math.trunc(
+      parseBoundedNumber(nearDuplicateMaxClusters.value, {
+        minimum: 1,
+        maximum: 200,
+        fallback: 25,
+      }),
+    ),
+    requested_by: nearDuplicateRequestedBy.value.trim() || undefined,
+  };
+}
+
+function selectedNearDuplicateKeys(): string[] {
+  return [...nearDuplicateSelectedClusterKeys.value].sort((left, right) => left.localeCompare(right));
+}
+
+function checkboxEventChecked(event: Event): boolean {
+  return event.target instanceof HTMLInputElement ? event.target.checked : false;
+}
+
 function summaryCount(job: AdminDbRepairJob, key: string): string {
   const value = job.summary[key];
   return typeof value === "number" ? String(value) : "n/a";
@@ -384,6 +458,67 @@ async function onRunRepair(): Promise<void> {
   }
 }
 
+function onToggleNearDuplicateClusterSelection(clusterKey: string, checked: boolean): void {
+  const next = new Set(nearDuplicateSelectedClusterKeys.value);
+  if (checked) {
+    next.add(clusterKey);
+  } else {
+    next.delete(clusterKey);
+  }
+  nearDuplicateSelectedClusterKeys.value = next;
+}
+
+async function onRunNearDuplicateScan(): Promise<void> {
+  runningNearDuplicateScan.value = true;
+  clearAlerts();
+  try {
+    const result = await triggerPublicationNearDuplicateRepair({
+      dry_run: true,
+      ...nearDuplicatePayloadBase(),
+    });
+    nearDuplicateClusters.value = result.clusters;
+    nearDuplicateSelectedClusterKeys.value = new Set();
+    nearDuplicateConfirmationText.value = "";
+    lastNearDuplicateResult.value = result;
+    successMessage.value = `Near-duplicate scan completed (job #${result.job_id}).`;
+    await refreshRepairJobs();
+  } catch (error) {
+    assignError(error, "Unable to scan for near-duplicate publications.");
+  } finally {
+    runningNearDuplicateScan.value = false;
+  }
+}
+
+async function onApplyNearDuplicateRepair(): Promise<void> {
+  applyingNearDuplicateRepair.value = true;
+  clearAlerts();
+  try {
+    const selectedKeys = selectedNearDuplicateKeys();
+    if (selectedKeys.length === 0) {
+      throw new Error("Select at least one near-duplicate cluster before applying.");
+    }
+    if (nearDuplicateConfirmationText.value.trim() !== APPLY_NEAR_DUPLICATES_CONFIRM_TEXT) {
+      throw new Error(`Type '${APPLY_NEAR_DUPLICATES_CONFIRM_TEXT}' to confirm merge.`);
+    }
+    const result = await triggerPublicationNearDuplicateRepair({
+      dry_run: false,
+      selected_cluster_keys: selectedKeys,
+      confirmation_text: nearDuplicateConfirmationText.value.trim(),
+      ...nearDuplicatePayloadBase(),
+    });
+    nearDuplicateClusters.value = result.clusters;
+    nearDuplicateSelectedClusterKeys.value = new Set();
+    nearDuplicateConfirmationText.value = "";
+    lastNearDuplicateResult.value = result;
+    successMessage.value = `Merged selected near-duplicate clusters (job #${result.job_id}).`;
+    await refreshRepairJobs();
+  } catch (error) {
+    assignError(error, "Unable to apply near-duplicate merge.");
+  } finally {
+    applyingNearDuplicateRepair.value = false;
+  }
+}
+
 function onScopeModeChange(): void {
   ensureRepairUserSelected();
 }
@@ -672,6 +807,98 @@ watch(
           </div>
         </AppCard>
 
+        <AppCard class="space-y-3">
+          <div class="flex items-center gap-1">
+            <h2 class="text-lg font-semibold text-ink-primary">Near-Duplicate Publication Repair</h2>
+            <AppHelpHint text="Run a dry-run scan first, verify candidate clusters, then merge only selected clusters." />
+          </div>
+
+          <form class="grid gap-3 md:grid-cols-2" @submit.prevent="onRunNearDuplicateScan">
+            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+              <span>Similarity threshold</span>
+              <AppInput v-model="nearDuplicateSimilarityThreshold" placeholder="0.78" />
+            </label>
+            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+              <span>Min shared tokens</span>
+              <AppInput v-model="nearDuplicateMinSharedTokens" placeholder="3" />
+            </label>
+            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+              <span>Max year delta</span>
+              <AppInput v-model="nearDuplicateMaxYearDelta" placeholder="1" />
+            </label>
+            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+              <span>Max preview clusters</span>
+              <AppInput v-model="nearDuplicateMaxClusters" placeholder="25" />
+            </label>
+            <label class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2">
+              <span>Requested by (optional)</span>
+              <AppInput v-model="nearDuplicateRequestedBy" placeholder="email/name/ticket id" />
+            </label>
+            <div class="md:col-span-2">
+              <AppButton type="submit" :disabled="runningNearDuplicateScan">
+                {{ runningNearDuplicateScan ? "Scanning..." : "Scan near-duplicate clusters" }}
+              </AppButton>
+            </div>
+          </form>
+
+          <div v-if="nearDuplicateClusters.length > 0" class="space-y-3">
+            <AppTable label="Near duplicate clusters table">
+              <thead>
+                <tr>
+                  <th scope="col">Select</th>
+                  <th scope="col">Cluster</th>
+                  <th scope="col">Winner</th>
+                  <th scope="col">Members</th>
+                  <th scope="col">Similarity</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr v-for="cluster in nearDuplicateClusters" :key="cluster.cluster_key">
+                  <td>
+                    <input
+                      :id="`near-dup-${cluster.cluster_key}`"
+                      class="h-4 w-4 rounded border-stroke-default bg-surface-card"
+                      type="checkbox"
+                      :checked="nearDuplicateSelectedClusterKeys.has(cluster.cluster_key)"
+                      @change="onToggleNearDuplicateClusterSelection(cluster.cluster_key, checkboxEventChecked($event))"
+                    />
+                  </td>
+                  <td class="font-mono text-xs">{{ cluster.cluster_key }}</td>
+                  <td>#{{ cluster.winner_publication_id }}</td>
+                  <td>
+                    <div class="grid gap-1">
+                      <span v-for="member in cluster.members" :key="member.publication_id" class="text-xs text-secondary">
+                        #{{ member.publication_id }} · {{ member.title }}
+                      </span>
+                    </div>
+                  </td>
+                  <td>{{ cluster.similarity_score.toFixed(2) }}</td>
+                </tr>
+              </tbody>
+            </AppTable>
+
+            <form class="grid gap-3 md:grid-cols-2" @submit.prevent="onApplyNearDuplicateRepair">
+              <label class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2">
+                <span>Type '{{ APPLY_NEAR_DUPLICATES_CONFIRM_TEXT }}' to merge selected clusters</span>
+                <AppInput v-model="nearDuplicateConfirmationText" :placeholder="APPLY_NEAR_DUPLICATES_CONFIRM_TEXT" />
+              </label>
+              <div class="md:col-span-2">
+                <AppButton type="submit" :disabled="applyingNearDuplicateRepair || !nearDuplicateApplyEnabled">
+                  {{ applyingNearDuplicateRepair ? "Merging..." : "Merge selected clusters" }}
+                </AppButton>
+              </div>
+            </form>
+          </div>
+
+          <div v-if="lastNearDuplicateResult" class="rounded-lg border border-stroke-default bg-surface-card-muted p-3 text-xs">
+            <div class="mb-2 flex flex-wrap items-center gap-2">
+              <AppBadge :tone="statusTone(lastNearDuplicateResult.status)">Job #{{ lastNearDuplicateResult.job_id }}</AppBadge>
+              <span class="text-secondary">Status: {{ lastNearDuplicateResult.status }}</span>
+            </div>
+            <pre class="overflow-x-auto text-secondary">{{ JSON.stringify(lastNearDuplicateResult.summary, null, 2) }}</pre>
+          </div>
+        </AppCard>
+
         <AppCard class="space-y-3">
           <div class="flex flex-wrap items-center justify-between gap-2">
             <div class="flex items-center gap-1">
diff --git a/frontend/src/pages/DashboardPage.vue b/frontend/src/pages/DashboardPage.vue
index 90d8513..fce9e02 100644
--- a/frontend/src/pages/DashboardPage.vue
+++ b/frontend/src/pages/DashboardPage.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { computed, onMounted, ref, watch } from "vue";
+import { computed, onMounted, onUnmounted, ref, watch } from "vue";
 
 import { fetchDashboardSnapshot, type DashboardSnapshot } from "@/features/dashboard";
 import { ApiRequestError } from "@/lib/api/errors";
@@ -26,6 +26,8 @@ const refreshingAfterCompletion = ref(false);
 const auth = useAuthStore();
 const runStatus = useRunStatusStore();
 const userSettings = useUserSettingsStore();
+const DASHBOARD_RUN_STATUS_SYNC_INTERVAL_MS = 5000;
+let runStatusSyncTimer: ReturnType<typeof setInterval> | null = null;
 
 const isStartBlocked = computed(
   () =>
@@ -145,13 +147,35 @@ function shouldRefreshAfterRunChange(
   if (!nextRun || !previousRun) {
     return false;
   }
-  if (nextRun.status === "running") {
-    return false;
-  }
   if (nextRun.id !== previousRun.id) {
     return true;
   }
-  return previousRun.status === "running";
+  if (nextRun.status === previousRun.status) {
+    return false;
+  }
+  const nextActive = nextRun.status === "running" || nextRun.status === "resolving";
+  const previousActive = previousRun.status === "running" || previousRun.status === "resolving";
+  return nextActive || previousActive;
+}
+
+function startRunStatusSyncLoop(): void {
+  if (runStatusSyncTimer !== null) {
+    return;
+  }
+  runStatusSyncTimer = setInterval(() => {
+    if (runStatus.isRunActive) {
+      return;
+    }
+    void runStatus.syncLatest();
+  }, DASHBOARD_RUN_STATUS_SYNC_INTERVAL_MS);
+}
+
+function stopRunStatusSyncLoop(): void {
+  if (runStatusSyncTimer === null) {
+    return;
+  }
+  clearInterval(runStatusSyncTimer);
+  runStatusSyncTimer = null;
 }
 
 async function loadSnapshot(): Promise<void> {
@@ -228,10 +252,15 @@ async function onCancelRun(): Promise<void> {
 }
 
 onMounted(() => {
+  startRunStatusSyncLoop();
   void loadSnapshot();
   void runStatus.syncLatest();
 });
 
+onUnmounted(() => {
+  stopRunStatusSyncLoop();
+});
+
 watch(
   () => runStatus.latestRun,
   (nextRun, previousRun) => {
@@ -372,7 +401,7 @@ watch(
                       <AppButton
                         v-if="auth.isAdmin && runStatus.isLikelyRunning"
                         variant="danger"
-                        :disabled="!activeRunId || isCancelAnimating.value"
+                        :disabled="!activeRunId || isCancelAnimating"
                         @click="onCancelRun"
                       >
                         <span class="inline-flex items-center gap-2">
diff --git a/frontend/src/pages/PublicationsPage.vue b/frontend/src/pages/PublicationsPage.vue
index 35b7f06..e94074d 100644
--- a/frontend/src/pages/PublicationsPage.vue
+++ b/frontend/src/pages/PublicationsPage.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { computed, onMounted, ref, watch } from "vue";
+import { computed, onMounted, onUnmounted, ref, watch } from "vue";
 import { useRoute, useRouter } from "vue-router";
 
 import AppPage from "@/components/layout/AppPage.vue";
@@ -33,7 +33,8 @@ type PublicationSortKey =
   | "scholar"
   | "year"
   | "citations"
-  | "first_seen";
+  | "first_seen"
+  | "pdf_status";
 
 type BulkAction =
   | "mark_selected_read"
@@ -70,6 +71,8 @@ const router = useRouter();
 const textCollator = new Intl.Collator(undefined, { sensitivity: "base", numeric: true });
 const runStatus = useRunStatusStore();
 const userSettings = useUserSettingsStore();
+const PUBLICATIONS_RUN_STATUS_SYNC_INTERVAL_MS = 5000;
+let runStatusSyncTimer: ReturnType<typeof setInterval> | null = null;
 
 function normalizeScholarFilterQuery(value: unknown): string {
   if (Array.isArray(value)) {
@@ -179,6 +182,26 @@ function publicationIdentifierLabel(item: PublicationItem): string | null {
   return item.display_identifier?.label ?? null;
 }
 
+function startRunStatusSyncLoop(): void {
+  if (runStatusSyncTimer !== null) {
+    return;
+  }
+  runStatusSyncTimer = setInterval(() => {
+    if (runStatus.isRunActive) {
+      return;
+    }
+    void runStatus.syncLatest();
+  }, PUBLICATIONS_RUN_STATUS_SYNC_INTERVAL_MS);
+}
+
+function stopRunStatusSyncLoop(): void {
+  if (runStatusSyncTimer === null) {
+    return;
+  }
+  clearInterval(runStatusSyncTimer);
+  runStatusSyncTimer = null;
+}
+
 const selectedScholarName = computed(() => {
   const selectedId = Number(selectedScholarFilter.value);
   if (!Number.isInteger(selectedId) || selectedId <= 0) {
@@ -203,11 +226,12 @@ const filteredPublications = computed(() => {
 
   const base = listState.value?.publications ?? [];
   const merged = [...stream, ...base];
-  const seenIds = new Set();
+  const seenKeys = new Set<string>();
   const deduped: typeof base = [];
   for (const item of merged) {
-    if (!seenIds.has(item.publication_id)) {
-      seenIds.add(item.publication_id);
+    const key = publicationKey(item);
+    if (!seenKeys.has(key)) {
+      seenKeys.add(key);
       deduped.push(item);
     }
   }
@@ -234,14 +258,41 @@ function publicationSortValue(item: PublicationItem, key: PublicationSortKey): n
   if (key === "citations") {
     return item.citation_count;
   }
+  if (key === "pdf_status") {
+    if (item.pdf_url || item.pdf_status === "resolved") {
+      return 4;
+    }
+    if (item.pdf_status === "running") {
+      return 3;
+    }
+    if (item.pdf_status === "queued") {
+      return 2;
+    }
+    if (item.pdf_status === "failed") {
+      return 0;
+    }
+    return 1;
+  }
   const timestamp = Date.parse(item.first_seen_at);
   return Number.isNaN(timestamp) ? 0 : timestamp;
 }
 
 const sortedPublications = computed(() => {
-  // Server already returns data in the correct sort order.
-  // We just pass through the filtered/merged list without client-side re-sorting.
-  return filteredPublications.value;
+  const direction = sortDirection.value === "asc" ? 1 : -1;
+  return [...filteredPublications.value].sort((left, right) => {
+    const leftValue = publicationSortValue(left, sortKey.value);
+    const rightValue = publicationSortValue(right, sortKey.value);
+    let comparison = 0;
+    if (typeof leftValue === "string" && typeof rightValue === "string") {
+      comparison = textCollator.compare(leftValue, rightValue);
+    } else {
+      comparison = Number(leftValue) - Number(rightValue);
+    }
+    if (comparison !== 0) {
+      return comparison * direction;
+    }
+    return right.publication_id - left.publication_id;
+  });
 });
 
 const visibleUnreadKeys = computed(() => {
@@ -271,6 +322,7 @@ const totalPages = computed(() => {
 });
 
 const selectedCount = computed(() => selectedPublicationKeys.value.size);
+const totalCount = computed(() => listState.value?.total_count ?? 0);
 const visibleCount = computed(() => sortedPublications.value.length);
 const visibleUnreadCount = computed(() => visibleUnreadKeys.value.size);
 const visibleFavoriteCount = computed(
@@ -432,7 +484,7 @@ async function toggleSort(nextKey: PublicationSortKey): Promise<void> {
     sortDirection.value = sortDirection.value === "asc" ? "desc" : "asc";
   } else {
     sortKey.value = nextKey;
-    sortDirection.value = nextKey === "first_seen" ? "desc" : "asc";
+    sortDirection.value = nextKey === "first_seen" || nextKey === "pdf_status" ? "desc" : "asc";
   }
   currentPage.value = 1;
   publicationSnapshot.value = null;
@@ -800,9 +852,32 @@ watch(searchQuery, () => {
 
 onMounted(() => {
   syncFiltersFromRoute();
+  startRunStatusSyncLoop();
   void Promise.all([loadScholarFilters(), loadPublications(), runStatus.syncLatest()]);
 });
 
+onUnmounted(() => {
+  stopRunStatusSyncLoop();
+});
+
+watch(
+  () => runStatus.latestRun,
+  async (nextRun, previousRun) => {
+    const nextRunId = nextRun && (nextRun.status === "running" || nextRun.status === "resolving")
+      ? nextRun.id
+      : null;
+    const previousRunId = previousRun && (previousRun.status === "running" || previousRun.status === "resolving")
+      ? previousRun.id
+      : null;
+    if (nextRunId === null || nextRunId === previousRunId) {
+      return;
+    }
+    publicationSnapshot.value = null;
+    currentPage.value = 1;
+    await loadPublications();
+  },
+);
+
 watch(
   () => [route.query.scholar, route.query.favorite, route.query.page],
   async () => {
@@ -1008,7 +1083,11 @@ watch(
                   Scholar <span aria-hidden="true" class="sort-marker">{{ sortMarker('scholar') }}</span>
                 </button>
               </th>
-              <th scope="col" class="w-[8.5rem] whitespace-nowrap text-left font-semibold text-ink-primary">PDF</th>
+              <th scope="col" class="w-[8.5rem] whitespace-nowrap">
+                <button type="button" class="table-sort" @click="toggleSort('pdf_status')">
+                  PDF <span aria-hidden="true" class="sort-marker">{{ sortMarker('pdf_status') }}</span>
+                </button>
+              </th>
               <th scope="col" class="w-16 whitespace-nowrap">
                 <button type="button" class="table-sort" @click="toggleSort('year')">
                   Year <span aria-hidden="true" class="sort-marker">{{ sortMarker('year') }}</span>
@@ -1135,7 +1214,7 @@ watch(
 
       <div class="flex flex-wrap items-center justify-between gap-2 border-t border-stroke-default pt-2 text-xs text-secondary">
         <span>
-          visible {{ visibleCount }} · unread {{ visibleUnreadCount }} · favorites {{ visibleFavoriteCount }}
+          total {{ totalCount }} · visible {{ visibleCount }} · unread {{ visibleUnreadCount }} · favorites {{ visibleFavoriteCount }}
           · selected {{ selectedCount }}
         </span>
         <div class="flex items-center gap-2">
diff --git a/frontend/src/pages/ScholarsPage.vue b/frontend/src/pages/ScholarsPage.vue
index a8794f2..1620128 100644
--- a/frontend/src/pages/ScholarsPage.vue
+++ b/frontend/src/pages/ScholarsPage.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from "vue";
+import { computed, onMounted, onUnmounted, ref, watch } from "vue";
 
 import AppPage from "@/components/layout/AppPage.vue";
 import AsyncStateGate from "@/components/patterns/AsyncStateGate.vue";
@@ -34,6 +34,7 @@ import {
 } from "@/features/scholars";
 import ScholarAvatar from "@/features/scholars/components/ScholarAvatar.vue";
 import { ApiRequestError } from "@/lib/api/errors";
+import { useRunStatusStore } from "@/stores/run_status";
 
 const loading = ref(true);
 const saving = ref(false);
@@ -66,6 +67,10 @@ const successMessage = ref<string | null>(null);
 const SCHOLAR_ID_PATTERN = /^[a-zA-Z0-9_-]{12}$/;
 const URL_USER_PARAM_PATTERN = /(?:\?|&)user=([a-zA-Z0-9_-]{12})(?:&|#|$)/i;
 const nameSearchWip = true;
+const SCHOLARS_LIVE_SYNC_INTERVAL_MS = 4000;
+let scholarsLiveSyncTimer: ReturnType<typeof setInterval> | null = null;
+
+const runStatus = useRunStatusStore();
 
 const trackedScholarIds = computed(() => new Set(scholars.value.map((item) => item.scholar_id)));
 const activeScholarSettings = computed(
@@ -260,14 +265,54 @@ function syncImageDrafts(): void {
   imageUrlDraftByScholarId.value = next;
 }
 
+function applyScholarList(nextScholars: ScholarProfile[]): void {
+  scholars.value = nextScholars;
+  syncImageDrafts();
+}
+
+function upsertScholar(profile: ScholarProfile): void {
+  const existingIndex = scholars.value.findIndex((item) => item.id === profile.id);
+  if (existingIndex < 0) {
+    applyScholarList([profile, ...scholars.value]);
+    return;
+  }
+  const next = [...scholars.value];
+  next[existingIndex] = profile;
+  applyScholarList(next);
+}
+
+function stopScholarLiveSync(): void {
+  if (scholarsLiveSyncTimer === null) {
+    return;
+  }
+  clearInterval(scholarsLiveSyncTimer);
+  scholarsLiveSyncTimer = null;
+}
+
+function startScholarLiveSync(): void {
+  if (scholarsLiveSyncTimer !== null) {
+    return;
+  }
+  scholarsLiveSyncTimer = setInterval(() => {
+    void refreshScholarsSilently();
+  }, SCHOLARS_LIVE_SYNC_INTERVAL_MS);
+}
+
+async function refreshScholarsSilently(): Promise<void> {
+  try {
+    applyScholarList(await listScholars());
+  } catch (_error) {
+    // Keep existing list when transient refresh fails.
+  }
+}
+
 async function loadScholars(): Promise<void> {
   loading.value = true;
 
   try {
-    scholars.value = await listScholars();
-    syncImageDrafts();
+    applyScholarList(await listScholars());
   } catch (error) {
-    scholars.value = [];
+    applyScholarList([]);
     if (error instanceof ApiRequestError) {
       errorMessage.value = error.message;
       errorRequestId.value = error.requestId;
@@ -360,7 +405,11 @@ async function onAddScholars(): Promise<void> {
     }
 
     const settled = await Promise.allSettled(
-      scholarIds.map((scholarId) => createScholar({ scholar_id: scholarId })),
+      scholarIds.map(async (scholarId) => {
+        const created = await createScholar({ scholar_id: scholarId });
+        upsertScholar(created);
+        return created;
+      }),
     );
 
     const failures: string[] = [];
@@ -399,7 +448,7 @@ async function onAddScholars(): Promise<void> {
       errorRequestId.value = requestIdFromFailures;
     }
 
-    await loadScholars();
+    await refreshScholarsSilently();
   } catch (error) {
     if (error instanceof ApiRequestError) {
       errorMessage.value = error.message;
@@ -453,12 +502,12 @@ async function onAddCandidate(candidate: ScholarSearchCandidate): Promise<void>
   successMessage.value = null;
 
   try {
-    await createScholar({
+    const created = await createScholar({
       scholar_id: candidate.scholar_id,
       profile_image_url: candidate.profile_image_url ?? undefined,
     });
+    upsertScholar(created);
     successMessage.value = `${candidate.display_name} added.`;
-    await loadScholars();
   } catch (error) {
     if (error instanceof ApiRequestError) {
       errorMessage.value = error.message;
@@ -608,6 +657,22 @@ async function onResetImage(profile: ScholarProfile): Promise<void> {
 onMounted(() => {
   void loadScholars();
 });
+
+onUnmounted(() => {
+  stopScholarLiveSync();
+});
+
+watch(
+  () => runStatus.isLikelyRunning,
+  (isRunning) => {
+    if (isRunning) {
+      startScholarLiveSync();
+      return;
+    }
+    stopScholarLiveSync();
+  },
+  { immediate: true },
+);
 </script>
 
 <template>
diff --git a/frontend/src/stores/run_status.test.ts b/frontend/src/stores/run_status.test.ts
index 99bf552..53dc875 100644
--- a/frontend/src/stores/run_status.test.ts
+++ b/frontend/src/stores/run_status.test.ts
@@ -49,6 +49,35 @@ function buildRunsPayload(runs: ReturnType<typeof buildRun>[]) {
   };
 }
 
+class FakeEventSource {
+  static instances: FakeEventSource[] = [];
+
+  public readonly url: string;
+  public closed = false;
+  private listeners = new Map<string, Array<(event: { data: string }) => void>>();
+
+  constructor(url: string) {
+    this.url = url;
+    FakeEventSource.instances.push(this);
+  }
+
+  addEventListener(eventType: string, callback: (event: { data: string }) => void): void {
+    const existing = this.listeners.get(eventType) ?? [];
+    this.listeners.set(eventType, [...existing, callback]);
+  }
+
+  emit(eventType: string, payload: unknown): void {
+    const callbacks = this.listeners.get(eventType) ?? [];
+    for (const callback of callbacks) {
+      callback({ data: JSON.stringify(payload) });
+    }
+  }
+
+  close(): void {
+    this.closed = true;
+  }
+}
+
 describe("run status store", () => {
   const mockedListRuns = vi.mocked(listRuns);
   const mockedTriggerManualRun = vi.mocked(triggerManualRun);
@@ -309,4 +338,42 @@ describe("run status store", () => {
 
     expect(store.latestRun?.new_publication_count).toBe(5);
   });
+
+  it("applies identifier_updated SSE events to live publications", () => {
+    const previousEventSource = (globalThis as any).EventSource;
+    FakeEventSource.instances = [];
+    (globalThis as any).EventSource = FakeEventSource as any;
+    try {
+      const store = useRunStatusStore();
+      store.setLatestRun(buildRun({ id: 314, status: "running", end_dt: null }));
+
+      const stream = FakeEventSource.instances[0];
+      expect(stream).toBeDefined();
+      stream.emit("publication_discovered", {
+        publication_id: 22,
+        scholar_profile_id: 7,
+        scholar_label: "Ada Lovelace",
+        title: "Optimization Notes",
+        pub_url: null,
+        first_seen_at: "2026-02-26T10:00:00Z",
+      });
+      expect(store.livePublications).toHaveLength(1);
+      expect(store.livePublications[0].display_identifier).toBeNull();
+
+      stream.emit("identifier_updated", {
+        publication_id: 22,
+        display_identifier: {
+          kind: "doi",
+          value: "10.1000/xyz",
+          label: "DOI: 10.1000/xyz",
+          url: "https://doi.org/10.1000/xyz",
+          confidence_score: 0.95,
+        },
+      });
+      expect(store.livePublications[0].display_identifier?.kind).toBe("doi");
+      expect(store.livePublications[0].display_identifier?.value).toBe("10.1000/xyz");
+    } finally {
+      (globalThis as any).EventSource = previousEventSource;
+    }
+  });
 });
diff --git a/frontend/src/stores/run_status.ts b/frontend/src/stores/run_status.ts
index e5b5cd7..3f90de0 100644
--- a/frontend/src/stores/run_status.ts
+++ b/frontend/src/stores/run_status.ts
@@ -40,6 +40,8 @@ let eventSource: EventSource | null = null;
 let activeStreamRunId: number | null = null;
 const ACTIVE_STATUSES = new Set(["running", "resolving"]);
 
+type StreamDisplayIdentifier = PublicationItem["display_identifier"];
+
 function parseRunId(value: unknown): number | null {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
@@ -86,6 +88,46 @@ function parsePublicationCount(value: unknown, fallback: number): number {
   return fallback;
 }
 
+function parseDisplayIdentifier(value: unknown): StreamDisplayIdentifier {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const payload = value as Record<string, unknown>;
+  if (typeof payload.kind !== "string" || typeof payload.value !== "string" || typeof payload.label !== "string") {
+    return null;
+  }
+  if (typeof payload.confidence_score !== "number" || !Number.isFinite(payload.confidence_score)) {
+    return null;
+  }
+  const url = typeof payload.url === "string" ? payload.url : null;
+  return {
+    kind: payload.kind,
+    value: payload.value,
+    label: payload.label,
+    url,
+    confidence_score: payload.confidence_score,
+  };
+}
+
+function withUpdatedDisplayIdentifier(
+  items: PublicationItem[],
+  update: {
+    publicationId: number;
+    displayIdentifier: StreamDisplayIdentifier;
+  },
+): PublicationItem[] {
+  const { publicationId, displayIdentifier } = update;
+  let changed = false;
+  const next = items.map((item) => {
+    if (item.publication_id !== publicationId) {
+      return item;
+    }
+    changed = true;
+    return { ...item, display_identifier: displayIdentifier };
+  });
+  return changed ? next : items;
+}
+
 function reconcileRunCounters(previous: RunListItem | null, next: RunListItem | null): RunListItem | null {
   if (previous === null || next === null) {
     return next;
@@ -200,7 +242,7 @@ export const useRunStatusStore = defineStore("runStatus", {
       this.updateEventSource();
     },
     updateEventSource(): void {
-      const targetRunId = this.latestRun?.status === "running" ? this.latestRun.id : null;
+      const targetRunId = isActiveStatus(this.latestRun?.status) ? this.latestRun?.id ?? null : null;
       if (activeStreamRunId === targetRunId) {
         return;
       }
@@ -251,6 +293,25 @@ export const useRunStatusStore = defineStore("runStatus", {
             console.error("Failed to parse SSE event", err);
           }
         });
+        eventSource.addEventListener("identifier_updated", (e) => {
+          try {
+            const data = JSON.parse(e.data);
+            const publicationId = parseRunId(data?.publication_id);
+            const displayIdentifier = parseDisplayIdentifier(data?.display_identifier);
+            if (publicationId === null || displayIdentifier === null) {
+              return;
+            }
+            this.livePublications = withUpdatedDisplayIdentifier(
+              this.livePublications,
+              {
+                publicationId,
+                displayIdentifier,
+              },
+            );
+          } catch (err) {
+            console.error("Failed to parse SSE event", err);
+          }
+        });
         eventSource.onerror = () => {
           // Reconnecting is handled automatically by EventSource,
           // but if it's permanently closed, we could do something here.
@@ -429,6 +490,7 @@ export const useRunStatusStore = defineStore("runStatus", {
       this.lastErrorRequestId = null;
       this.lastSyncAt = null;
       this.safetyState = createDefaultSafetyState();
+      this.livePublications = [];
     },
   },
 });
diff --git a/tests/conftest.py b/tests/conftest.py
index 4fa650c..0fb19ed 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -19,6 +19,8 @@ from app.settings import settings
 RESET_SQL = text(
     """
     TRUNCATE TABLE
+      arxiv_query_cache_entries,
+      arxiv_runtime_state,
       author_search_cache_entries,
       author_search_runtime_state,
       data_repair_jobs,
diff --git a/tests/integration/test_api_v1.py b/tests/integration/test_api_v1.py
index e6a5422..7da04a6 100644
--- a/tests/integration/test_api_v1.py
+++ b/tests/integration/test_api_v1.py
@@ -580,6 +580,14 @@ async def test_api_admin_dbops_forbidden_for_non_admin_and_validates_scope(db_se
     assert forbidden_repair.status_code == 403
     assert forbidden_repair.json()["error"]["code"] == "forbidden"
 
+    forbidden_near_duplicate = client.post(
+        "/api/v1/admin/db/repairs/publication-near-duplicates",
+        json={"dry_run": True},
+        headers=headers,
+    )
+    assert forbidden_near_duplicate.status_code == 403
+    assert forbidden_near_duplicate.json()["error"]["code"] == "forbidden"
+
     admin_headers = _api_bootstrap_csrf_headers(client)
     admin_login = client.post(
         "/api/v1/auth/login",
@@ -650,6 +658,138 @@ async def test_api_admin_dbops_all_users_apply_requires_confirmation(db_session:
     assert int(remaining_links.scalar_one()) == 0
 
 
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_admin_dbops_near_duplicate_repair_scan_and_apply(
+    db_session: AsyncSession,
+) -> None:
+    await insert_user(
+        db_session,
+        email="api-admin-near-dup@example.com",
+        password="admin-password",
+        is_admin=True,
+    )
+    user_id = await insert_user(
+        db_session,
+        email="api-near-dup-target@example.com",
+        password="user-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "nearDupScholar01",
+            "display_name": "Near Dup Target",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    first_pub = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, year, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 2014, 100)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 1201):064x}",
+            "title_raw": "Adam: A method for stochastic optimization",
+            "title_normalized": "adam a method for stochastic optimization",
+        },
+    )
+    first_publication_id = int(first_pub.scalar_one())
+    second_pub = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, year, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 2015, 10)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 1202):064x}",
+            "title_raw": "†œAdam: A method for stochastic optimization, †3rd Int. Conf. Learn. Represent.",
+            "title_normalized": "adam method for stochastic optimization",
+        },
+    )
+    second_publication_id = int(second_pub.scalar_one())
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
+            VALUES (:scholar_profile_id, :first_publication_id, false),
+                   (:scholar_profile_id, :second_publication_id, false)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "first_publication_id": first_publication_id,
+            "second_publication_id": second_publication_id,
+        },
+    )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-admin-near-dup@example.com", password="admin-password")
+    headers = _api_csrf_headers(client)
+
+    scan_response = client.post(
+        "/api/v1/admin/db/repairs/publication-near-duplicates",
+        json={"dry_run": True, "max_clusters": 20},
+        headers=headers,
+    )
+    assert scan_response.status_code == 200
+    scan_data = scan_response.json()["data"]
+    assert scan_data["status"] == "completed"
+    assert int(scan_data["summary"]["candidate_cluster_count"]) >= 1
+    assert len(scan_data["clusters"]) >= 1
+    selected_key = str(scan_data["clusters"][0]["cluster_key"])
+
+    missing_confirmation = client.post(
+        "/api/v1/admin/db/repairs/publication-near-duplicates",
+        json={"dry_run": False, "selected_cluster_keys": [selected_key]},
+        headers=headers,
+    )
+    assert missing_confirmation.status_code == 422
+    assert "confirmation_text" in str(missing_confirmation.json())
+
+    apply_response = client.post(
+        "/api/v1/admin/db/repairs/publication-near-duplicates",
+        json={
+            "dry_run": False,
+            "selected_cluster_keys": [selected_key],
+            "confirmation_text": "MERGE SELECTED DUPLICATES",
+        },
+        headers=headers,
+    )
+    assert apply_response.status_code == 200
+    apply_data = apply_response.json()["data"]
+    assert apply_data["status"] == "completed"
+    assert int(apply_data["summary"]["merged_publications"]) >= 1
+
+    remaining = await db_session.execute(
+        text(
+            """
+            SELECT count(*)
+            FROM publications
+            WHERE id IN (:first_publication_id, :second_publication_id)
+            """
+        ),
+        {
+            "first_publication_id": first_publication_id,
+            "second_publication_id": second_publication_id,
+        },
+    )
+    assert int(remaining.scalar_one()) == 1
+
+
 @pytest.mark.integration
 @pytest.mark.db
 @pytest.mark.asyncio
@@ -753,9 +893,11 @@ async def test_api_scholars_search_and_profile_image_management(
 
     previous_upload_dir = settings.scholar_image_upload_dir
     previous_upload_max_bytes = settings.scholar_image_upload_max_bytes
+    previous_queue_enabled = settings.ingestion_continuation_queue_enabled
     app.dependency_overrides[get_scholar_source] = lambda: StubScholarSource()
     object.__setattr__(settings, "scholar_image_upload_dir", str(tmp_path / "scholar_images"))
     object.__setattr__(settings, "scholar_image_upload_max_bytes", 1_000_000)
+    object.__setattr__(settings, "ingestion_continuation_queue_enabled", False)
 
     try:
         client = TestClient(app)
@@ -826,6 +968,7 @@ async def test_api_scholars_search_and_profile_image_management(
             "scholar_image_upload_max_bytes",
             previous_upload_max_bytes,
         )
+        object.__setattr__(settings, "ingestion_continuation_queue_enabled", previous_queue_enabled)
 
 
 @pytest.mark.integration
@@ -1893,6 +2036,190 @@ async def test_api_publications_list_supports_pagination(db_session: AsyncSessio
     assert len(second_data["publications"]) == 1
 
 
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_publications_search_pagination_uses_filtered_total_count(
+    db_session: AsyncSession,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-pubs-search-page@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "searchPagingScholar01",
+            "display_name": "Search Paging Scholar",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    titles = ["Alpha Optimization", "Alpha Learning", "Beta Methods"]
+    publication_ids: list[int] = []
+    for index, title in enumerate(titles):
+        created = await db_session.execute(
+            text(
+                """
+                INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+                VALUES (:fingerprint, :title_raw, :title_normalized, 1)
+                RETURNING id
+                """
+            ),
+            {
+                "fingerprint": f"{(user_id + 900 + index):064x}",
+                "title_raw": title,
+                "title_normalized": title.lower(),
+            },
+        )
+        publication_ids.append(int(created.scalar_one()))
+    for publication_id in publication_ids:
+        await db_session.execute(
+            text(
+                """
+                INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
+                VALUES (:scholar_profile_id, :publication_id, false, false)
+                """
+            ),
+            {"scholar_profile_id": scholar_profile_id, "publication_id": publication_id},
+        )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-pubs-search-page@example.com", password="api-password")
+
+    response = client.get("/api/v1/publications?mode=all&page=1&page_size=2&search=alpha")
+    assert response.status_code == 200
+    data = response.json()["data"]
+    assert int(data["total_count"]) == 2
+    assert data["has_next"] is False
+    assert len(data["publications"]) == 2
+    assert all("alpha" in str(item["title"]).lower() for item in data["publications"])
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_publications_supports_sort_by_pdf_status(
+    db_session: AsyncSession,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-pubs-pdf-sort@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "pdfSortScholar01",
+            "display_name": "PDF Sort Scholar",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+
+    resolved_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count, pdf_url)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 1, :pdf_url)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 1300):064x}",
+            "title_raw": "Resolved PDF",
+            "title_normalized": "resolved pdf",
+            "pdf_url": "https://example.org/resolved.pdf",
+        },
+    )
+    resolved_publication_id = int(resolved_result.scalar_one())
+    queued_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 1)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 1301):064x}",
+            "title_raw": "Queued PDF",
+            "title_normalized": "queued pdf",
+        },
+    )
+    queued_publication_id = int(queued_result.scalar_one())
+    failed_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 1)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 1302):064x}",
+            "title_raw": "Failed PDF",
+            "title_normalized": "failed pdf",
+        },
+    )
+    failed_publication_id = int(failed_result.scalar_one())
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
+            VALUES
+              (:scholar_profile_id, :resolved_publication_id, false, false),
+              (:scholar_profile_id, :queued_publication_id, false, false),
+              (:scholar_profile_id, :failed_publication_id, false, false)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "resolved_publication_id": resolved_publication_id,
+            "queued_publication_id": queued_publication_id,
+            "failed_publication_id": failed_publication_id,
+        },
+    )
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO publication_pdf_jobs (publication_id, status, attempt_count)
+            VALUES (:queued_publication_id, 'queued', 1),
+                   (:failed_publication_id, 'failed', 2)
+            """
+        ),
+        {
+            "queued_publication_id": queued_publication_id,
+            "failed_publication_id": failed_publication_id,
+        },
+    )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-pubs-pdf-sort@example.com", password="api-password")
+
+    response = client.get("/api/v1/publications?mode=all&sort_by=pdf_status&sort_dir=desc")
+    assert response.status_code == 200
+    publications = response.json()["data"]["publications"]
+    publication_ids = [int(item["publication_id"]) for item in publications]
+    assert publication_ids[0] == resolved_publication_id
+    assert publication_ids[-1] == failed_publication_id
+
+
 @pytest.mark.integration
 @pytest.mark.db
 @pytest.mark.asyncio
diff --git a/tests/integration/test_migrations.py b/tests/integration/test_migrations.py
index f8c3e0a..0155cbc 100644
--- a/tests/integration/test_migrations.py
+++ b/tests/integration/test_migrations.py
@@ -13,13 +13,15 @@ EXPECTED_TABLES = {
     "ingestion_queue_items",
     "author_search_runtime_state",
     "author_search_cache_entries",
+    "arxiv_runtime_state",
+    "arxiv_query_cache_entries",
     "data_repair_jobs",
     "publication_pdf_jobs",
     "publication_pdf_job_events",
 }
 
 EXPECTED_ENUMS = {"run_status", "run_trigger_type"}
-EXPECTED_REVISION = "20260225_0022"
+EXPECTED_REVISION = "20260226_0024"
 
 
 @pytest.mark.integration
diff --git a/tests/unit/services/domains/arxiv/test_cache.py b/tests/unit/services/domains/arxiv/test_cache.py
new file mode 100644
index 0000000..2f15891
--- /dev/null
+++ b/tests/unit/services/domains/arxiv/test_cache.py
@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import asyncio
+import gc
+from datetime import datetime, timedelta, timezone
+
+import pytest
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import ArxivQueryCacheEntry
+from app.services.domains.arxiv.cache import (
+    build_query_fingerprint,
+    get_cached_feed,
+    run_with_inflight_dedupe,
+    set_cached_feed,
+)
+from app.services.domains.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
+
+
+def _sample_feed(arxiv_id: str = "1234.5678") -> ArxivFeed:
+    return ArxivFeed(
+        entries=[
+            ArxivEntry(
+                entry_id_url=f"https://arxiv.org/abs/{arxiv_id}",
+                arxiv_id=arxiv_id,
+                title="Sample",
+                summary="Summary",
+                published=None,
+                updated=None,
+            )
+        ],
+        opensearch=ArxivOpenSearchMeta(total_results=1, start_index=0, items_per_page=1),
+    )
+
+
+def test_build_query_fingerprint_normalizes_search_and_id_params() -> None:
+    first = build_query_fingerprint(
+        params={
+            "search_query": '  TI:"Quantum   Fields"   AND AU:"Doe" ',
+            "start": 0,
+            "max_results": 3,
+        }
+    )
+    second = build_query_fingerprint(
+        params={
+            "search_query": 'ti:"quantum fields" and au:"doe"',
+            "start": 0,
+            "max_results": 3,
+        }
+    )
+    third = build_query_fingerprint(params={"id_list": " 2222.0002,1111.0001 "})
+    fourth = build_query_fingerprint(params={"id_list": "1111.0001, 2222.0002"})
+
+    assert first == second
+    assert third == fourth
+
+
+@pytest.mark.asyncio
+async def test_cache_entry_expires_and_is_deleted(db_session: AsyncSession) -> None:
+    query_fingerprint = build_query_fingerprint(params={"search_query": "ti:test", "start": 0})
+    now_utc = datetime(2026, 2, 26, 12, 0, tzinfo=timezone.utc)
+
+    await set_cached_feed(
+        query_fingerprint=query_fingerprint,
+        feed=_sample_feed(),
+        ttl_seconds=5.0,
+        max_entries=16,
+        now_utc=now_utc,
+    )
+
+    hit = await get_cached_feed(
+        query_fingerprint=query_fingerprint,
+        now_utc=now_utc + timedelta(seconds=2),
+    )
+    miss = await get_cached_feed(
+        query_fingerprint=query_fingerprint,
+        now_utc=now_utc + timedelta(seconds=8),
+    )
+
+    result = await db_session.execute(
+        select(ArxivQueryCacheEntry).where(
+            ArxivQueryCacheEntry.query_fingerprint == query_fingerprint
+        )
+    )
+    assert hit is not None
+    assert miss is None
+    assert result.scalar_one_or_none() is None
+
+
+@pytest.mark.asyncio
+async def test_inflight_dedupe_coalesces_identical_requests() -> None:
+    calls = {"count": 0}
+
+    async def _fetch_feed() -> ArxivFeed:
+        calls["count"] += 1
+        await asyncio.sleep(0.05)
+        return _sample_feed("9999.0001")
+
+    first, second = await asyncio.gather(
+        run_with_inflight_dedupe(query_fingerprint="same-key", fetch_feed=_fetch_feed),
+        run_with_inflight_dedupe(query_fingerprint="same-key", fetch_feed=_fetch_feed),
+    )
+
+    assert calls["count"] == 1
+    assert first.entries[0].arxiv_id == "9999.0001"
+    assert second.entries[0].arxiv_id == "9999.0001"
+
+
+@pytest.mark.asyncio
+async def test_inflight_owner_failure_without_joiner_has_no_unretrieved_exception() -> None:
+    loop = asyncio.get_running_loop()
+    messages: list[str] = []
+    previous_handler = loop.get_exception_handler()
+
+    def _capture_exception(_loop, context) -> None:
+        messages.append(str(context.get("message", "")))
+
+    loop.set_exception_handler(_capture_exception)
+    try:
+        async def _failing_fetch() -> ArxivFeed:
+            raise RuntimeError("owner_failed")
+
+        with pytest.raises(RuntimeError, match="owner_failed"):
+            await run_with_inflight_dedupe(
+                query_fingerprint="owner-failure-no-joiner",
+                fetch_feed=_failing_fetch,
+            )
+        gc.collect()
+        await asyncio.sleep(0)
+    finally:
+        loop.set_exception_handler(previous_handler)
+
+    assert "Future exception was never retrieved" not in " | ".join(messages)
diff --git a/tests/unit/services/domains/arxiv/test_client.py b/tests/unit/services/domains/arxiv/test_client.py
new file mode 100644
index 0000000..f1c4c51
--- /dev/null
+++ b/tests/unit/services/domains/arxiv/test_client.py
@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime, timezone
+import httpx
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.services.domains.arxiv import client as arxiv_client_module
+from app.services.domains.arxiv.client import ArxivClient
+from app.services.domains.arxiv.errors import ArxivClientValidationError, ArxivRateLimitError
+from app.services.domains.arxiv.rate_limit import ArxivCooldownStatus
+
+_CLIENT_FEED_XML = """<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom"
+      xmlns:opensearch="http://a9.com/-/spec/opensearch/1.1/"
+      xmlns:arxiv="http://arxiv.org/schemas/atom">
+  <opensearch:totalResults>1</opensearch:totalResults>
+  <opensearch:startIndex>0</opensearch:startIndex>
+  <opensearch:itemsPerPage>1</opensearch:itemsPerPage>
+  <entry>
+    <id>http://arxiv.org/abs/9999.0001</id>
+    <title>Client Entry</title>
+    <summary>Client summary</summary>
+  </entry>
+</feed>
+"""
+
+
+@pytest.mark.asyncio
+async def test_client_search_builds_query_and_sort_params() -> None:
+    captured: dict[str, object] = {}
+
+    async def _request_fn(*, params, request_email, timeout_seconds):
+        captured["params"] = params
+        captured["request_email"] = request_email
+        captured["timeout_seconds"] = timeout_seconds
+        return httpx.Response(200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query"))
+
+    client = ArxivClient(request_fn=_request_fn)
+    feed = await client.search(
+        query='ti:"test"',
+        start=5,
+        max_results=7,
+        sort_by="submittedDate",
+        sort_order="ascending",
+        request_email="user@example.com",
+        timeout_seconds=3.5,
+    )
+
+    assert feed.opensearch.total_results == 1
+    assert captured["params"] == {
+        "search_query": 'ti:"test"',
+        "start": 5,
+        "max_results": 7,
+        "sortBy": "submittedDate",
+        "sortOrder": "ascending",
+    }
+    assert captured["request_email"] == "user@example.com"
+    assert captured["timeout_seconds"] == 3.5
+
+
+@pytest.mark.asyncio
+async def test_client_lookup_ids_builds_id_list_param() -> None:
+    captured: dict[str, object] = {}
+
+    async def _request_fn(*, params, request_email, timeout_seconds):
+        captured["params"] = params
+        return httpx.Response(200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query"))
+
+    client = ArxivClient(request_fn=_request_fn)
+    await client.lookup_ids(id_list=["1234.5678", " 9999.0001 "], start=0, max_results=2)
+    assert captured["params"] == {"id_list": "1234.5678,9999.0001", "start": 0, "max_results": 2}
+
+
+@pytest.mark.asyncio
+async def test_client_search_rejects_invalid_sort_by() -> None:
+    async def _unused_request_fn(*, params, request_email, timeout_seconds):
+        return httpx.Response(200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query"))
+
+    client = ArxivClient(request_fn=_unused_request_fn)
+    with pytest.raises(ArxivClientValidationError):
+        await client.search(query="x", sort_by="bad")
+
+
+@pytest.mark.asyncio
+async def test_client_lookup_ids_rejects_empty_list() -> None:
+    async def _unused_request_fn(*, params, request_email, timeout_seconds):
+        return httpx.Response(200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query"))
+
+    client = ArxivClient(request_fn=_unused_request_fn)
+    with pytest.raises(ArxivClientValidationError):
+        await client.lookup_ids(id_list=[])
+
+
+@pytest.mark.asyncio
+async def test_client_search_rejects_negative_start() -> None:
+    async def _unused_request_fn(*, params, request_email, timeout_seconds):
+        return httpx.Response(200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query"))
+
+    client = ArxivClient(request_fn=_unused_request_fn)
+    with pytest.raises(ArxivClientValidationError):
+        await client.search(query="ti:test", start=-1)
+
+
+@pytest.mark.asyncio
+async def test_client_propagates_http_status_error() -> None:
+    async def _request_fn(*, params, request_email, timeout_seconds):
+        request = httpx.Request("GET", "https://export.arxiv.org/api/query")
+        return httpx.Response(500, text="error", request=request)
+
+    client = ArxivClient(request_fn=_request_fn)
+    with pytest.raises(httpx.HTTPStatusError):
+        await client.search(query="ti:test")
+
+
+@pytest.mark.asyncio
+async def test_client_coalesces_concurrent_identical_search_requests() -> None:
+    calls = {"count": 0}
+
+    async def _request_fn(*, params, request_email, timeout_seconds):
+        calls["count"] += 1
+        await asyncio.sleep(0.05)
+        request = httpx.Request("GET", "https://export.arxiv.org/api/query")
+        return httpx.Response(200, text=_CLIENT_FEED_XML, request=request)
+
+    client = ArxivClient(request_fn=_request_fn)
+    await asyncio.gather(
+        client.search(query="ti:test"),
+        client.search(query="ti:test"),
+    )
+    assert calls["count"] == 1
+
+
+@pytest.mark.asyncio
+async def test_client_logs_cache_hit_and_miss(
+    db_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _ = db_session
+    calls = {"count": 0}
+    logged: list[dict[str, object]] = []
+
+    async def _request_fn(*, params, request_email, timeout_seconds):
+        calls["count"] += 1
+        request = httpx.Request("GET", "https://export.arxiv.org/api/query")
+        return httpx.Response(200, text=_CLIENT_FEED_XML, request=request)
+
+    def _capture_log(_msg: str, *args, **kwargs) -> None:
+        extra = kwargs.get("extra")
+        if isinstance(extra, dict):
+            logged.append(extra)
+
+    monkeypatch.setattr("app.services.domains.arxiv.client.logger.info", _capture_log)
+    client = ArxivClient(request_fn=_request_fn, cache_enabled=True)
+    await client.search(query="ti:test-cache")
+    await client.search(query="ti:test-cache")
+
+    events = [str(entry.get("event", "")) for entry in logged]
+    assert "arxiv.cache_miss" in events
+    assert "arxiv.cache_hit" in events
+    assert calls["count"] == 1
+
+
+@pytest.mark.asyncio
+async def test_request_feed_skips_live_call_when_global_cooldown_is_active(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    logged: list[dict[str, object]] = []
+    called = {"count": 0}
+
+    async def _cooldown_status(*, now_utc=None):
+        _ = now_utc
+        return ArxivCooldownStatus(
+            is_active=True,
+            remaining_seconds=61.0,
+            cooldown_until=datetime(2026, 2, 26, 12, 1, tzinfo=timezone.utc),
+        )
+
+    async def _unexpected_limit_call(*, fetch, source_path):  # pragma: no cover - defensive
+        _ = (fetch, source_path)
+        called["count"] += 1
+        return httpx.Response(200, text=_CLIENT_FEED_XML)
+
+    def _capture_warning(_msg: str, *args, **kwargs) -> None:
+        extra = kwargs.get("extra")
+        if isinstance(extra, dict):
+            logged.append(extra)
+
+    monkeypatch.setattr(arxiv_client_module, "get_arxiv_cooldown_status", _cooldown_status)
+    monkeypatch.setattr(arxiv_client_module, "run_with_global_arxiv_limit", _unexpected_limit_call)
+    monkeypatch.setattr("app.services.domains.arxiv.client.logger.warning", _capture_warning)
+
+    with pytest.raises(ArxivRateLimitError):
+        await arxiv_client_module._request_arxiv_feed(
+            params={"search_query": 'ti:"test"'},
+            request_email="user@example.com",
+            timeout_seconds=2.0,
+        )
+
+    assert called["count"] == 0
+    assert [entry.get("event") for entry in logged] == ["arxiv.request_skipped_cooldown"]
diff --git a/tests/unit/services/domains/arxiv/test_gateway.py b/tests/unit/services/domains/arxiv/test_gateway.py
new file mode 100644
index 0000000..934c4fc
--- /dev/null
+++ b/tests/unit/services/domains/arxiv/test_gateway.py
@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from app.services.domains.arxiv import application as arxiv_application
+from app.services.domains.arxiv import gateway as arxiv_gateway
+from app.services.domains.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
+from app.settings import settings
+
+
+def _item(*, title: str = "A Test Paper", scholar_label: str = "Ada Lovelace") -> SimpleNamespace:
+    return SimpleNamespace(title=title, scholar_label=scholar_label)
+
+
+def test_get_arxiv_gateway_returns_cached_instance() -> None:
+    previous = arxiv_gateway.set_arxiv_gateway(None)
+    try:
+        first = arxiv_gateway.get_arxiv_gateway()
+        second = arxiv_gateway.get_arxiv_gateway()
+        assert first is second
+    finally:
+        arxiv_gateway.set_arxiv_gateway(previous)
+
+
+@pytest.mark.asyncio
+async def test_application_discover_uses_gateway_override() -> None:
+    class FakeGateway:
+        def __init__(self) -> None:
+            self.calls: list[tuple[object, str | None, float | None]] = []
+
+        async def discover_arxiv_id_for_publication(
+            self,
+            *,
+            item,
+            request_email: str | None = None,
+            timeout_seconds: float | None = None,
+            max_results: int | None = None,
+        ) -> str | None:
+            self.calls.append((item, request_email, timeout_seconds))
+            return "1234.5678"
+
+    fake_gateway = FakeGateway()
+    previous = arxiv_gateway.set_arxiv_gateway(fake_gateway)
+    try:
+        result = await arxiv_application.discover_arxiv_id_for_publication(
+            item=_item(),
+            request_email="user@example.com",
+            timeout_seconds=7.0,
+        )
+        assert result == "1234.5678"
+        assert fake_gateway.calls
+        assert fake_gateway.calls[0][1] == "user@example.com"
+        assert fake_gateway.calls[0][2] == 7.0
+    finally:
+        arxiv_gateway.set_arxiv_gateway(previous)
+
+
+@pytest.mark.asyncio
+async def test_http_gateway_returns_none_when_disabled(monkeypatch: pytest.MonkeyPatch) -> None:
+    class FakeClient:
+        def __init__(self) -> None:
+            self.calls = 0
+
+        async def search(self, **kwargs):
+            self.calls += 1
+            return ArxivFeed()
+
+    previous_enabled = bool(settings.arxiv_enabled)
+    fake_client = FakeClient()
+    object.__setattr__(settings, "arxiv_enabled", False)
+    try:
+        gateway = arxiv_gateway.HttpArxivGateway(client=fake_client)
+        result = await gateway.discover_arxiv_id_for_publication(item=_item())
+        assert result is None
+        assert fake_client.calls == 0
+    finally:
+        object.__setattr__(settings, "arxiv_enabled", previous_enabled)
+
+
+@pytest.mark.asyncio
+async def test_http_gateway_uses_client_search_for_discovery() -> None:
+    class FakeClient:
+        def __init__(self) -> None:
+            self.calls: list[dict] = []
+
+        async def search(self, **kwargs):
+            self.calls.append(kwargs)
+            return ArxivFeed(
+                entries=[
+                    ArxivEntry(
+                        entry_id_url="https://arxiv.org/abs/1234.5678v1",
+                        arxiv_id="1234.5678v1",
+                        title="Paper",
+                        summary="",
+                        published=None,
+                        updated=None,
+                    )
+                ],
+                opensearch=ArxivOpenSearchMeta(total_results=1, start_index=0, items_per_page=1),
+            )
+
+    fake_client = FakeClient()
+    gateway = arxiv_gateway.HttpArxivGateway(client=fake_client)
+    result = await gateway.discover_arxiv_id_for_publication(
+        item=_item(title="My Paper", scholar_label="Ada Lovelace"),
+        request_email="user@example.com",
+        timeout_seconds=2.0,
+        max_results=4,
+    )
+
+    assert result == "1234.5678v1"
+    assert fake_client.calls
+    first_call = fake_client.calls[0]
+    assert first_call["query"] == 'ti:"My Paper" AND au:"lovelace"'
+    assert first_call["request_email"] == "user@example.com"
+    assert first_call["timeout_seconds"] == 2.0
+    assert first_call["max_results"] == 4
+
+
+def test_build_arxiv_query_normalizes_noisy_mojibake_title() -> None:
+    noisy = "  Graph–Neural   Networks  Survey  "
+    clean = "Graph Neural Networks Survey"
+
+    assert arxiv_gateway.build_arxiv_query(noisy, None) == arxiv_gateway.build_arxiv_query(clean, None)
diff --git a/tests/unit/services/domains/arxiv/test_guards.py b/tests/unit/services/domains/arxiv/test_guards.py
new file mode 100644
index 0000000..6acc042
--- /dev/null
+++ b/tests/unit/services/domains/arxiv/test_guards.py
@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from app.services.domains.arxiv.guards import arxiv_skip_reason_for_item
+from app.services.domains.publication_identifiers.types import DisplayIdentifier
+from app.services.domains.publications.types import PublicationListItem
+
+
+def _item(
+    *,
+    title: str,
+    pub_url: str | None = None,
+    pdf_url: str | None = None,
+    display_identifier: DisplayIdentifier | None = None,
+) -> PublicationListItem:
+    return PublicationListItem(
+        publication_id=1,
+        scholar_profile_id=1,
+        scholar_label="Ada Lovelace",
+        title=title,
+        year=2024,
+        citation_count=0,
+        venue_text=None,
+        pub_url=pub_url,
+        pdf_url=pdf_url,
+        is_read=False,
+        first_seen_at=datetime.now(timezone.utc),
+        is_new_in_latest_run=True,
+        display_identifier=display_identifier,
+    )
+
+
+def test_arxiv_skip_reason_for_strong_doi_evidence() -> None:
+    item = _item(
+        title="A Robust and Reproducible Deep Learning Benchmark",
+        display_identifier=DisplayIdentifier(
+            kind="doi",
+            value="10.1000/example",
+            label="DOI: 10.1000/example",
+            url="https://doi.org/10.1000/example",
+            confidence_score=1.0,
+        ),
+    )
+    assert arxiv_skip_reason_for_item(item=item) == "strong_doi_present"
+
+
+def test_arxiv_skip_reason_for_existing_arxiv_link() -> None:
+    item = _item(
+        title="A Robust and Reproducible Deep Learning Benchmark",
+        pub_url="https://arxiv.org/abs/2501.00001",
+    )
+    assert arxiv_skip_reason_for_item(item=item) == "arxiv_identifier_present"
+
+
+def test_arxiv_skip_reason_for_low_quality_title() -> None:
+    item = _item(title="AI 2024")
+    assert arxiv_skip_reason_for_item(item=item) == "title_quality_below_threshold"
+
+
+def test_arxiv_skip_reason_none_for_eligible_item() -> None:
+    item = _item(title="Reliable Graph Neural Network Benchmarking Across Multiple Datasets")
+    assert arxiv_skip_reason_for_item(item=item) is None
diff --git a/tests/unit/services/domains/arxiv/test_parser.py b/tests/unit/services/domains/arxiv/test_parser.py
new file mode 100644
index 0000000..5ff78a8
--- /dev/null
+++ b/tests/unit/services/domains/arxiv/test_parser.py
@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import pytest
+
+from app.services.domains.arxiv.errors import ArxivParseError
+from app.services.domains.arxiv.parser import parse_arxiv_feed
+
+_VALID_FEED_XML = """<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom"
+      xmlns:opensearch="http://a9.com/-/spec/opensearch/1.1/"
+      xmlns:arxiv="http://arxiv.org/schemas/atom">
+  <opensearch:totalResults>2</opensearch:totalResults>
+  <opensearch:startIndex>0</opensearch:startIndex>
+  <opensearch:itemsPerPage>2</opensearch:itemsPerPage>
+  <entry>
+    <id>http://arxiv.org/abs/1234.5678v2</id>
+    <updated>2020-01-01T00:00:00Z</updated>
+    <published>2019-12-31T00:00:00Z</published>
+    <title>Test Entry</title>
+    <summary>Example summary</summary>
+    <author><name>Ada Lovelace</name></author>
+    <author><name>Grace Hopper</name></author>
+    <link href="http://arxiv.org/abs/1234.5678v2" />
+    <category term="cs.AI" />
+    <category term="stat.ML" />
+    <arxiv:primary_category term="cs.AI" />
+  </entry>
+</feed>
+"""
+
+
+def test_parse_arxiv_feed_extracts_entries_and_opensearch_meta() -> None:
+    feed = parse_arxiv_feed(_VALID_FEED_XML)
+    assert feed.opensearch.total_results == 2
+    assert feed.opensearch.start_index == 0
+    assert feed.opensearch.items_per_page == 2
+    assert len(feed.entries) == 1
+    entry = feed.entries[0]
+    assert entry.arxiv_id == "1234.5678v2"
+    assert entry.title == "Test Entry"
+    assert entry.summary == "Example summary"
+    assert entry.authors == ["Ada Lovelace", "Grace Hopper"]
+    assert entry.primary_category == "cs.AI"
+    assert entry.categories == ["cs.AI", "stat.ML"]
+
+
+def test_parse_arxiv_feed_raises_on_invalid_xml() -> None:
+    with pytest.raises(ArxivParseError):
+        parse_arxiv_feed("<feed><entry></feed>")
+
+
+def test_parse_arxiv_feed_raises_on_invalid_opensearch_integer() -> None:
+    payload = _VALID_FEED_XML.replace("<opensearch:totalResults>2</opensearch:totalResults>", "<opensearch:totalResults>x</opensearch:totalResults>")
+    with pytest.raises(ArxivParseError):
+        parse_arxiv_feed(payload)
diff --git a/tests/unit/services/domains/arxiv/test_rate_limit.py b/tests/unit/services/domains/arxiv/test_rate_limit.py
new file mode 100644
index 0000000..4e5623b
--- /dev/null
+++ b/tests/unit/services/domains/arxiv/test_rate_limit.py
@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime, timedelta, timezone
+
+import httpx
+import pytest
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import ArxivRuntimeState
+from app.services.domains.arxiv.constants import ARXIV_RUNTIME_STATE_KEY
+from app.services.domains.arxiv.errors import ArxivRateLimitError
+from app.services.domains.arxiv.rate_limit import get_arxiv_cooldown_status, run_with_global_arxiv_limit
+from app.settings import settings
+
+
+@pytest.mark.asyncio
+async def test_arxiv_rate_limit_respects_cooldown(db_session: AsyncSession) -> None:
+    db_session.add(
+        ArxivRuntimeState(
+            state_key=ARXIV_RUNTIME_STATE_KEY,
+            cooldown_until=datetime.now(timezone.utc) + timedelta(seconds=30),
+        )
+    )
+    await db_session.commit()
+
+    called = {"count": 0}
+
+    async def _fetch() -> httpx.Response:
+        called["count"] += 1
+        return httpx.Response(200, text="ok")
+
+    with pytest.raises(ArxivRateLimitError):
+        await run_with_global_arxiv_limit(fetch=_fetch)
+    assert called["count"] == 0
+
+
+@pytest.mark.asyncio
+async def test_arxiv_rate_limit_persists_cooldown_after_429(db_session: AsyncSession) -> None:
+    previous_interval = settings.arxiv_min_interval_seconds
+    previous_cooldown = settings.arxiv_rate_limit_cooldown_seconds
+    object.__setattr__(settings, "arxiv_min_interval_seconds", 0.0)
+    object.__setattr__(settings, "arxiv_rate_limit_cooldown_seconds", 5.0)
+    try:
+        async def _fetch() -> httpx.Response:
+            return httpx.Response(429, text="rate limited")
+
+        with pytest.raises(ArxivRateLimitError):
+            await run_with_global_arxiv_limit(fetch=_fetch)
+    finally:
+        object.__setattr__(settings, "arxiv_min_interval_seconds", previous_interval)
+        object.__setattr__(settings, "arxiv_rate_limit_cooldown_seconds", previous_cooldown)
+
+    result = await db_session.execute(
+        select(ArxivRuntimeState).where(ArxivRuntimeState.state_key == ARXIV_RUNTIME_STATE_KEY)
+    )
+    state = result.scalar_one()
+    assert state.cooldown_until is not None
+    assert state.cooldown_until > datetime.now(timezone.utc)
+
+
+@pytest.mark.asyncio
+async def test_arxiv_rate_limit_serializes_concurrent_calls(db_session: AsyncSession) -> None:
+    previous_interval = settings.arxiv_min_interval_seconds
+    previous_cooldown = settings.arxiv_rate_limit_cooldown_seconds
+    object.__setattr__(settings, "arxiv_min_interval_seconds", 0.2)
+    object.__setattr__(settings, "arxiv_rate_limit_cooldown_seconds", 5.0)
+    try:
+        call_times: list[float] = []
+
+        async def _fetch() -> httpx.Response:
+            call_times.append(asyncio.get_running_loop().time())
+            return httpx.Response(200, text="ok")
+
+        await asyncio.gather(
+            run_with_global_arxiv_limit(fetch=_fetch),
+            run_with_global_arxiv_limit(fetch=_fetch),
+        )
+    finally:
+        object.__setattr__(settings, "arxiv_min_interval_seconds", previous_interval)
+        object.__setattr__(settings, "arxiv_rate_limit_cooldown_seconds", previous_cooldown)
+
+    assert len(call_times) == 2
+    assert call_times[1] - call_times[0] >= 0.18
+
+
+@pytest.mark.asyncio
+async def test_arxiv_rate_limit_logs_request_scheduled_and_completed(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    logged: list[dict[str, object]] = []
+
+    async def _fetch() -> httpx.Response:
+        return httpx.Response(200, text="ok")
+
+    def _capture_log(_msg: str, *args, **kwargs) -> None:
+        extra = kwargs.get("extra")
+        if isinstance(extra, dict):
+            logged.append(extra)
+
+    monkeypatch.setattr("app.services.domains.arxiv.rate_limit.logger.info", _capture_log)
+    await run_with_global_arxiv_limit(fetch=_fetch, source_path="search")
+
+    scheduled = [entry for entry in logged if entry.get("event") == "arxiv.request_scheduled"]
+    completed = [entry for entry in logged if entry.get("event") == "arxiv.request_completed"]
+
+    assert scheduled
+    assert completed
+    assert float(scheduled[0]["wait_seconds"]) >= 0.0
+    assert int(completed[0]["status_code"]) == 200
+    assert completed[0]["source_path"] == "search"
+
+
+@pytest.mark.asyncio
+async def test_arxiv_rate_limit_logs_cooldown_activation(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    logged_warning: list[dict[str, object]] = []
+    previous_interval = settings.arxiv_min_interval_seconds
+    previous_cooldown = settings.arxiv_rate_limit_cooldown_seconds
+    object.__setattr__(settings, "arxiv_min_interval_seconds", 0.0)
+    object.__setattr__(settings, "arxiv_rate_limit_cooldown_seconds", 5.0)
+    try:
+        async def _fetch() -> httpx.Response:
+            return httpx.Response(429, text="rate limited")
+
+        def _capture_warning(_msg: str, *args, **kwargs) -> None:
+            extra = kwargs.get("extra")
+            if isinstance(extra, dict):
+                logged_warning.append(extra)
+
+        monkeypatch.setattr("app.services.domains.arxiv.rate_limit.logger.warning", _capture_warning)
+        with pytest.raises(ArxivRateLimitError):
+            await run_with_global_arxiv_limit(fetch=_fetch, source_path="lookup_ids")
+    finally:
+        object.__setattr__(settings, "arxiv_min_interval_seconds", previous_interval)
+        object.__setattr__(settings, "arxiv_rate_limit_cooldown_seconds", previous_cooldown)
+
+    cooldown_events = [
+        entry for entry in logged_warning if entry.get("event") == "arxiv.cooldown_activated"
+    ]
+    assert cooldown_events
+    assert cooldown_events[0]["source_path"] == "lookup_ids"
+    assert float(cooldown_events[0]["cooldown_remaining_seconds"]) > 0.0
+
+
+@pytest.mark.asyncio
+async def test_get_arxiv_cooldown_status_reads_active_cooldown(db_session: AsyncSession) -> None:
+    now_utc = datetime(2026, 2, 26, 13, 0, tzinfo=timezone.utc)
+    existing = await db_session.get(ArxivRuntimeState, ARXIV_RUNTIME_STATE_KEY)
+    if existing is None:
+        db_session.add(
+            ArxivRuntimeState(
+                state_key=ARXIV_RUNTIME_STATE_KEY,
+                cooldown_until=now_utc + timedelta(seconds=45),
+            )
+        )
+    else:
+        existing.cooldown_until = now_utc + timedelta(seconds=45)
+    await db_session.commit()
+
+    status = await get_arxiv_cooldown_status(now_utc=now_utc)
+
+    assert status.is_active is True
+    assert status.cooldown_until is not None
+    assert int(status.remaining_seconds) == 45
diff --git a/tests/unit/services/domains/publications/test_dedup.py b/tests/unit/services/domains/publications/test_dedup.py
index 71542f0..1f0f4dd 100644
--- a/tests/unit/services/domains/publications/test_dedup.py
+++ b/tests/unit/services/domains/publications/test_dedup.py
@@ -1,29 +1,30 @@
-"""Unit tests for the identifier-based publication dedup sweep.
+"""Unit tests for publication dedup operations."""
 
-DB operations are mocked via AsyncMock so no database is required.
-"""
 from __future__ import annotations
 
+from types import SimpleNamespace
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
 from app.db.models import ScholarPublication
+from app.services.domains.publications import dedup as dedup_service
 from app.services.domains.publications.dedup import (
+    NearDuplicateCluster,
+    NearDuplicateMember,
     find_identifier_duplicate_pairs,
+    find_near_duplicate_clusters,
     merge_duplicate_publication,
+    merge_near_duplicate_cluster,
     sweep_identifier_duplicates,
 )
 
 
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
 def _make_result(rows: list) -> MagicMock:
     mock_result = MagicMock()
     mock_result.scalars.return_value.all.return_value = rows
     mock_result.__iter__ = lambda self: iter(rows)
+    mock_result.all.return_value = rows
     return mock_result
 
 
@@ -35,10 +36,6 @@ def _session_with_execute_sequence(results: list) -> AsyncMock:
     return session
 
 
-# ---------------------------------------------------------------------------
-# find_identifier_duplicate_pairs
-# ---------------------------------------------------------------------------
-
 @pytest.mark.asyncio
 async def test_find_identifier_duplicate_pairs_returns_pairs() -> None:
     session = AsyncMock()
@@ -60,56 +57,104 @@ async def test_find_identifier_duplicate_pairs_returns_empty_when_no_duplicates(
     assert pairs == []
 
 
-# ---------------------------------------------------------------------------
-# merge_duplicate_publication
-# ---------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_merge_duplicate_publication_migrates_links_and_identifiers() -> None:
+    session = AsyncMock()
+    winner = SimpleNamespace(
+        year=2014,
+        citation_count=10,
+        author_text=None,
+        venue_text=None,
+        pub_url=None,
+        pdf_url=None,
+        cluster_id=None,
+        canonical_title_hash=None,
+        title_raw="winner",
+        title_normalized="winner",
+    )
+    dup = SimpleNamespace(
+        year=2015,
+        citation_count=11,
+        author_text="a",
+        venue_text="v",
+        pub_url="https://example.org",
+        pdf_url="https://example.org/a.pdf",
+        cluster_id="x",
+        canonical_title_hash="hash",
+        title_raw="dup",
+        title_normalized="dup",
+    )
+
+    with (
+        patch(
+            "app.services.domains.publications.dedup._load_publication",
+            new=AsyncMock(side_effect=[winner, dup]),
+        ),
+        patch(
+            "app.services.domains.publications.dedup._migrate_scholar_links",
+            new=AsyncMock(),
+        ) as mock_links,
+        patch(
+            "app.services.domains.publications.dedup._migrate_identifiers",
+            new=AsyncMock(),
+        ) as mock_identifiers,
+    ):
+        await merge_duplicate_publication(session, winner_id=1, dup_id=2)
+
+    assert session.execute.await_count == 1
+    mock_links.assert_awaited_once_with(session, winner_id=1, dup_id=2)
+    mock_identifiers.assert_awaited_once_with(session, winner_id=1, dup_id=2)
+
 
 @pytest.mark.asyncio
-async def test_merge_duplicate_migrates_orphaned_scholar_links() -> None:
-    """Scholar link that only the dup has should be migrated to winner."""
+async def test_merge_duplicate_publication_rejects_missing_publications() -> None:
+    session = AsyncMock()
+
+    with patch(
+        "app.services.domains.publications.dedup._load_publication",
+        new=AsyncMock(side_effect=[None, None]),
+    ):
+        with pytest.raises(ValueError):
+            await merge_duplicate_publication(session, winner_id=1, dup_id=2)
+
+
+@pytest.mark.asyncio
+async def test_migrate_scholar_links_moves_orphans() -> None:
     dup_link = MagicMock(spec=ScholarPublication)
     dup_link.scholar_profile_id = 99
     dup_link.publication_id = 2
 
     session = _session_with_execute_sequence(
         results=[
-            [dup_link],  # dup links
-            [],          # winner profile ids (no conflict)
-            [],          # execute(delete(Publication)) result
+            [dup_link],
+            [],
         ]
     )
 
-    await merge_duplicate_publication(session, winner_id=1, dup_id=2)
+    await dedup_service._migrate_scholar_links(session, winner_id=1, dup_id=2)
 
     assert dup_link.publication_id == 1
-    session.delete.assert_not_awaited()  # not deleted; migrated instead
+    session.delete.assert_not_awaited()
 
 
 @pytest.mark.asyncio
-async def test_merge_duplicate_drops_conflicting_scholar_link() -> None:
-    """When winner already has a link for the same scholar, dup's link is deleted."""
+async def test_migrate_scholar_links_drops_conflicts() -> None:
     dup_link = MagicMock(spec=ScholarPublication)
     dup_link.scholar_profile_id = 88
     dup_link.publication_id = 2
 
     session = _session_with_execute_sequence(
         results=[
-            [dup_link],    # dup links
-            [(88,)],       # winner profiles (conflict: profile 88 already linked)
-            [],            # execute(delete(Publication)) result
+            [dup_link],
+            [(88,)],
         ]
     )
 
-    await merge_duplicate_publication(session, winner_id=1, dup_id=2)
+    await dedup_service._migrate_scholar_links(session, winner_id=1, dup_id=2)
 
     session.delete.assert_awaited_once_with(dup_link)
-    assert dup_link.publication_id == 2  # unchanged — link was deleted, not migrated
 
 
-# ---------------------------------------------------------------------------
-# sweep_identifier_duplicates
-# ---------------------------------------------------------------------------
-
 @pytest.mark.asyncio
 async def test_sweep_returns_zero_when_no_pairs() -> None:
     with patch(
@@ -145,7 +190,6 @@ async def test_sweep_returns_merge_count() -> None:
 
 @pytest.mark.asyncio
 async def test_sweep_merges_each_dup_only_once() -> None:
-    """A dup sharing two identifiers with the winner appears twice in pairs but merged once."""
     with (
         patch(
             "app.services.domains.publications.dedup.find_identifier_duplicate_pairs",
@@ -161,3 +205,80 @@ async def test_sweep_merges_each_dup_only_once() -> None:
 
     assert count == 1
     assert mock_merge.await_count == 1
+
+
+@pytest.mark.asyncio
+async def test_find_near_duplicate_clusters_groups_similar_titles() -> None:
+    first = dedup_service._candidate_from_row(
+        publication_id=10,
+        title="Adam: A method for stochastic optimization",
+        year=2014,
+        citation_count=100,
+    )
+    second = dedup_service._candidate_from_row(
+        publication_id=11,
+        title="†œAdam: A method for stochastic optimization, †3rd Int. Conf. Learn. Represent.",
+        year=2015,
+        citation_count=50,
+    )
+    assert first is not None
+    assert second is not None
+
+    with patch(
+        "app.services.domains.publications.dedup._load_near_duplicate_candidates",
+        new=AsyncMock(return_value=[first, second]),
+    ):
+        clusters = await find_near_duplicate_clusters(AsyncMock())
+
+    assert len(clusters) == 1
+    assert len(clusters[0].members) == 2
+    assert clusters[0].winner_publication_id == 10
+
+
+@pytest.mark.asyncio
+async def test_find_near_duplicate_clusters_skips_unrelated_titles() -> None:
+    first = dedup_service._candidate_from_row(
+        publication_id=21,
+        title="Adam optimizer",
+        year=2014,
+        citation_count=10,
+    )
+    second = dedup_service._candidate_from_row(
+        publication_id=22,
+        title="Diffusion models in vision",
+        year=2022,
+        citation_count=10,
+    )
+    assert first is not None
+    assert second is not None
+
+    with patch(
+        "app.services.domains.publications.dedup._load_near_duplicate_candidates",
+        new=AsyncMock(return_value=[first, second]),
+    ):
+        clusters = await find_near_duplicate_clusters(AsyncMock())
+
+    assert clusters == []
+
+
+@pytest.mark.asyncio
+async def test_merge_near_duplicate_cluster_merges_non_winner_members() -> None:
+    cluster = NearDuplicateCluster(
+        cluster_key="abc",
+        winner_publication_id=5,
+        similarity_score=1.0,
+        members=(
+            NearDuplicateMember(publication_id=5, title="Winner", year=2014, citation_count=10),
+            NearDuplicateMember(publication_id=6, title="Dup", year=2014, citation_count=3),
+            NearDuplicateMember(publication_id=7, title="Dup2", year=2014, citation_count=1),
+        ),
+    )
+
+    with patch(
+        "app.services.domains.publications.dedup.merge_duplicate_publication",
+        new=AsyncMock(),
+    ) as mock_merge:
+        merged = await merge_near_duplicate_cluster(AsyncMock(), cluster=cluster)
+
+    assert merged == 2
+    assert mock_merge.await_count == 2
diff --git a/tests/unit/test_fingerprints.py b/tests/unit/test_fingerprints.py
index 2065713..f05b69d 100644
--- a/tests/unit/test_fingerprints.py
+++ b/tests/unit/test_fingerprints.py
@@ -240,3 +240,35 @@ class TestCanonicalTitleForDedup:
         ]
         canonicals = [canonical_title_for_dedup(v) for v in variants]
         assert len(set(canonicals)) == 1, f"Expected one canonical, got: {canonicals}"
+
+    def test_strips_mojibake_conference_suffix(self) -> None:
+        noisy = (
+            "†œAdam: A method for stochastic optimization, "
+            "†3rd Int. Conf. Learn. Represent. ICLR 2015-Conf"
+        )
+        clean = "Adam: A method for stochastic optimization"
+        assert canonical_title_for_dedup(noisy) == normalize_title(clean)
+
+    def test_preserves_clean_subtitle_not_venue_metadata(self) -> None:
+        title = "Vision-Language Models - A Survey"
+        assert canonical_title_for_dedup(title) == normalize_title(title)
+
+    def test_strips_leading_author_fragment_before_core_title(self) -> None:
+        noisy = "and Ba.J.:Adam: a method for stochastic optimization"
+        clean = "Adam: a method for stochastic optimization"
+        assert canonical_title_for_dedup(noisy) == normalize_title(clean)
+
+    def test_strips_leading_date_prefix(self) -> None:
+        noisy = "January 7-9). Adam: A method for stochastic optimization"
+        clean = "Adam: A method for stochastic optimization"
+        assert canonical_title_for_dedup(noisy) == normalize_title(clean)
+
+    def test_strips_trailing_publication_type(self) -> None:
+        noisy = "Adam: A method for stochastic optimization. conference paper"
+        clean = "Adam: A method for stochastic optimization"
+        assert canonical_title_for_dedup(noisy) == normalize_title(clean)
+
+    def test_strips_trailing_month_year_parenthetical(self) -> None:
+        noisy = "Adam: A method for stochastic optimization (Jan 2017)"
+        clean = "Adam: A method for stochastic optimization"
+        assert canonical_title_for_dedup(noisy) == normalize_title(clean)
diff --git a/tests/unit/test_ingestion_arxiv_rate_limit.py b/tests/unit/test_ingestion_arxiv_rate_limit.py
new file mode 100644
index 0000000..470a59f
--- /dev/null
+++ b/tests/unit/test_ingestion_arxiv_rate_limit.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from app.services.domains.arxiv.errors import ArxivRateLimitError
+from app.services.domains.ingestion.application import ScholarIngestionService
+from app.services.domains.publication_identifiers import application as identifier_service
+
+
+@pytest.mark.asyncio
+async def test_discover_identifiers_for_enrichment_disables_arxiv_on_rate_limit(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    service = ScholarIngestionService(source=object())
+    publication = SimpleNamespace(id=11, author_text="Ada Lovelace")
+    calls = {"sync": 0}
+
+    async def _raise_rate_limit(db_session, *, publication, scholar_label):
+        _ = (db_session, publication, scholar_label)
+        raise ArxivRateLimitError("arXiv rate limit hit (429) — stopping batch")
+
+    async def _sync_fields(db_session, *, publication):
+        _ = (db_session, publication)
+        calls["sync"] += 1
+
+    monkeypatch.setattr(
+        identifier_service,
+        "discover_and_sync_identifiers_for_publication",
+        _raise_rate_limit,
+    )
+    monkeypatch.setattr(identifier_service, "sync_identifiers_for_publication_fields", _sync_fields)
+    async def _publish_noop(*args, **kwargs) -> None:
+        _ = (args, kwargs)
+
+    monkeypatch.setattr(service, "_publish_identifier_update_event", _publish_noop)
+
+    result = await service._discover_identifiers_for_enrichment(
+        object(),
+        publication=publication,
+        run_id=321,
+        allow_arxiv_lookup=True,
+    )
+
+    assert result is False
+    assert calls["sync"] == 1
diff --git a/tests/unit/test_ingestion_progress_reporting.py b/tests/unit/test_ingestion_progress_reporting.py
new file mode 100644
index 0000000..1567a42
--- /dev/null
+++ b/tests/unit/test_ingestion_progress_reporting.py
@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import pytest
+
+from app.services.domains.ingestion.application import ScholarIngestionService
+from app.services.domains.ingestion.types import RunProgress, ScholarProcessingOutcome
+
+
+def _outcome(*, scholar_profile_id: int, outcome_label: str) -> ScholarProcessingOutcome:
+    counters = {
+        "success": (1, 0, 0),
+        "partial": (1, 0, 1),
+        "failed": (0, 1, 0),
+    }
+    succeeded, failed, partial = counters[outcome_label]
+    return ScholarProcessingOutcome(
+        result_entry={
+            "scholar_profile_id": scholar_profile_id,
+            "outcome": outcome_label,
+            "state": "ok",
+            "state_reason": "publications_extracted",
+            "publication_count": 1,
+        },
+        succeeded_count_delta=succeeded,
+        failed_count_delta=failed,
+        partial_count_delta=partial,
+        discovered_publication_count=1,
+    )
+
+
+def test_apply_outcome_to_progress_replaces_previous_scholar_outcome() -> None:
+    progress = RunProgress()
+
+    ScholarIngestionService._apply_outcome_to_progress(
+        progress=progress,
+        outcome=_outcome(scholar_profile_id=42, outcome_label="partial"),
+    )
+    ScholarIngestionService._apply_outcome_to_progress(
+        progress=progress,
+        outcome=_outcome(scholar_profile_id=42, outcome_label="success"),
+    )
+
+    assert len(progress.scholar_results) == 1
+    assert progress.scholar_results[0]["outcome"] == "success"
+    assert progress.succeeded_count == 1
+    assert progress.failed_count == 0
+    assert progress.partial_count == 0
+
+
+def test_apply_outcome_to_progress_rejects_invalid_scholar_id() -> None:
+    progress = RunProgress()
+    invalid = ScholarProcessingOutcome(
+        result_entry={"scholar_profile_id": 0, "outcome": "success"},
+        succeeded_count_delta=1,
+        failed_count_delta=0,
+        partial_count_delta=0,
+        discovered_publication_count=0,
+    )
+
+    with pytest.raises(RuntimeError, match="missing valid scholar_profile_id"):
+        ScholarIngestionService._apply_outcome_to_progress(progress=progress, outcome=invalid)
diff --git a/tests/unit/test_publication_identifiers.py b/tests/unit/test_publication_identifiers.py
index 88f5fcf..745b62c 100644
--- a/tests/unit/test_publication_identifiers.py
+++ b/tests/unit/test_publication_identifiers.py
@@ -1,6 +1,14 @@
 from __future__ import annotations
 
+import pytest
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import Publication, PublicationIdentifier
+from app.services.domains.arxiv import application as arxiv_service
 from app.services.domains.publication_identifiers import application as identifier_service
+from app.services.domains.publication_identifiers.types import IdentifierKind
+from app.services.domains.publications.types import UnreadPublicationItem
 
 
 def test_derive_display_identifier_prefers_doi_over_arxiv() -> None:
@@ -40,7 +48,7 @@ def test_derive_display_identifier_uses_pmcid_when_present() -> None:
 
 def test_normalize_arxiv_id_handles_urls() -> None:
     from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
-    
+
     assert normalize_arxiv_id("https://arxiv.org/abs/1504.08025") == "1504.08025"
     assert normalize_arxiv_id("http://arxiv.org/pdf/1504.08025v2.pdf") == "1504.08025v2"
     assert normalize_arxiv_id("https://arxiv.org/html/1504.08025v2") == "1504.08025v2"
@@ -52,7 +60,8 @@ def test_normalize_arxiv_id_handles_urls() -> None:
 
 def test_normalize_arxiv_id_handles_raw_text() -> None:
     from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
-    
+
+    assert normalize_arxiv_id("1504.08025v1") == "1504.08025v1"
     assert normalize_arxiv_id("arXiv:1504.08025") == "1504.08025"
     assert normalize_arxiv_id("arxiv: 1504.08025v1") == "1504.08025v1"
     assert normalize_arxiv_id("Preprint at arXiv:math/9901123v2") == "math/9901123v2"
@@ -61,7 +70,7 @@ def test_normalize_arxiv_id_handles_raw_text() -> None:
 
 def test_normalize_pmcid_handles_urls_and_text() -> None:
     from app.services.domains.publication_identifiers.normalize import normalize_pmcid
-    
+
     assert normalize_pmcid("https://pmc.ncbi.nlm.nih.gov/articles/PMC2175868/") == "PMC2175868"
     assert normalize_pmcid("http://www.ncbi.nlm.nih.gov/pmc/articles/PMC1234567") == "PMC1234567"
     assert normalize_pmcid("PMCID: PMC1234567") == "PMC1234567"
@@ -71,15 +80,140 @@ def test_normalize_pmcid_handles_urls_and_text() -> None:
 
 def test_normalize_pmid_handles_urls() -> None:
     from app.services.domains.publication_identifiers.normalize import normalize_pmid
-    
+
     assert normalize_pmid("https://pubmed.ncbi.nlm.nih.gov/12345678/") == "12345678"
     assert normalize_pmid("http://pubmed.ncbi.nlm.nih.gov/12345678") == "12345678"
     assert normalize_pmid("https://pubmed.ncbi.nlm.nih.gov/not-a-pmid/") is None
 
 
-import pytest
-from app.services.domains.arxiv import application as arxiv_service
-from app.services.domains.publications.types import UnreadPublicationItem
+def _publication(*, title: str, pub_url: str | None = None) -> Publication:
+    return Publication(
+        cluster_id=None,
+        fingerprint_sha256="f" * 64,
+        title_raw=title,
+        title_normalized=title.lower(),
+        year=2024,
+        citation_count=0,
+        author_text=None,
+        venue_text=None,
+        pub_url=pub_url,
+        pdf_url=None,
+    )
+
+
+@pytest.mark.asyncio
+async def test_discover_and_sync_skips_arxiv_when_crossref_finds_doi(
+    db_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    publication = _publication(title="Reliable Paper Title for DOI discovery")
+    db_session.add(publication)
+    await db_session.flush()
+
+    async def _fake_crossref(*, item):
+        return "10.1000/strong-doi"
+
+    async def _fail_arxiv(*, item, request_email=None, timeout_seconds=None):
+        raise AssertionError("arXiv should be skipped after strong DOI evidence.")
+
+    monkeypatch.setattr(
+        "app.services.domains.crossref.application.discover_doi_for_publication",
+        _fake_crossref,
+    )
+    monkeypatch.setattr(
+        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        _fail_arxiv,
+    )
+
+    await identifier_service.discover_and_sync_identifiers_for_publication(
+        db_session,
+        publication=publication,
+        scholar_label="Ada Lovelace",
+    )
+
+    result = await db_session.execute(
+        select(PublicationIdentifier).where(
+            PublicationIdentifier.publication_id == int(publication.id),
+            PublicationIdentifier.kind == IdentifierKind.DOI.value,
+        )
+    )
+    assert result.scalar_one_or_none() is not None
+
+
+@pytest.mark.asyncio
+async def test_discover_and_sync_skips_arxiv_for_low_quality_title(
+    db_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    publication = _publication(title="AI 2024")
+    db_session.add(publication)
+    await db_session.flush()
+    calls = {"count": 0}
+
+    async def _fake_crossref(*, item):
+        return None
+
+    async def _fake_arxiv(*, item, request_email=None, timeout_seconds=None):
+        calls["count"] += 1
+        return "1234.5678"
+
+    monkeypatch.setattr(
+        "app.services.domains.crossref.application.discover_doi_for_publication",
+        _fake_crossref,
+    )
+    monkeypatch.setattr(
+        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        _fake_arxiv,
+    )
+
+    await identifier_service.discover_and_sync_identifiers_for_publication(
+        db_session,
+        publication=publication,
+        scholar_label="Alan Turing",
+    )
+    assert calls["count"] == 0
+
+
+@pytest.mark.asyncio
+async def test_discover_and_sync_calls_arxiv_when_item_is_eligible(
+    db_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    publication = _publication(title="Neural Representation Learning for Graph Signals")
+    db_session.add(publication)
+    await db_session.flush()
+
+    async def _fake_crossref(*, item):
+        return None
+
+    async def _fake_arxiv(*, item, request_email=None, timeout_seconds=None):
+        return "2501.00001v2"
+
+    monkeypatch.setattr(
+        "app.services.domains.crossref.application.discover_doi_for_publication",
+        _fake_crossref,
+    )
+    monkeypatch.setattr(
+        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        _fake_arxiv,
+    )
+
+    await identifier_service.discover_and_sync_identifiers_for_publication(
+        db_session,
+        publication=publication,
+        scholar_label="Grace Hopper",
+    )
+
+    result = await db_session.execute(
+        select(PublicationIdentifier).where(
+            PublicationIdentifier.publication_id == int(publication.id),
+            PublicationIdentifier.kind == IdentifierKind.ARXIV.value,
+        )
+    )
+    identifier = result.scalar_one_or_none()
+    assert identifier is not None
+    assert identifier.value_normalized == "2501.00001v2"
+
 
 @pytest.mark.asyncio
 async def test_discover_arxiv_id_returns_none_if_no_title() -> None:
diff --git a/tests/unit/test_publication_pdf_queue_policy.py b/tests/unit/test_publication_pdf_queue_policy.py
index 494d752..5f8cbeb 100644
--- a/tests/unit/test_publication_pdf_queue_policy.py
+++ b/tests/unit/test_publication_pdf_queue_policy.py
@@ -6,7 +6,6 @@ from types import SimpleNamespace
 import pytest
 
 from app.db.models import PublicationPdfJob
-from app.services.domains.arxiv.application import ArxivRateLimitError
 from app.services.domains.publications import pdf_queue
 from app.services.domains.publications.pdf_resolution_pipeline import PipelineOutcome
 from app.services.domains.unpaywall.application import OaResolutionOutcome
@@ -134,8 +133,9 @@ def test_pdf_queue_manual_requeue_still_blocks_when_inflight() -> None:
 
 @pytest.mark.asyncio
 async def test_fetch_outcome_for_row_uses_pipeline_outcome(monkeypatch: pytest.MonkeyPatch) -> None:
-    async def _fake_pipeline(*, row, request_email=None, openalex_api_key=None):
+    async def _fake_pipeline(*, row, request_email=None, openalex_api_key=None, allow_arxiv_lookup=True):
         assert request_email == "user@example.com"
+        assert allow_arxiv_lookup is True
         return PipelineOutcome(
             outcome=OaResolutionOutcome(
                 publication_id=row.publication_id,
@@ -150,31 +150,40 @@ async def test_fetch_outcome_for_row_uses_pipeline_outcome(monkeypatch: pytest.M
 
     monkeypatch.setattr(pdf_queue, "resolve_publication_pdf_outcome_for_row", _fake_pipeline)
 
-    outcome = await pdf_queue._fetch_outcome_for_row(row=_row(), request_email="user@example.com")
+    outcome, arxiv_rate_limited = await pdf_queue._fetch_outcome_for_row(
+        row=_row(),
+        request_email="user@example.com",
+    )
 
     assert outcome.pdf_url == "https://arxiv.org/pdf/1703.06103"
     assert outcome.source == "openalex"
     assert outcome.used_crossref is False
+    assert arxiv_rate_limited is False
 
 
 @pytest.mark.asyncio
 async def test_fetch_outcome_for_row_returns_failed_outcome_when_pipeline_returns_none(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    async def _fake_pipeline(*, row, request_email=None, openalex_api_key=None):
+    async def _fake_pipeline(*, row, request_email=None, openalex_api_key=None, allow_arxiv_lookup=True):
         assert request_email == "user@example.com"
-        return PipelineOutcome(outcome=None, scholar_candidates=None)
+        assert allow_arxiv_lookup is True
+        return PipelineOutcome(outcome=None, scholar_candidates=None, arxiv_rate_limited=True)
 
     monkeypatch.setattr(pdf_queue, "resolve_publication_pdf_outcome_for_row", _fake_pipeline)
 
-    outcome = await pdf_queue._fetch_outcome_for_row(row=_row(), request_email="user@example.com")
+    outcome, arxiv_rate_limited = await pdf_queue._fetch_outcome_for_row(
+        row=_row(),
+        request_email="user@example.com",
+    )
 
     assert outcome.pdf_url is None
     assert outcome.failure_reason == pdf_queue.FAILURE_RESOLUTION_EXCEPTION
+    assert arxiv_rate_limited is True
 
 
 @pytest.mark.asyncio
-async def test_resolve_publication_row_persists_failed_outcome_before_reraising_arxiv_rate_limit(
+async def test_resolve_publication_row_persists_outcome_and_returns_rate_limit_flag(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     captured: list[tuple[int, int, OaResolutionOutcome]] = []
@@ -182,47 +191,64 @@ async def test_resolve_publication_row_persists_failed_outcome_before_reraising_
     async def _noop_mark_attempt_started(*, publication_id: int, user_id: int) -> None:
         return None
 
-    async def _raise_rate_limit(*, row, request_email=None, openalex_api_key=None):
-        raise ArxivRateLimitError("arXiv rate limit hit (429) — stopping batch")
+    async def _fake_fetch(*, row, request_email=None, openalex_api_key=None, allow_arxiv_lookup=True):
+        assert allow_arxiv_lookup is True
+        return (
+            OaResolutionOutcome(
+                publication_id=row.publication_id,
+                doi=None,
+                pdf_url="https://fallback.example/test.pdf",
+                failure_reason=None,
+                source="unpaywall",
+                used_crossref=False,
+            ),
+            True,
+        )
 
     async def _capture_persist_outcome(*, publication_id: int, user_id: int, outcome: OaResolutionOutcome) -> None:
         captured.append((publication_id, user_id, outcome))
 
     monkeypatch.setattr(pdf_queue, "_mark_attempt_started", _noop_mark_attempt_started)
-    monkeypatch.setattr(pdf_queue, "_fetch_outcome_for_row", _raise_rate_limit)
+    monkeypatch.setattr(pdf_queue, "_fetch_outcome_for_row", _fake_fetch)
     monkeypatch.setattr(pdf_queue, "_persist_outcome", _capture_persist_outcome)
 
-    with pytest.raises(ArxivRateLimitError):
-        await pdf_queue._resolve_publication_row(
-            user_id=42,
-            request_email="user@example.com",
-            row=_row(),
-            openalex_api_key="key",
-        )
+    rate_limited = await pdf_queue._resolve_publication_row(
+        user_id=42,
+        request_email="user@example.com",
+        row=_row(),
+        openalex_api_key="key",
+    )
 
     assert len(captured) == 1
     publication_id, user_id, outcome = captured[0]
     assert publication_id == 1
     assert user_id == 42
-    assert outcome.pdf_url is None
-    assert outcome.failure_reason == pdf_queue.FAILURE_RESOLUTION_EXCEPTION
+    assert outcome.pdf_url == "https://fallback.example/test.pdf"
+    assert rate_limited is True
 
 
 @pytest.mark.asyncio
-async def test_run_resolution_task_stops_batch_on_arxiv_rate_limit(
+async def test_run_resolution_task_disables_arxiv_for_remaining_batch(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    calls: list[int] = []
+    calls: list[tuple[int, bool]] = []
     first = _row()
     second = SimpleNamespace(**{**first.__dict__, "publication_id": 2})
 
     def _raise_session_factory_error():
         raise RuntimeError("skip user settings lookup in test")
 
-    async def _fake_resolve_publication_row(*, user_id: int, request_email: str | None, row, openalex_api_key=None):
-        calls.append(int(row.publication_id))
-        if row.publication_id == 1:
-            raise ArxivRateLimitError("arXiv rate limit hit (429) — stopping batch")
+    async def _fake_resolve_publication_row(
+        *,
+        user_id: int,
+        request_email: str | None,
+        row,
+        openalex_api_key=None,
+        allow_arxiv_lookup=True,
+    ):
+        _ = (user_id, request_email, openalex_api_key)
+        calls.append((int(row.publication_id), bool(allow_arxiv_lookup)))
+        return row.publication_id == 1
 
     monkeypatch.setattr(pdf_queue, "get_session_factory", _raise_session_factory_error)
     monkeypatch.setattr(pdf_queue, "_resolve_publication_row", _fake_resolve_publication_row)
@@ -233,4 +259,4 @@ async def test_run_resolution_task_stops_batch_on_arxiv_rate_limit(
         rows=[first, second],
     )
 
-    assert calls == [1]
+    assert calls == [(1, True), (2, False)]
diff --git a/tests/unit/test_publication_pdf_resolution_pipeline.py b/tests/unit/test_publication_pdf_resolution_pipeline.py
index 74768c2..9016dad 100644
--- a/tests/unit/test_publication_pdf_resolution_pipeline.py
+++ b/tests/unit/test_publication_pdf_resolution_pipeline.py
@@ -5,6 +5,7 @@ from types import SimpleNamespace
 
 import pytest
 
+from app.services.domains.arxiv.errors import ArxivRateLimitError
 from app.services.domains.publications import pdf_resolution_pipeline as pipeline
 from app.services.domains.publication_identifiers.types import DisplayIdentifier
 from app.services.domains.unpaywall.application import OaResolutionOutcome
@@ -58,7 +59,8 @@ async def test_pipeline_prefers_openalex_before_arxiv(monkeypatch: pytest.Monkey
     async def _fake_openalex(row, request_email: str | None = None, openalex_api_key: str | None = None):
         return _api_outcome(pdf_url="https://oa.example.org/found.pdf", source="openalex")
 
-    async def _fail_arxiv(row):
+    async def _fail_arxiv(row, *, request_email: str | None = None, allow_lookup: bool = True):
+        _ = (row, request_email, allow_lookup)
         raise AssertionError(f"arXiv should not run when OpenAlex candidate exists.")
 
     monkeypatch.setattr(pipeline, "_openalex_outcome", _fake_openalex)
@@ -76,7 +78,8 @@ async def test_pipeline_uses_arxiv_after_openalex_failure(monkeypatch: pytest.Mo
     async def _fake_openalex(row, request_email: str | None = None, openalex_api_key: str | None = None):
         return None
 
-    async def _fake_arxiv(row, request_email: str | None = None):
+    async def _fake_arxiv(row, *, request_email: str | None = None, allow_lookup: bool = True):
+        _ = allow_lookup
         return _api_outcome(pdf_url="https://arxiv.org/pdf/1234.5678.pdf", source="arxiv")
 
     async def _fail_oa(*, row, request_email):
@@ -98,7 +101,8 @@ async def test_pipeline_uses_unpaywall_after_arxiv_failure(monkeypatch: pytest.M
     async def _fake_openalex(row, request_email: str | None = None, openalex_api_key: str | None = None):
         return None
 
-    async def _fake_arxiv(row, request_email: str | None = None):
+    async def _fake_arxiv(row, *, request_email: str | None = None, allow_lookup: bool = True):
+        _ = (request_email, allow_lookup)
         return None
 
     async def _fake_oa(*, row, request_email):
@@ -114,3 +118,93 @@ async def test_pipeline_uses_unpaywall_after_arxiv_failure(monkeypatch: pytest.M
     assert result.outcome is not None
     assert result.outcome.pdf_url == "https://example.org/fallback.pdf"
     assert result.outcome.source == "unpaywall"
+
+
+@pytest.mark.asyncio
+async def test_pipeline_falls_back_to_unpaywall_when_arxiv_is_rate_limited(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    async def _fake_openalex(row, request_email: str | None = None, openalex_api_key: str | None = None):
+        _ = (row, request_email, openalex_api_key)
+        return None
+
+    async def _raise_rate_limit(row, *, request_email: str | None = None, allow_lookup: bool = True):
+        _ = (row, request_email, allow_lookup)
+        raise ArxivRateLimitError("arXiv rate limit hit (429) — stopping batch")
+
+    async def _fake_oa(*, row, request_email):
+        _ = (row, request_email)
+        return _oa_fallback_outcome(pdf_url="https://example.org/fallback.pdf", source="unpaywall")
+
+    monkeypatch.setattr(pipeline, "_openalex_outcome", _fake_openalex)
+    monkeypatch.setattr(pipeline, "_arxiv_outcome", _raise_rate_limit)
+    monkeypatch.setattr(pipeline, "_oa_outcome", _fake_oa)
+
+    result = await pipeline.resolve_publication_pdf_outcome_for_row(row=_row(), request_email="user@example.com")
+
+    assert result.outcome is not None
+    assert result.outcome.source == "unpaywall"
+    assert result.arxiv_rate_limited is True
+
+
+@pytest.mark.asyncio
+async def test_arxiv_outcome_skips_when_strong_doi_identifier(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    row = _row(
+        display_identifier=DisplayIdentifier(
+            kind="doi",
+            value="10.1000/example",
+            label="DOI",
+            url="https://doi.org/10.1000/example",
+            confidence_score=1.0,
+        )
+    )
+
+    async def _fail_discover(*, item, request_email: str | None = None, timeout_seconds: float | None = None):
+        raise AssertionError("arXiv lookup should be skipped when DOI evidence is strong.")
+
+    monkeypatch.setattr(
+        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        _fail_discover,
+    )
+    outcome = await pipeline._arxiv_outcome(row, request_email="user@example.com")
+    assert outcome is None
+
+
+@pytest.mark.asyncio
+async def test_arxiv_outcome_skips_when_title_quality_is_low(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    row = _row()
+    row.title = "AI 2024"
+
+    async def _fail_discover(*, item, request_email: str | None = None, timeout_seconds: float | None = None):
+        raise AssertionError("arXiv lookup should be skipped for low-quality titles.")
+
+    monkeypatch.setattr(
+        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        _fail_discover,
+    )
+    outcome = await pipeline._arxiv_outcome(row, request_email="user@example.com")
+    assert outcome is None
+
+
+@pytest.mark.asyncio
+async def test_arxiv_outcome_calls_arxiv_when_eligible(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    async def _fake_discover(*, item, request_email: str | None = None, timeout_seconds: float | None = None):
+        return "1234.5678"
+
+    monkeypatch.setattr(
+        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        _fake_discover,
+    )
+    row = _row()
+    row.title = "Reliable Graph Neural Network Benchmark across Multiple Datasets"
+    outcome = await pipeline._arxiv_outcome(row, request_email="user@example.com")
+
+    assert outcome is not None
+    assert outcome.source == "arxiv"
+    assert outcome.pdf_url == "https://arxiv.org/pdf/1234.5678.pdf"
diff --git a/tests/unit/test_scholar_source.py b/tests/unit/test_scholar_source.py
index c11ed1e..179ca8b 100644
--- a/tests/unit/test_scholar_source.py
+++ b/tests/unit/test_scholar_source.py
@@ -1,4 +1,7 @@
-from app.services.domains.scholar.source import _build_profile_url
+import pytest
+
+from app.services.domains.scholar import rate_limit as scholar_rate_limit
+from app.services.domains.scholar.source import FetchResult, LiveScholarSource, _build_profile_url
 
 
 def test_build_profile_url_includes_pagesize_for_initial_page() -> None:
@@ -11,3 +14,37 @@ def test_build_profile_url_includes_pagesize_for_initial_page() -> None:
     assert "user=abcDEF123456" in url
     assert "pagesize=100" in url
     assert "cstart=" not in url
+
+
+@pytest.mark.asyncio
+async def test_live_scholar_source_applies_global_throttle(monkeypatch: pytest.MonkeyPatch) -> None:
+    captured_interval: list[float] = []
+
+    async def _fake_wait_for_scholar_slot(*, min_interval_seconds: float) -> None:
+        captured_interval.append(min_interval_seconds)
+
+    monkeypatch.setattr(
+        scholar_rate_limit,
+        "wait_for_scholar_slot",
+        _fake_wait_for_scholar_slot,
+    )
+
+    expected_result = FetchResult(
+        requested_url="https://example.test/scholar",
+        status_code=200,
+        final_url="https://example.test/scholar",
+        body="ok",
+        error=None,
+    )
+
+    source = LiveScholarSource(min_interval_seconds=7.0)
+    monkeypatch.setattr(source, "_fetch_sync", lambda _url: expected_result)
+
+    result = await source.fetch_profile_page_html(
+        "abcDEF123456",
+        cstart=0,
+        pagesize=100,
+    )
+
+    assert result == expected_result
+    assert captured_interval == [7.0]
diff --git a/tests/unit/test_scholars_create_hydration.py b/tests/unit/test_scholars_create_hydration.py
new file mode 100644
index 0000000..b452b44
--- /dev/null
+++ b/tests/unit/test_scholars_create_hydration.py
@@ -0,0 +1,144 @@
+from types import SimpleNamespace
+
+import pytest
+
+from app.api.routers import scholars as scholars_router
+
+
+class _FakeSession:
+    def __init__(self) -> None:
+        self.commits = 0
+        self.rollbacks = 0
+
+    async def commit(self) -> None:
+        self.commits += 1
+
+    async def rollback(self) -> None:
+        self.rollbacks += 1
+
+
+@pytest.mark.asyncio
+async def test_create_hydration_skips_when_global_throttle_active(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    profile = SimpleNamespace(
+        id=42,
+        profile_image_url=None,
+        display_name="",
+    )
+
+    async def _fail_hydration(*_args, **_kwargs):
+        raise AssertionError("hydrate_profile_metadata should not run when throttle is active")
+
+    monkeypatch.setattr(
+        scholars_router.scholar_rate_limit,
+        "remaining_scholar_slot_seconds",
+        lambda **_kwargs: 3.5,
+    )
+    monkeypatch.setattr(
+        scholars_router.scholar_service,
+        "hydrate_profile_metadata",
+        _fail_hydration,
+    )
+
+    result = await scholars_router._hydrate_scholar_metadata_if_needed(
+        db_session=None,
+        profile=profile,
+        source=object(),
+        user_id=7,
+    )
+
+    assert result is profile
+
+
+@pytest.mark.asyncio
+async def test_create_hydration_runs_when_throttle_is_clear(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    profile = SimpleNamespace(
+        id=84,
+        profile_image_url=None,
+        display_name="",
+    )
+
+    async def _hydrate_profile_metadata(*_args, **_kwargs):
+        profile.display_name = "Ada Lovelace"
+        return profile
+
+    monkeypatch.setattr(
+        scholars_router.scholar_rate_limit,
+        "remaining_scholar_slot_seconds",
+        lambda **_kwargs: 0.0,
+    )
+    monkeypatch.setattr(
+        scholars_router.scholar_service,
+        "hydrate_profile_metadata",
+        _hydrate_profile_metadata,
+    )
+
+    result = await scholars_router._hydrate_scholar_metadata_if_needed(
+        db_session=None,
+        profile=profile,
+        source=object(),
+        user_id=8,
+    )
+
+    assert result.display_name == "Ada Lovelace"
+
+
+@pytest.mark.asyncio
+async def test_initial_scrape_job_enqueued_on_create(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    profile = SimpleNamespace(id=101)
+    session = _FakeSession()
+    upsert_calls: list[dict[str, object]] = []
+
+    async def _fake_upsert_job(*_args, **kwargs):
+        upsert_calls.append(kwargs)
+
+    monkeypatch.setattr(
+        scholars_router,
+        "_auto_enqueue_new_scholar_enabled",
+        lambda: True,
+    )
+    monkeypatch.setattr(
+        scholars_router.ingestion_queue_service,
+        "upsert_job",
+        _fake_upsert_job,
+    )
+
+    queued = await scholars_router._enqueue_initial_scrape_job_for_scholar(
+        session,
+        profile=profile,
+        user_id=9,
+    )
+
+    assert queued is True
+    assert session.commits == 1
+    assert session.rollbacks == 0
+    assert upsert_calls[0]["reason"] == scholars_router.INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON
+
+
+@pytest.mark.asyncio
+async def test_initial_scrape_job_not_enqueued_when_disabled(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    profile = SimpleNamespace(id=202)
+    session = _FakeSession()
+
+    monkeypatch.setattr(
+        scholars_router,
+        "_auto_enqueue_new_scholar_enabled",
+        lambda: False,
+    )
+
+    queued = await scholars_router._enqueue_initial_scrape_job_for_scholar(
+        session,
+        profile=profile,
+        user_id=11,
+    )
+
+    assert queued is False
+    assert session.commits == 0
+    assert session.rollbacks == 0
-- 
2.49.1


From 7736cab141e61a5045ea8097f4aea25f81c3732c Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Thu, 26 Feb 2026 21:24:59 +0100
Subject: [PATCH 05/38] chore: remove stale build artifacts, fix gitignore, use
 npm ci in CI

- Remove 114 tracked build/lib/ files (stale setuptools artifact that
  broke the repo-hygiene CI guard)
- Add build/ to .gitignore
- Remove AGENTS.MD from .gitignore (track agents.md instead)
- Delete ad-hoc scripts: diag_pubs.py, test_enrich.py
- Delete orphaned frontend/docs/website/package-lock.json
- Replace npm install with npm ci in ci.yml and docs-pages.yml for
  deterministic lockfile installs

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/workflows/ci.yml                      |    4 +-
 .github/workflows/docs-pages.yml              |    2 +-
 .gitignore                                    |    2 +-
 build/lib/app/__init__.py                     |    1 -
 build/lib/app/api/__init__.py                 |    2 -
 build/lib/app/api/deps.py                     |   35 -
 build/lib/app/api/errors.py                   |   85 -
 build/lib/app/api/media.py                    |   63 -
 build/lib/app/api/responses.py                |   64 -
 build/lib/app/api/router.py                   |   14 -
 build/lib/app/api/routers/__init__.py         |    2 -
 build/lib/app/api/routers/admin.py            |  202 --
 build/lib/app/api/routers/admin_dbops.py      |  349 ---
 build/lib/app/api/routers/auth.py             |  237 --
 build/lib/app/api/routers/publications.py     |  528 ----
 build/lib/app/api/routers/runs.py             |  845 ------
 build/lib/app/api/routers/scholars.py         |  557 ----
 build/lib/app/api/routers/settings.py         |  189 --
 build/lib/app/api/runtime_deps.py             |   16 -
 build/lib/app/api/schemas.py                  |  884 ------
 build/lib/app/auth/__init__.py                |    2 -
 build/lib/app/auth/deps.py                    |   27 -
 build/lib/app/auth/rate_limit.py              |   69 -
 build/lib/app/auth/runtime.py                 |   55 -
 build/lib/app/auth/security.py                |   19 -
 build/lib/app/auth/service.py                 |   38 -
 build/lib/app/auth/session.py                 |   50 -
 build/lib/app/db/__init__.py                  |    1 -
 build/lib/app/db/base.py                      |   27 -
 build/lib/app/db/models.py                    |  546 ----
 build/lib/app/db/session.py                   |   99 -
 build/lib/app/http/__init__.py                |    1 -
 build/lib/app/http/middleware.py              |  205 --
 build/lib/app/logging_config.py               |  183 --
 build/lib/app/logging_context.py              |   15 -
 build/lib/app/main.py                         |  168 --
 build/lib/app/security/__init__.py            |    2 -
 build/lib/app/security/csrf.py                |  133 -
 build/lib/app/services/__init__.py            |    2 -
 build/lib/app/services/domains/__init__.py    |    1 -
 .../app/services/domains/arxiv/application.py |   84 -
 .../app/services/domains/crossref/__init__.py |    5 -
 .../services/domains/crossref/application.py  |  382 ---
 .../app/services/domains/dbops/__init__.py    |    5 -
 .../app/services/domains/dbops/application.py |  364 ---
 .../app/services/domains/dbops/integrity.py   |  175 --
 build/lib/app/services/domains/dbops/query.py |   22 -
 .../lib/app/services/domains/doi/normalize.py |   23 -
 .../services/domains/ingestion/__init__.py    |    1 -
 .../services/domains/ingestion/application.py | 2413 -----------------
 .../services/domains/ingestion/constants.py   |   31 -
 .../domains/ingestion/fingerprints.py         |  175 --
 .../app/services/domains/ingestion/queue.py   |  348 ---
 .../app/services/domains/ingestion/safety.py  |  282 --
 .../services/domains/ingestion/scheduler.py   |  622 -----
 .../app/services/domains/ingestion/types.py   |  110 -
 .../app/services/domains/openalex/__init__.py |    5 -
 .../app/services/domains/openalex/client.py   |  135 -
 .../app/services/domains/openalex/matching.py |  108 -
 .../app/services/domains/openalex/types.py    |   71 -
 .../services/domains/portability/__init__.py  |    1 -
 .../domains/portability/application.py        |   67 -
 .../services/domains/portability/constants.py |    9 -
 .../services/domains/portability/exporting.py |   91 -
 .../services/domains/portability/normalize.py |  109 -
 .../domains/portability/publication_import.py |  370 ---
 .../domains/portability/scholar_import.py     |  107 -
 .../app/services/domains/portability/types.py |   25 -
 .../publication_identifiers/__init__.py       |   17 -
 .../publication_identifiers/application.py    |  433 ---
 .../publication_identifiers/normalize.py      |   76 -
 .../domains/publication_identifiers/types.py  |   30 -
 .../services/domains/publications/__init__.py |    1 -
 .../domains/publications/application.py       |   74 -
 .../services/domains/publications/counts.py   |   90 -
 .../domains/publications/enrichment.py        |   73 -
 .../services/domains/publications/listing.py  |   93 -
 .../services/domains/publications/modes.py    |   14 -
 .../domains/publications/pdf_queue.py         |  915 -------
 .../publications/pdf_resolution_pipeline.py   |  108 -
 .../services/domains/publications/queries.py  |  203 --
 .../domains/publications/read_state.py        |   94 -
 .../services/domains/publications/types.py    |   41 -
 .../lib/app/services/domains/runs/__init__.py |    1 -
 .../app/services/domains/runs/application.py  |   45 -
 build/lib/app/services/domains/runs/events.py |   59 -
 .../services/domains/runs/queue_queries.py    |   70 -
 .../services/domains/runs/queue_service.py    |  182 --
 .../app/services/domains/runs/runs_service.py |   79 -
 .../lib/app/services/domains/runs/summary.py  |   76 -
 build/lib/app/services/domains/runs/types.py  |   38 -
 .../app/services/domains/scholar/__init__.py  |    1 -
 .../services/domains/scholar/author_rows.py   |  202 --
 .../app/services/domains/scholar/parser.py    |  165 --
 .../domains/scholar/parser_constants.py       |   87 -
 .../services/domains/scholar/parser_types.py  |   75 -
 .../services/domains/scholar/parser_utils.py  |   42 -
 .../services/domains/scholar/profile_rows.py  |  270 --
 .../services/domains/scholar/rate_limit.py    |   18 -
 .../app/services/domains/scholar/source.py    |  235 --
 .../domains/scholar/state_detection.py        |  164 --
 .../app/services/domains/scholars/__init__.py |    1 -
 .../services/domains/scholars/application.py  |  974 -------
 .../services/domains/scholars/constants.py    |   70 -
 .../services/domains/scholars/exceptions.py   |    5 -
 .../services/domains/scholars/search_hints.py |   67 -
 .../app/services/domains/scholars/uploads.py  |   39 -
 .../services/domains/scholars/validators.py   |   38 -
 .../app/services/domains/settings/__init__.py |    1 -
 .../services/domains/settings/application.py  |  159 --
 .../services/domains/unpaywall/__init__.py    |   10 -
 .../services/domains/unpaywall/application.py |  458 ----
 .../domains/unpaywall/pdf_discovery.py        |  156 --
 .../services/domains/unpaywall/rate_limit.py  |   18 -
 .../app/services/domains/users/__init__.py    |    1 -
 .../app/services/domains/users/application.py |   98 -
 build/lib/app/settings.py                     |  267 --
 diag_pubs.py                                  |   39 -
 frontend/docs/website/package-lock.json       |    6 -
 test_enrich.py                                |   42 -
 120 files changed, 4 insertions(+), 18380 deletions(-)
 delete mode 100644 build/lib/app/__init__.py
 delete mode 100644 build/lib/app/api/__init__.py
 delete mode 100644 build/lib/app/api/deps.py
 delete mode 100644 build/lib/app/api/errors.py
 delete mode 100644 build/lib/app/api/media.py
 delete mode 100644 build/lib/app/api/responses.py
 delete mode 100644 build/lib/app/api/router.py
 delete mode 100644 build/lib/app/api/routers/__init__.py
 delete mode 100644 build/lib/app/api/routers/admin.py
 delete mode 100644 build/lib/app/api/routers/admin_dbops.py
 delete mode 100644 build/lib/app/api/routers/auth.py
 delete mode 100644 build/lib/app/api/routers/publications.py
 delete mode 100644 build/lib/app/api/routers/runs.py
 delete mode 100644 build/lib/app/api/routers/scholars.py
 delete mode 100644 build/lib/app/api/routers/settings.py
 delete mode 100644 build/lib/app/api/runtime_deps.py
 delete mode 100644 build/lib/app/api/schemas.py
 delete mode 100644 build/lib/app/auth/__init__.py
 delete mode 100644 build/lib/app/auth/deps.py
 delete mode 100644 build/lib/app/auth/rate_limit.py
 delete mode 100644 build/lib/app/auth/runtime.py
 delete mode 100644 build/lib/app/auth/security.py
 delete mode 100644 build/lib/app/auth/service.py
 delete mode 100644 build/lib/app/auth/session.py
 delete mode 100644 build/lib/app/db/__init__.py
 delete mode 100644 build/lib/app/db/base.py
 delete mode 100644 build/lib/app/db/models.py
 delete mode 100644 build/lib/app/db/session.py
 delete mode 100644 build/lib/app/http/__init__.py
 delete mode 100644 build/lib/app/http/middleware.py
 delete mode 100644 build/lib/app/logging_config.py
 delete mode 100644 build/lib/app/logging_context.py
 delete mode 100644 build/lib/app/main.py
 delete mode 100644 build/lib/app/security/__init__.py
 delete mode 100644 build/lib/app/security/csrf.py
 delete mode 100644 build/lib/app/services/__init__.py
 delete mode 100644 build/lib/app/services/domains/__init__.py
 delete mode 100644 build/lib/app/services/domains/arxiv/application.py
 delete mode 100644 build/lib/app/services/domains/crossref/__init__.py
 delete mode 100644 build/lib/app/services/domains/crossref/application.py
 delete mode 100644 build/lib/app/services/domains/dbops/__init__.py
 delete mode 100644 build/lib/app/services/domains/dbops/application.py
 delete mode 100644 build/lib/app/services/domains/dbops/integrity.py
 delete mode 100644 build/lib/app/services/domains/dbops/query.py
 delete mode 100644 build/lib/app/services/domains/doi/normalize.py
 delete mode 100644 build/lib/app/services/domains/ingestion/__init__.py
 delete mode 100644 build/lib/app/services/domains/ingestion/application.py
 delete mode 100644 build/lib/app/services/domains/ingestion/constants.py
 delete mode 100644 build/lib/app/services/domains/ingestion/fingerprints.py
 delete mode 100644 build/lib/app/services/domains/ingestion/queue.py
 delete mode 100644 build/lib/app/services/domains/ingestion/safety.py
 delete mode 100644 build/lib/app/services/domains/ingestion/scheduler.py
 delete mode 100644 build/lib/app/services/domains/ingestion/types.py
 delete mode 100644 build/lib/app/services/domains/openalex/__init__.py
 delete mode 100644 build/lib/app/services/domains/openalex/client.py
 delete mode 100644 build/lib/app/services/domains/openalex/matching.py
 delete mode 100644 build/lib/app/services/domains/openalex/types.py
 delete mode 100644 build/lib/app/services/domains/portability/__init__.py
 delete mode 100644 build/lib/app/services/domains/portability/application.py
 delete mode 100644 build/lib/app/services/domains/portability/constants.py
 delete mode 100644 build/lib/app/services/domains/portability/exporting.py
 delete mode 100644 build/lib/app/services/domains/portability/normalize.py
 delete mode 100644 build/lib/app/services/domains/portability/publication_import.py
 delete mode 100644 build/lib/app/services/domains/portability/scholar_import.py
 delete mode 100644 build/lib/app/services/domains/portability/types.py
 delete mode 100644 build/lib/app/services/domains/publication_identifiers/__init__.py
 delete mode 100644 build/lib/app/services/domains/publication_identifiers/application.py
 delete mode 100644 build/lib/app/services/domains/publication_identifiers/normalize.py
 delete mode 100644 build/lib/app/services/domains/publication_identifiers/types.py
 delete mode 100644 build/lib/app/services/domains/publications/__init__.py
 delete mode 100644 build/lib/app/services/domains/publications/application.py
 delete mode 100644 build/lib/app/services/domains/publications/counts.py
 delete mode 100644 build/lib/app/services/domains/publications/enrichment.py
 delete mode 100644 build/lib/app/services/domains/publications/listing.py
 delete mode 100644 build/lib/app/services/domains/publications/modes.py
 delete mode 100644 build/lib/app/services/domains/publications/pdf_queue.py
 delete mode 100644 build/lib/app/services/domains/publications/pdf_resolution_pipeline.py
 delete mode 100644 build/lib/app/services/domains/publications/queries.py
 delete mode 100644 build/lib/app/services/domains/publications/read_state.py
 delete mode 100644 build/lib/app/services/domains/publications/types.py
 delete mode 100644 build/lib/app/services/domains/runs/__init__.py
 delete mode 100644 build/lib/app/services/domains/runs/application.py
 delete mode 100644 build/lib/app/services/domains/runs/events.py
 delete mode 100644 build/lib/app/services/domains/runs/queue_queries.py
 delete mode 100644 build/lib/app/services/domains/runs/queue_service.py
 delete mode 100644 build/lib/app/services/domains/runs/runs_service.py
 delete mode 100644 build/lib/app/services/domains/runs/summary.py
 delete mode 100644 build/lib/app/services/domains/runs/types.py
 delete mode 100644 build/lib/app/services/domains/scholar/__init__.py
 delete mode 100644 build/lib/app/services/domains/scholar/author_rows.py
 delete mode 100644 build/lib/app/services/domains/scholar/parser.py
 delete mode 100644 build/lib/app/services/domains/scholar/parser_constants.py
 delete mode 100644 build/lib/app/services/domains/scholar/parser_types.py
 delete mode 100644 build/lib/app/services/domains/scholar/parser_utils.py
 delete mode 100644 build/lib/app/services/domains/scholar/profile_rows.py
 delete mode 100644 build/lib/app/services/domains/scholar/rate_limit.py
 delete mode 100644 build/lib/app/services/domains/scholar/source.py
 delete mode 100644 build/lib/app/services/domains/scholar/state_detection.py
 delete mode 100644 build/lib/app/services/domains/scholars/__init__.py
 delete mode 100644 build/lib/app/services/domains/scholars/application.py
 delete mode 100644 build/lib/app/services/domains/scholars/constants.py
 delete mode 100644 build/lib/app/services/domains/scholars/exceptions.py
 delete mode 100644 build/lib/app/services/domains/scholars/search_hints.py
 delete mode 100644 build/lib/app/services/domains/scholars/uploads.py
 delete mode 100644 build/lib/app/services/domains/scholars/validators.py
 delete mode 100644 build/lib/app/services/domains/settings/__init__.py
 delete mode 100644 build/lib/app/services/domains/settings/application.py
 delete mode 100644 build/lib/app/services/domains/unpaywall/__init__.py
 delete mode 100644 build/lib/app/services/domains/unpaywall/application.py
 delete mode 100644 build/lib/app/services/domains/unpaywall/pdf_discovery.py
 delete mode 100644 build/lib/app/services/domains/unpaywall/rate_limit.py
 delete mode 100644 build/lib/app/services/domains/users/__init__.py
 delete mode 100644 build/lib/app/services/domains/users/application.py
 delete mode 100644 build/lib/app/settings.py
 delete mode 100644 diag_pubs.py
 delete mode 100644 frontend/docs/website/package-lock.json
 delete mode 100644 test_enrich.py

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9a93c27..f82312a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -91,7 +91,7 @@ jobs:
 
       - name: Install frontend dependencies
         working-directory: frontend
-        run: npm install
+        run: npm ci
 
       - name: Frontend theme token policy
         working-directory: frontend
@@ -124,7 +124,7 @@ jobs:
           node-version: "20"
 
       - name: Install docs dependencies
-        run: npm install --prefix docs/website
+        run: npm ci --prefix docs/website
 
       - name: Docs build
         run: npm --prefix docs/website run build
diff --git a/.github/workflows/docs-pages.yml b/.github/workflows/docs-pages.yml
index 1e699e5..24ebe7a 100644
--- a/.github/workflows/docs-pages.yml
+++ b/.github/workflows/docs-pages.yml
@@ -32,7 +32,7 @@ jobs:
           node-version: "20"
 
       - name: Install docs dependencies
-        run: npm install --prefix docs/website
+        run: npm ci --prefix docs/website
 
       - name: Build docs site
         run: npm --prefix docs/website run build
diff --git a/.gitignore b/.gitignore
index 88c4ac6..68a3f87 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,9 +12,9 @@ htmlcov/
 *.log
 .DS_Store
 planning/
+build/
 frontend/node_modules/
 frontend/dist/
 frontend/.vite/
 docs/website/node_modules/
 docs/website/build/
-AGENTS.MD
diff --git a/build/lib/app/__init__.py b/build/lib/app/__init__.py
deleted file mode 100644
index 8b13789..0000000
--- a/build/lib/app/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/build/lib/app/api/__init__.py b/build/lib/app/api/__init__.py
deleted file mode 100644
index 3ce55a6..0000000
--- a/build/lib/app/api/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from __future__ import annotations
-
diff --git a/build/lib/app/api/deps.py b/build/lib/app/api/deps.py
deleted file mode 100644
index f9c5377..0000000
--- a/build/lib/app/api/deps.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-from fastapi import Depends, Request
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.api.errors import ApiException
-from app.auth import runtime as auth_runtime
-from app.db.models import User
-from app.db.session import get_db_session
-
-
-async def get_api_current_user(
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-) -> User:
-    current_user = await auth_runtime.get_authenticated_user(request, db_session)
-    if current_user is None:
-        raise ApiException(
-            status_code=401,
-            code="auth_required",
-            message="Authentication required.",
-        )
-    return current_user
-
-
-async def get_api_admin_user(
-    current_user: User = Depends(get_api_current_user),
-) -> User:
-    if not current_user.is_admin:
-        raise ApiException(
-            status_code=403,
-            code="forbidden",
-            message="Admin access required.",
-        )
-    return current_user
diff --git a/build/lib/app/api/errors.py b/build/lib/app/api/errors.py
deleted file mode 100644
index 976ccb8..0000000
--- a/build/lib/app/api/errors.py
+++ /dev/null
@@ -1,85 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.exception_handlers import (
-    http_exception_handler as fastapi_http_exception_handler,
-)
-from fastapi.exception_handlers import (
-    request_validation_exception_handler as fastapi_validation_exception_handler,
-)
-from fastapi.exceptions import RequestValidationError
-
-from app.api.responses import error_response
-
-
-def _is_api_path(path: str) -> bool:
-    return path.startswith("/api/")
-
-
-def _status_code_to_error_code(status_code: int) -> str:
-    mapping = {
-        400: "bad_request",
-        401: "auth_required",
-        403: "forbidden",
-        404: "not_found",
-        409: "conflict",
-        422: "validation_error",
-        429: "rate_limited",
-        500: "internal_error",
-    }
-    return mapping.get(status_code, "error")
-
-
-class ApiException(Exception):
-    def __init__(
-        self,
-        *,
-        status_code: int,
-        code: str,
-        message: str,
-        details: Any | None = None,
-    ) -> None:
-        super().__init__(message)
-        self.status_code = status_code
-        self.code = code
-        self.message = message
-        self.details = details
-
-
-def register_api_exception_handlers(app: FastAPI) -> None:
-    @app.exception_handler(ApiException)
-    async def _handle_api_exception(request: Request, exc: ApiException):
-        return error_response(
-            request,
-            status_code=exc.status_code,
-            code=exc.code,
-            message=exc.message,
-            details=exc.details,
-        )
-
-    @app.exception_handler(HTTPException)
-    async def _handle_http_exception(request: Request, exc: HTTPException):
-        if not _is_api_path(request.url.path):
-            return await fastapi_http_exception_handler(request, exc)
-        return error_response(
-            request,
-            status_code=exc.status_code,
-            code=_status_code_to_error_code(exc.status_code),
-            message=str(exc.detail) if exc.detail is not None else "Request failed.",
-            details=exc.detail if isinstance(exc.detail, (dict, list)) else None,
-        )
-
-    @app.exception_handler(RequestValidationError)
-    async def _handle_validation_exception(request: Request, exc: RequestValidationError):
-        if not _is_api_path(request.url.path):
-            return await fastapi_validation_exception_handler(request, exc)
-        return error_response(
-            request,
-            status_code=422,
-            code="validation_error",
-            message="Request validation failed.",
-            details=exc.errors(),
-        )
-
diff --git a/build/lib/app/api/media.py b/build/lib/app/api/media.py
deleted file mode 100644
index 00943bd..0000000
--- a/build/lib/app/api/media.py
+++ /dev/null
@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-import mimetypes
-
-from fastapi import APIRouter, Depends
-from fastapi.responses import FileResponse
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.api.deps import get_api_current_user
-from app.api.errors import ApiException
-from app.db.models import User
-from app.db.session import get_db_session
-from app.services.domains.scholars import application as scholar_service
-from app.settings import settings
-
-router = APIRouter(tags=["media"])
-
-
-@router.get("/scholar-images/{scholar_profile_id}/upload")
-async def get_uploaded_scholar_image(
-    scholar_profile_id: int,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    profile = await scholar_service.get_user_scholar_by_id(
-        db_session,
-        user_id=current_user.id,
-        scholar_profile_id=scholar_profile_id,
-    )
-    if profile is None:
-        raise ApiException(
-            status_code=404,
-            code="scholar_not_found",
-            message="Scholar not found.",
-        )
-    if not profile.profile_image_upload_path:
-        raise ApiException(
-            status_code=404,
-            code="scholar_image_not_found",
-            message="Scholar image not found.",
-        )
-
-    try:
-        image_path = scholar_service.resolve_upload_file_path(
-            upload_dir=settings.scholar_image_upload_dir,
-            relative_path=profile.profile_image_upload_path,
-        )
-    except scholar_service.ScholarServiceError as exc:
-        raise ApiException(
-            status_code=404,
-            code="scholar_image_not_found",
-            message="Scholar image not found.",
-        ) from exc
-
-    if not image_path.exists() or not image_path.is_file():
-        raise ApiException(
-            status_code=404,
-            code="scholar_image_not_found",
-            message="Scholar image not found.",
-        )
-
-    media_type = mimetypes.guess_type(str(image_path))[0] or "application/octet-stream"
-    return FileResponse(path=image_path, media_type=media_type)
diff --git a/build/lib/app/api/responses.py b/build/lib/app/api/responses.py
deleted file mode 100644
index 9976aba..0000000
--- a/build/lib/app/api/responses.py
+++ /dev/null
@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from fastapi.encoders import jsonable_encoder
-from starlette.requests import Request
-from starlette.responses import JSONResponse
-
-
-def _request_id(request: Request) -> str | None:
-    request_state = getattr(request, "state", None)
-    if request_state is None:
-        return None
-    return getattr(request_state, "request_id", None)
-
-
-def success_payload(
-    request: Request,
-    *,
-    data: Any,
-) -> dict[str, Any]:
-    return {
-        "data": data,
-        "meta": {
-            "request_id": _request_id(request),
-        },
-    }
-
-
-def success_response(
-    request: Request,
-    *,
-    data: Any,
-    status_code: int = 200,
-) -> JSONResponse:
-    payload = success_payload(request, data=data)
-    return JSONResponse(
-        status_code=status_code,
-        content=jsonable_encoder(payload),
-    )
-
-
-def error_response(
-    request: Request,
-    *,
-    status_code: int,
-    code: str,
-    message: str,
-    details: Any | None = None,
-) -> JSONResponse:
-    payload = {
-        "error": {
-            "code": code,
-            "message": message,
-            "details": details,
-        },
-        "meta": {
-            "request_id": _request_id(request),
-        },
-    }
-    return JSONResponse(
-        status_code=status_code,
-        content=jsonable_encoder(payload),
-    )
diff --git a/build/lib/app/api/router.py b/build/lib/app/api/router.py
deleted file mode 100644
index a11d98a..0000000
--- a/build/lib/app/api/router.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from __future__ import annotations
-
-from fastapi import APIRouter
-
-from app.api.routers import admin, admin_dbops, auth, publications, runs, scholars, settings
-
-router = APIRouter(prefix="/api/v1")
-router.include_router(auth.router)
-router.include_router(admin.router)
-router.include_router(admin_dbops.router)
-router.include_router(scholars.router)
-router.include_router(settings.router)
-router.include_router(runs.router)
-router.include_router(publications.router)
diff --git a/build/lib/app/api/routers/__init__.py b/build/lib/app/api/routers/__init__.py
deleted file mode 100644
index 3ce55a6..0000000
--- a/build/lib/app/api/routers/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from __future__ import annotations
-
diff --git a/build/lib/app/api/routers/admin.py b/build/lib/app/api/routers/admin.py
deleted file mode 100644
index 9844c3e..0000000
--- a/build/lib/app/api/routers/admin.py
+++ /dev/null
@@ -1,202 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-from fastapi import APIRouter, Depends, Request
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.api.deps import get_api_admin_user
-from app.api.errors import ApiException
-from app.api.responses import success_payload
-from app.api.schemas import (
-    AdminResetPasswordRequest,
-    AdminUserActiveUpdateRequest,
-    AdminUserCreateRequest,
-    AdminUserEnvelope,
-    AdminUsersListEnvelope,
-    MessageEnvelope,
-)
-from app.auth.deps import get_auth_service
-from app.auth.service import AuthService
-from app.db.models import User
-from app.db.session import get_db_session
-from app.services.domains.users import application as user_service
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/admin/users", tags=["api-admin-users"])
-
-
-def _serialize_user(user: User) -> dict[str, object]:
-    return {
-        "id": int(user.id),
-        "email": user.email,
-        "is_active": bool(user.is_active),
-        "is_admin": bool(user.is_admin),
-        "created_at": user.created_at,
-        "updated_at": user.updated_at,
-    }
-
-
-@router.get(
-    "",
-    response_model=AdminUsersListEnvelope,
-)
-async def list_users(
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    admin_user: User = Depends(get_api_admin_user),
-):
-    users = await user_service.list_users(db_session)
-    logger.info(
-        "api.admin.users_listed",
-        extra={
-            "event": "api.admin.users_listed",
-            "admin_user_id": int(admin_user.id),
-            "user_count": len(users),
-        },
-    )
-    return success_payload(
-        request,
-        data={
-            "users": [_serialize_user(user) for user in users],
-        },
-    )
-
-
-@router.post(
-    "",
-    response_model=AdminUserEnvelope,
-    status_code=201,
-)
-async def create_user(
-    payload: AdminUserCreateRequest,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    auth_service: AuthService = Depends(get_auth_service),
-    admin_user: User = Depends(get_api_admin_user),
-):
-    try:
-        validated_email = user_service.validate_email(payload.email)
-        validated_password = user_service.validate_password(payload.password)
-        created_user = await user_service.create_user(
-            db_session,
-            email=validated_email,
-            password_hash=auth_service.hash_password(validated_password),
-            is_admin=bool(payload.is_admin),
-        )
-    except user_service.UserServiceError as exc:
-        raise ApiException(
-            status_code=400,
-            code="invalid_user_input",
-            message=str(exc),
-        ) from exc
-
-    logger.info(
-        "api.admin.user_created",
-        extra={
-            "event": "api.admin.user_created",
-            "admin_user_id": int(admin_user.id),
-            "target_user_id": int(created_user.id),
-            "target_is_admin": bool(created_user.is_admin),
-        },
-    )
-    return success_payload(
-        request,
-        data=_serialize_user(created_user),
-    )
-
-
-@router.patch(
-    "/{user_id}/active",
-    response_model=AdminUserEnvelope,
-)
-async def set_user_active(
-    user_id: int,
-    payload: AdminUserActiveUpdateRequest,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    admin_user: User = Depends(get_api_admin_user),
-):
-    target_user = await user_service.get_user_by_id(db_session, user_id)
-    if target_user is None:
-        raise ApiException(
-            status_code=404,
-            code="user_not_found",
-            message="User not found.",
-        )
-    if (
-        int(target_user.id) == int(admin_user.id)
-        and bool(target_user.is_active)
-        and not bool(payload.is_active)
-    ):
-        raise ApiException(
-            status_code=400,
-            code="cannot_deactivate_self",
-            message="You cannot deactivate your own account.",
-        )
-    updated_user = await user_service.set_user_active(
-        db_session,
-        user=target_user,
-        is_active=bool(payload.is_active),
-    )
-    logger.info(
-        "api.admin.user_active_updated",
-        extra={
-            "event": "api.admin.user_active_updated",
-            "admin_user_id": int(admin_user.id),
-            "target_user_id": int(updated_user.id),
-            "is_active": bool(updated_user.is_active),
-        },
-    )
-    return success_payload(
-        request,
-        data=_serialize_user(updated_user),
-    )
-
-
-@router.post(
-    "/{user_id}/reset-password",
-    response_model=MessageEnvelope,
-)
-async def reset_user_password(
-    user_id: int,
-    payload: AdminResetPasswordRequest,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    auth_service: AuthService = Depends(get_auth_service),
-    admin_user: User = Depends(get_api_admin_user),
-):
-    target_user = await user_service.get_user_by_id(db_session, user_id)
-    if target_user is None:
-        raise ApiException(
-            status_code=404,
-            code="user_not_found",
-            message="User not found.",
-        )
-    try:
-        validated_password = user_service.validate_password(payload.new_password)
-    except user_service.UserServiceError as exc:
-        raise ApiException(
-            status_code=400,
-            code="invalid_password",
-            message=str(exc),
-        ) from exc
-
-    await user_service.set_user_password_hash(
-        db_session,
-        user=target_user,
-        password_hash=auth_service.hash_password(validated_password),
-    )
-    logger.info(
-        "api.admin.user_password_reset",
-        extra={
-            "event": "api.admin.user_password_reset",
-            "admin_user_id": int(admin_user.id),
-            "target_user_id": int(target_user.id),
-        },
-    )
-    return success_payload(
-        request,
-        data={"message": f"Password reset: {target_user.email}"},
-    )
diff --git a/build/lib/app/api/routers/admin_dbops.py b/build/lib/app/api/routers/admin_dbops.py
deleted file mode 100644
index 87fc3b8..0000000
--- a/build/lib/app/api/routers/admin_dbops.py
+++ /dev/null
@@ -1,349 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-from fastapi import APIRouter, Depends, Path, Query, Request
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.api.deps import get_api_admin_user
-from app.api.errors import ApiException
-from app.api.responses import success_payload
-from app.api.schemas import (
-    AdminDbIntegrityEnvelope,
-    AdminPdfQueueBulkEnqueueEnvelope,
-    AdminPdfQueueRequeueEnvelope,
-    AdminPdfQueueEnvelope,
-    AdminDbRepairJobsEnvelope,
-    AdminRepairPublicationLinksEnvelope,
-    AdminRepairPublicationLinksRequest,
-)
-from app.db.models import DataRepairJob, User
-from app.db.session import get_db_session
-from app.services.domains.dbops import (
-    collect_integrity_report,
-    list_repair_jobs,
-    run_publication_link_repair,
-)
-from app.services.domains.publications import application as publication_service
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/admin/db", tags=["api-admin-dbops"])
-
-
-def _serialize_repair_job(job: DataRepairJob) -> dict[str, object]:
-    return {
-        "id": int(job.id),
-        "job_name": job.job_name,
-        "requested_by": job.requested_by,
-        "dry_run": bool(job.dry_run),
-        "status": job.status,
-        "scope": dict(job.scope or {}),
-        "summary": dict(job.summary or {}),
-        "error_text": job.error_text,
-        "started_at": job.started_at,
-        "finished_at": job.finished_at,
-        "created_at": job.created_at,
-        "updated_at": job.updated_at,
-    }
-
-
-def _requested_by_value(*, payload: AdminRepairPublicationLinksRequest, admin_user: User) -> str:
-    from_payload = (payload.requested_by or "").strip()
-    return from_payload or admin_user.email
-
-
-def _serialize_pdf_queue_item(item) -> dict[str, object]:
-    return {
-        "publication_id": item.publication_id,
-        "title": item.title,
-        "display_identifier": _serialize_display_identifier(item.display_identifier),
-        "pdf_url": item.pdf_url,
-        "status": item.status,
-        "attempt_count": item.attempt_count,
-        "last_failure_reason": item.last_failure_reason,
-        "last_failure_detail": item.last_failure_detail,
-        "last_source": item.last_source,
-        "requested_by_user_id": item.requested_by_user_id,
-        "requested_by_email": item.requested_by_email,
-        "queued_at": item.queued_at,
-        "last_attempt_at": item.last_attempt_at,
-        "resolved_at": item.resolved_at,
-        "updated_at": item.updated_at,
-    }
-
-
-def _serialize_display_identifier(value) -> dict[str, object] | None:
-    if value is None:
-        return None
-    return {
-        "kind": value.kind,
-        "value": value.value,
-        "label": value.label,
-        "url": value.url,
-        "confidence_score": float(value.confidence_score),
-    }
-
-
-def _requeue_response_state(*, queued: bool) -> tuple[str, str]:
-    if queued:
-        return "queued", "PDF lookup queued."
-    return "blocked", "PDF lookup is already queued or currently running."
-
-
-def _bulk_enqueue_message(*, queued_count: int, requested_count: int) -> str:
-    if requested_count == 0:
-        return "No missing-PDF publications were found."
-    if queued_count == 0:
-        return "No publications were queued; all candidates were already in-flight."
-    return f"Queued {queued_count} publication(s) for PDF lookup."
-
-
-def _resolve_pdf_queue_paging(
-    *,
-    page: int,
-    page_size: int,
-    limit: int | None,
-    offset: int | None,
-) -> tuple[int, int, int]:
-    resolved_limit = int(limit) if limit is not None else int(page_size)
-    resolved_offset = int(offset) if offset is not None else max((int(page) - 1) * resolved_limit, 0)
-    resolved_page = max((resolved_offset // max(resolved_limit, 1)) + 1, 1)
-    return resolved_page, max(resolved_limit, 1), max(resolved_offset, 0)
-
-
-def _pdf_queue_page_data(*, total_count: int, page: int, page_size: int, offset: int) -> dict[str, object]:
-    return {
-        "total_count": int(total_count),
-        "page": int(page),
-        "page_size": int(page_size),
-        "has_prev": int(offset) > 0,
-        "has_next": int(offset) + int(page_size) < int(total_count),
-    }
-
-
-@router.get(
-    "/integrity",
-    response_model=AdminDbIntegrityEnvelope,
-)
-async def get_integrity_report(
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    admin_user: User = Depends(get_api_admin_user),
-):
-    report = await collect_integrity_report(db_session)
-    logger.info(
-        "api.admin.db.integrity_checked",
-        extra={
-            "event": "api.admin.db.integrity_checked",
-            "admin_user_id": int(admin_user.id),
-            "status": report.get("status"),
-            "failure_count": len(report.get("failures", [])),
-            "warning_count": len(report.get("warnings", [])),
-        },
-    )
-    return success_payload(request, data=report)
-
-
-@router.get(
-    "/repair-jobs",
-    response_model=AdminDbRepairJobsEnvelope,
-)
-async def get_repair_jobs(
-    request: Request,
-    limit: int = Query(default=50, ge=1, le=200),
-    db_session: AsyncSession = Depends(get_db_session),
-    admin_user: User = Depends(get_api_admin_user),
-):
-    jobs = await list_repair_jobs(db_session, limit=limit)
-    logger.info(
-        "api.admin.db.repair_jobs_listed",
-        extra={
-            "event": "api.admin.db.repair_jobs_listed",
-            "admin_user_id": int(admin_user.id),
-            "limit": int(limit),
-            "job_count": len(jobs),
-        },
-    )
-    return success_payload(
-        request,
-        data={"jobs": [_serialize_repair_job(job) for job in jobs]},
-    )
-
-
-@router.get(
-    "/pdf-queue",
-    response_model=AdminPdfQueueEnvelope,
-)
-async def get_pdf_queue(
-    request: Request,
-    page: int = Query(default=1, ge=1),
-    page_size: int = Query(default=100, ge=1, le=500),
-    limit: int | None = Query(default=None, ge=1, le=500),
-    offset: int | None = Query(default=None, ge=0),
-    status: str | None = Query(default=None),
-    db_session: AsyncSession = Depends(get_db_session),
-    admin_user: User = Depends(get_api_admin_user),
-):
-    normalized_status = (status or "").strip().lower() or None
-    resolved_page, resolved_limit, resolved_offset = _resolve_pdf_queue_paging(
-        page=page,
-        page_size=page_size,
-        limit=limit,
-        offset=offset,
-    )
-    queue_page = await publication_service.list_pdf_queue_page(
-        db_session,
-        limit=resolved_limit,
-        offset=resolved_offset,
-        status=normalized_status,
-    )
-    logger.info(
-        "api.admin.db.pdf_queue_listed",
-        extra={
-            "event": "api.admin.db.pdf_queue_listed",
-            "admin_user_id": int(admin_user.id),
-            "page": int(resolved_page),
-            "page_size": int(resolved_limit),
-            "offset": int(resolved_offset),
-            "status": normalized_status,
-            "item_count": len(queue_page.items),
-            "total_count": int(queue_page.total_count),
-        },
-    )
-    return success_payload(
-        request,
-        data={
-            "items": [_serialize_pdf_queue_item(item) for item in queue_page.items],
-            **_pdf_queue_page_data(
-                total_count=queue_page.total_count,
-                page=resolved_page,
-                page_size=resolved_limit,
-                offset=resolved_offset,
-            ),
-        },
-    )
-
-
-@router.post(
-    "/pdf-queue/{publication_id}/requeue",
-    response_model=AdminPdfQueueRequeueEnvelope,
-)
-async def requeue_pdf_lookup(
-    request: Request,
-    publication_id: int = Path(ge=1),
-    db_session: AsyncSession = Depends(get_db_session),
-    admin_user: User = Depends(get_api_admin_user),
-):
-    result = await publication_service.enqueue_retry_pdf_job_for_publication_id(
-        db_session,
-        user_id=int(admin_user.id),
-        request_email=admin_user.email,
-        publication_id=publication_id,
-    )
-    if not result.publication_exists:
-        raise ApiException(
-            status_code=404,
-            code="publication_not_found",
-            message="Publication not found.",
-        )
-    status, message = _requeue_response_state(queued=result.queued)
-    logger.info(
-        "api.admin.db.pdf_queue_requeue_requested",
-        extra={
-            "event": "api.admin.db.pdf_queue_requeue_requested",
-            "admin_user_id": int(admin_user.id),
-            "publication_id": int(publication_id),
-            "queued": bool(result.queued),
-        },
-    )
-    return success_payload(
-        request,
-        data={
-            "publication_id": int(publication_id),
-            "queued": bool(result.queued),
-            "status": status,
-            "message": message,
-        },
-    )
-
-
-@router.post(
-    "/pdf-queue/requeue-all",
-    response_model=AdminPdfQueueBulkEnqueueEnvelope,
-)
-async def requeue_all_missing_pdfs(
-    request: Request,
-    limit: int = Query(default=1000, ge=1, le=5000),
-    db_session: AsyncSession = Depends(get_db_session),
-    admin_user: User = Depends(get_api_admin_user),
-):
-    result = await publication_service.enqueue_all_missing_pdf_jobs(
-        db_session,
-        user_id=int(admin_user.id),
-        request_email=admin_user.email,
-        limit=limit,
-    )
-    logger.info(
-        "api.admin.db.pdf_queue_requeue_all",
-        extra={
-            "event": "api.admin.db.pdf_queue_requeue_all",
-            "admin_user_id": int(admin_user.id),
-            "limit": int(limit),
-            "requested_count": int(result.requested_count),
-            "queued_count": int(result.queued_count),
-        },
-    )
-    return success_payload(
-        request,
-        data={
-            "requested_count": int(result.requested_count),
-            "queued_count": int(result.queued_count),
-            "message": _bulk_enqueue_message(
-                queued_count=int(result.queued_count),
-                requested_count=int(result.requested_count),
-            ),
-        },
-    )
-
-
-@router.post(
-    "/repairs/publication-links",
-    response_model=AdminRepairPublicationLinksEnvelope,
-)
-async def trigger_publication_link_repair(
-    payload: AdminRepairPublicationLinksRequest,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    admin_user: User = Depends(get_api_admin_user),
-):
-    try:
-        result = await run_publication_link_repair(
-            db_session,
-            scope_mode=payload.scope_mode,
-            user_id=payload.user_id,
-            scholar_profile_ids=payload.scholar_profile_ids,
-            dry_run=bool(payload.dry_run),
-            gc_orphan_publications=bool(payload.gc_orphan_publications),
-            requested_by=_requested_by_value(payload=payload, admin_user=admin_user),
-        )
-    except ValueError as exc:
-        raise ApiException(
-            status_code=400,
-            code="invalid_repair_scope",
-            message=str(exc),
-        ) from exc
-    logger.info(
-        "api.admin.db.publication_link_repair_triggered",
-        extra={
-            "event": "api.admin.db.publication_link_repair_triggered",
-            "admin_user_id": int(admin_user.id),
-            "scope_mode": payload.scope_mode,
-            "target_user_id": int(payload.user_id) if payload.user_id is not None else None,
-            "dry_run": bool(payload.dry_run),
-            "gc_orphan_publications": bool(payload.gc_orphan_publications),
-            "job_id": int(result["job_id"]),
-            "status": result["status"],
-        },
-    )
-    return success_payload(request, data=result)
diff --git a/build/lib/app/api/routers/auth.py b/build/lib/app/api/routers/auth.py
deleted file mode 100644
index 8f8da17..0000000
--- a/build/lib/app/api/routers/auth.py
+++ /dev/null
@@ -1,237 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-from fastapi import APIRouter, Depends, Request
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.api.errors import ApiException
-from app.api.deps import get_api_current_user
-from app.api.responses import success_payload
-from app.api.schemas import (
-    AuthMeEnvelope,
-    ChangePasswordRequest,
-    CsrfBootstrapEnvelope,
-    LoginEnvelope,
-    LoginRequest,
-    MessageEnvelope,
-)
-from app.auth.deps import get_auth_service, get_login_rate_limiter
-from app.auth.rate_limit import SlidingWindowRateLimiter
-from app.auth import runtime as auth_runtime
-from app.auth.service import AuthService
-from app.auth.session import set_session_user
-from app.db.models import User
-from app.db.session import get_db_session
-from app.security.csrf import ensure_csrf_token
-from app.services.domains.users import application as user_service
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/auth", tags=["api-auth"])
-
-
-def _login_limiter_key_and_email(request: Request, payload: LoginRequest) -> tuple[str, str]:
-    return auth_runtime.login_rate_limit_key(request, payload.email), payload.email.strip().lower()
-
-
-def _raise_rate_limited(normalized_email: str, retry_after_seconds: int) -> None:
-    logger.warning(
-        "api.auth.login_rate_limited",
-        extra={
-            "event": "api.auth.login_rate_limited",
-            "email": normalized_email,
-            "retry_after_seconds": retry_after_seconds,
-        },
-    )
-    raise ApiException(
-        status_code=429,
-        code="rate_limited",
-        message="Too many login attempts. Please try again later.",
-        details={"retry_after_seconds": retry_after_seconds},
-    )
-
-
-def _serialize_user_payload(user: User) -> dict[str, object]:
-    return {
-        "id": int(user.id),
-        "email": user.email,
-        "is_admin": bool(user.is_admin),
-        "is_active": bool(user.is_active),
-    }
-
-
-def _raise_invalid_credentials(*, normalized_email: str) -> None:
-    logger.info(
-        "api.auth.login_failed",
-        extra={"event": "api.auth.login_failed", "email": normalized_email},
-    )
-    raise ApiException(
-        status_code=401,
-        code="invalid_credentials",
-        message="Invalid email or password.",
-    )
-
-
-@router.post(
-    "/login",
-    response_model=LoginEnvelope,
-)
-async def login(
-    payload: LoginRequest,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    auth_service: AuthService = Depends(get_auth_service),
-    rate_limiter: SlidingWindowRateLimiter = Depends(get_login_rate_limiter),
-):
-    limiter_key, normalized_email = _login_limiter_key_and_email(request, payload)
-    decision = rate_limiter.check(limiter_key)
-    if not decision.allowed:
-        _raise_rate_limited(normalized_email, int(decision.retry_after_seconds))
-
-    user = await auth_service.authenticate_user(
-        db_session,
-        email=payload.email,
-        password=payload.password,
-    )
-    if user is None:
-        rate_limiter.record_failure(limiter_key)
-        _raise_invalid_credentials(normalized_email=normalized_email)
-
-    rate_limiter.reset(limiter_key)
-    set_session_user(
-        request,
-        user_id=user.id,
-        email=user.email,
-        is_admin=user.is_admin,
-    )
-    logger.info(
-        "api.auth.login_succeeded",
-        extra={
-            "event": "api.auth.login_succeeded",
-            "user_id": user.id,
-            "is_admin": user.is_admin,
-        },
-    )
-    return success_payload(
-        request,
-        data={
-            "authenticated": True,
-            "csrf_token": ensure_csrf_token(request),
-            "user": _serialize_user_payload(user),
-        },
-    )
-
-
-@router.get(
-    "/me",
-    response_model=AuthMeEnvelope,
-)
-async def get_current_session(
-    request: Request,
-    current_user: User = Depends(get_api_current_user),
-):
-    return success_payload(
-        request,
-        data={
-            "authenticated": True,
-            "csrf_token": ensure_csrf_token(request),
-            "user": _serialize_user_payload(current_user),
-        },
-    )
-
-
-@router.get(
-    "/csrf",
-    response_model=CsrfBootstrapEnvelope,
-)
-async def get_csrf_bootstrap(
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-):
-    current_user = await auth_runtime.get_authenticated_user(request, db_session)
-    return success_payload(
-        request,
-        data={
-            "csrf_token": ensure_csrf_token(request),
-            "authenticated": current_user is not None,
-        },
-    )
-
-
-@router.post(
-    "/change-password",
-    response_model=MessageEnvelope,
-)
-async def change_password(
-    payload: ChangePasswordRequest,
-    request: Request,
-    current_user: User = Depends(get_api_current_user),
-    db_session: AsyncSession = Depends(get_db_session),
-    auth_service: AuthService = Depends(get_auth_service),
-):
-    if not auth_service.verify_password(
-        password_hash=current_user.password_hash,
-        password=payload.current_password,
-    ):
-        raise ApiException(
-            status_code=400,
-            code="invalid_current_password",
-            message="Current password is incorrect.",
-        )
-    if payload.new_password != payload.confirm_password:
-        raise ApiException(
-            status_code=400,
-            code="password_confirmation_mismatch",
-            message="New password and confirmation do not match.",
-        )
-    try:
-        validated_password = user_service.validate_password(payload.new_password)
-    except user_service.UserServiceError as exc:
-        raise ApiException(
-            status_code=400,
-            code="invalid_password",
-            message=str(exc),
-        ) from exc
-
-    await user_service.set_user_password_hash(
-        db_session,
-        user=current_user,
-        password_hash=auth_service.hash_password(validated_password),
-    )
-    logger.info(
-        "api.auth.password_changed",
-        extra={
-            "event": "api.auth.password_changed",
-            "user_id": int(current_user.id),
-        },
-    )
-    return success_payload(
-        request,
-        data={"message": "Password updated successfully."},
-    )
-
-
-@router.post(
-    "/logout",
-    response_model=MessageEnvelope,
-)
-async def logout(
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-):
-    current_user = await auth_runtime.get_authenticated_user(request, db_session)
-    auth_runtime.invalidate_session(request)
-    logger.info(
-        "api.auth.logout",
-        extra={
-            "event": "api.auth.logout",
-            "user_id": int(current_user.id) if current_user is not None else None,
-        },
-    )
-    return success_payload(
-        request,
-        data={
-            "message": "Logged out.",
-        },
-    )
diff --git a/build/lib/app/api/routers/publications.py b/build/lib/app/api/routers/publications.py
deleted file mode 100644
index 2a96b8b..0000000
--- a/build/lib/app/api/routers/publications.py
+++ /dev/null
@@ -1,528 +0,0 @@
-from __future__ import annotations
-
-import logging
-from typing import Literal
-
-from fastapi import APIRouter, Depends, Path, Query, Request
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.api.deps import get_api_current_user
-from app.api.errors import ApiException
-from app.api.responses import success_payload
-from app.api.schemas import (
-    MarkAllReadEnvelope,
-    MarkSelectedReadEnvelope,
-    MarkSelectedReadRequest,
-    PublicationsListEnvelope,
-    RetryPublicationPdfEnvelope,
-    RetryPublicationPdfRequest,
-    TogglePublicationFavoriteEnvelope,
-    TogglePublicationFavoriteRequest,
-)
-from app.db.models import User
-from app.db.session import get_db_session
-from app.services.domains.publication_identifiers import application as identifier_service
-from app.services.domains.publications import application as publication_service
-from app.services.domains.scholars import application as scholar_service
-from app.settings import settings
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/publications", tags=["api-publications"])
-
-
-async def _require_selected_profile(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    selected_scholar_id: int | None,
-) -> None:
-    if selected_scholar_id is None:
-        return
-    selected_profile = await scholar_service.get_user_scholar_by_id(
-        db_session,
-        user_id=user_id,
-        scholar_profile_id=selected_scholar_id,
-    )
-    if selected_profile is None:
-        raise ApiException(
-            status_code=404,
-            code="scholar_not_found",
-            message="Scholar filter not found.",
-        )
-
-
-def _serialize_publication_item(item) -> dict[str, object]:
-    return {
-        "publication_id": item.publication_id,
-        "scholar_profile_id": item.scholar_profile_id,
-        "scholar_label": item.scholar_label,
-        "title": item.title,
-        "year": item.year,
-        "citation_count": item.citation_count,
-        "venue_text": item.venue_text,
-        "pub_url": item.pub_url,
-        "display_identifier": _serialize_display_identifier(item.display_identifier),
-        "pdf_url": item.pdf_url,
-        "pdf_status": item.pdf_status,
-        "pdf_attempt_count": item.pdf_attempt_count,
-        "pdf_failure_reason": item.pdf_failure_reason,
-        "pdf_failure_detail": item.pdf_failure_detail,
-        "is_read": item.is_read,
-        "is_favorite": item.is_favorite,
-        "first_seen_at": item.first_seen_at,
-        "is_new_in_latest_run": item.is_new_in_latest_run,
-    }
-
-
-def _serialize_display_identifier(value) -> dict[str, object] | None:
-    if value is None:
-        return None
-    return {
-        "kind": value.kind,
-        "value": value.value,
-        "label": value.label,
-        "url": value.url,
-        "confidence_score": float(value.confidence_score),
-    }
-
-
-async def _publication_counts(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    selected_scholar_id: int | None,
-    favorite_only: bool,
-) -> tuple[int, int, int, int]:
-    unread_count = await publication_service.count_unread_for_user(
-        db_session,
-        user_id=user_id,
-        scholar_profile_id=selected_scholar_id,
-        favorite_only=favorite_only,
-    )
-    favorites_count = await publication_service.count_favorite_for_user(
-        db_session,
-        user_id=user_id,
-        scholar_profile_id=selected_scholar_id,
-    )
-    latest_count = await publication_service.count_latest_for_user(
-        db_session,
-        user_id=user_id,
-        scholar_profile_id=selected_scholar_id,
-        favorite_only=favorite_only,
-    )
-    total_count = await publication_service.count_for_user(
-        db_session,
-        user_id=user_id,
-        mode=publication_service.MODE_ALL,
-        scholar_profile_id=selected_scholar_id,
-        favorite_only=favorite_only,
-    )
-    return unread_count, favorites_count, latest_count, total_count
-
-
-async def _list_publications_for_request(
-    db_session: AsyncSession,
-    *,
-    current_user: User,
-    mode: Literal["all", "unread", "latest", "new"] | None,
-    favorite_only: bool,
-    scholar_profile_id: int | None,
-    limit: int,
-    offset: int,
-) -> tuple[str, int | None, list]:
-    resolved_mode = publication_service.resolve_publication_view_mode(mode)
-    selected_scholar_id = scholar_profile_id
-    await _require_selected_profile(
-        db_session,
-        user_id=current_user.id,
-        selected_scholar_id=selected_scholar_id,
-    )
-    publications = await publication_service.list_for_user(
-        db_session,
-        user_id=current_user.id,
-        mode=resolved_mode,
-        scholar_profile_id=selected_scholar_id,
-        favorite_only=favorite_only,
-        limit=limit,
-        offset=offset,
-    )
-    await publication_service.schedule_missing_pdf_enrichment_for_user(
-        db_session,
-        user_id=current_user.id,
-        request_email=current_user.email,
-        items=publications,
-        max_items=settings.unpaywall_max_items_per_request,
-    )
-    hydrated = await publication_service.hydrate_pdf_enrichment_state(
-        db_session,
-        items=publications,
-    )
-    return resolved_mode, selected_scholar_id, hydrated
-
-
-def _resolve_publications_paging(
-    *,
-    page: int,
-    page_size: int,
-    limit: int | None,
-    offset: int | None,
-) -> tuple[int, int, int]:
-    resolved_limit = int(limit) if limit is not None else int(page_size)
-    resolved_offset = int(offset) if offset is not None else max((int(page) - 1) * resolved_limit, 0)
-    resolved_page = max((resolved_offset // max(resolved_limit, 1)) + 1, 1)
-    return resolved_page, max(resolved_limit, 1), max(resolved_offset, 0)
-
-
-def _publications_list_data(
-    *,
-    mode: str,
-    favorite_only: bool,
-    selected_scholar_id: int | None,
-    unread_count: int,
-    favorites_count: int,
-    latest_count: int,
-    total_count: int,
-    publications: list,
-    page: int,
-    page_size: int,
-    offset: int,
-) -> dict[str, object]:
-    return {
-        "mode": mode,
-        "favorite_only": favorite_only,
-        "selected_scholar_profile_id": selected_scholar_id,
-        "unread_count": unread_count,
-        "favorites_count": favorites_count,
-        "latest_count": latest_count,
-        "new_count": latest_count,
-        "total_count": total_count,
-        "page": int(page),
-        "page_size": int(page_size),
-        "has_prev": int(offset) > 0,
-        "has_next": int(offset) + int(page_size) < int(total_count),
-        "publications": [_serialize_publication_item(item) for item in publications],
-    }
-
-
-def _retry_pdf_message(*, queued: bool, resolved_pdf: bool, pdf_status: str) -> str:
-    if resolved_pdf:
-        return "Open-access PDF link already resolved."
-    if queued:
-        return "PDF lookup queued."
-    if pdf_status in {"queued", "running"}:
-        return "PDF lookup is already queued."
-    return "No open-access PDF link found."
-
-
-def _favorite_message(*, is_favorite: bool) -> str:
-    if is_favorite:
-        return "Publication marked as favorite."
-    return "Publication removed from favorites."
-
-
-async def _retry_publication_state(
-    db_session: AsyncSession,
-    *,
-    current_user: User,
-    scholar_profile_id: int,
-    publication_id: int,
-):
-    publication = await publication_service.retry_pdf_for_user(
-        db_session,
-        user_id=current_user.id,
-        scholar_profile_id=scholar_profile_id,
-        publication_id=publication_id,
-    )
-    if publication is None:
-        raise ApiException(
-            status_code=404,
-            code="publication_not_found",
-            message="Publication not found.",
-        )
-    queued = False
-    if not publication.pdf_url:
-        queued = await publication_service.schedule_retry_pdf_enrichment_for_row(
-            db_session,
-            user_id=current_user.id,
-            request_email=current_user.email,
-            item=publication,
-        )
-    hydrated = await publication_service.hydrate_pdf_enrichment_state(
-        db_session,
-        items=[publication],
-    )
-    current = hydrated[0] if hydrated else publication
-    return current, queued
-
-
-async def _favorite_publication_state(
-    db_session: AsyncSession,
-    *,
-    current_user: User,
-    scholar_profile_id: int,
-    publication_id: int,
-    is_favorite: bool,
-):
-    updated_count = await publication_service.set_publication_favorite_for_user(
-        db_session,
-        user_id=current_user.id,
-        scholar_profile_id=scholar_profile_id,
-        publication_id=publication_id,
-        is_favorite=is_favorite,
-    )
-    if updated_count <= 0:
-        raise ApiException(
-            status_code=404,
-            code="publication_not_found",
-            message="Publication not found.",
-        )
-    publication = await publication_service.get_publication_item_for_user(
-        db_session,
-        user_id=current_user.id,
-        scholar_profile_id=scholar_profile_id,
-        publication_id=publication_id,
-    )
-    if publication is None:
-        raise ApiException(
-            status_code=404,
-            code="publication_not_found",
-            message="Publication not found.",
-        )
-    hydrated = await publication_service.hydrate_pdf_enrichment_state(
-        db_session,
-        items=[publication],
-    )
-    current = hydrated[0] if hydrated else publication
-    identifiers = await identifier_service.overlay_publication_items_with_display_identifiers(
-        db_session,
-        items=[current],
-    )
-    return identifiers[0] if identifiers else current
-
-
-def _log_retry_pdf_result(
-    *,
-    current_user: User,
-    scholar_profile_id: int,
-    publication_id: int,
-    queued: bool,
-    resolved_pdf: bool,
-    pdf_status: str,
-    doi: str | None,
-) -> None:
-    logger.info(
-        "api.publications.retry_pdf",
-        extra={
-            "event": "api.publications.retry_pdf",
-            "user_id": current_user.id,
-            "scholar_profile_id": scholar_profile_id,
-            "publication_id": publication_id,
-            "queued": queued,
-            "resolved_pdf": resolved_pdf,
-            "pdf_status": pdf_status,
-        },
-    )
-
-
-@router.get(
-    "",
-    response_model=PublicationsListEnvelope,
-)
-async def list_publications(
-    request: Request,
-    mode: Literal["all", "unread", "latest", "new"] | None = Query(default=None),
-    favorite_only: bool = Query(default=False),
-    scholar_profile_id: int | None = Query(default=None, ge=1),
-    page: int = Query(default=1, ge=1),
-    page_size: int = Query(default=100, ge=1, le=500),
-    limit: int | None = Query(default=None, ge=1, le=1000),
-    offset: int | None = Query(default=None, ge=0),
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    resolved_page, resolved_limit, resolved_offset = _resolve_publications_paging(
-        page=page,
-        page_size=page_size,
-        limit=limit,
-        offset=offset,
-    )
-    resolved_mode, selected_scholar_id, publications = await _list_publications_for_request(
-        db_session,
-        current_user=current_user,
-        mode=mode,
-        favorite_only=favorite_only,
-        scholar_profile_id=scholar_profile_id,
-        limit=resolved_limit,
-        offset=resolved_offset,
-    )
-    unread_count, favorites_count, latest_count, total_count = await _publication_counts(
-        db_session,
-        user_id=current_user.id,
-        selected_scholar_id=selected_scholar_id,
-        favorite_only=favorite_only,
-    )
-    data = _publications_list_data(
-        mode=resolved_mode,
-        favorite_only=favorite_only,
-        selected_scholar_id=selected_scholar_id,
-        unread_count=unread_count,
-        favorites_count=favorites_count,
-        latest_count=latest_count,
-        total_count=total_count,
-        publications=publications,
-        page=resolved_page,
-        page_size=resolved_limit,
-        offset=resolved_offset,
-    )
-    return success_payload(request, data=data)
-
-
-@router.post(
-    "/mark-all-read",
-    response_model=MarkAllReadEnvelope,
-)
-async def mark_all_publications_read(
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    updated_count = await publication_service.mark_all_unread_as_read_for_user(
-        db_session,
-        user_id=current_user.id,
-    )
-    logger.info(
-        "api.publications.mark_all_read",
-        extra={
-            "event": "api.publications.mark_all_read",
-            "user_id": current_user.id,
-            "updated_count": updated_count,
-        },
-    )
-    return success_payload(
-        request,
-        data={
-            "message": "Marked all unread publications as read.",
-            "updated_count": updated_count,
-        },
-    )
-
-
-@router.post(
-    "/mark-read",
-    response_model=MarkSelectedReadEnvelope,
-)
-async def mark_selected_publications_read(
-    payload: MarkSelectedReadRequest,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    selection_pairs = sorted(
-        {
-            (int(item.scholar_profile_id), int(item.publication_id))
-            for item in payload.selections
-        }
-    )
-    updated_count = await publication_service.mark_selected_as_read_for_user(
-        db_session,
-        user_id=current_user.id,
-        selections=selection_pairs,
-    )
-    logger.info(
-        "api.publications.mark_selected_read",
-        extra={
-            "event": "api.publications.mark_selected_read",
-            "user_id": current_user.id,
-            "requested_count": len(selection_pairs),
-            "updated_count": updated_count,
-        },
-    )
-    return success_payload(
-        request,
-        data={
-            "message": "Marked selected publications as read.",
-            "requested_count": len(selection_pairs),
-            "updated_count": updated_count,
-        },
-    )
-
-
-@router.post(
-    "/{publication_id}/retry-pdf",
-    response_model=RetryPublicationPdfEnvelope,
-)
-async def retry_publication_pdf(
-    payload: RetryPublicationPdfRequest,
-    request: Request,
-    publication_id: int = Path(ge=1),
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    current, queued = await _retry_publication_state(
-        db_session,
-        current_user=current_user,
-        scholar_profile_id=payload.scholar_profile_id,
-        publication_id=publication_id,
-    )
-    resolved_pdf = bool(current.pdf_url)
-    message = _retry_pdf_message(
-        queued=queued,
-        resolved_pdf=resolved_pdf,
-        pdf_status=current.pdf_status,
-    )
-    _log_retry_pdf_result(
-        current_user=current_user,
-        scholar_profile_id=payload.scholar_profile_id,
-        publication_id=publication_id,
-        queued=queued,
-        resolved_pdf=resolved_pdf,
-        pdf_status=current.pdf_status,
-        doi=None,
-    )
-    return success_payload(
-        request,
-        data={
-            "message": message,
-            "queued": queued,
-            "resolved_pdf": resolved_pdf,
-            "publication": _serialize_publication_item(current),
-        },
-    )
-
-
-@router.post(
-    "/{publication_id}/favorite",
-    response_model=TogglePublicationFavoriteEnvelope,
-)
-async def toggle_publication_favorite(
-    payload: TogglePublicationFavoriteRequest,
-    request: Request,
-    publication_id: int = Path(ge=1),
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    current = await _favorite_publication_state(
-        db_session,
-        current_user=current_user,
-        scholar_profile_id=payload.scholar_profile_id,
-        publication_id=publication_id,
-        is_favorite=payload.is_favorite,
-    )
-    logger.info(
-        "api.publications.favorite",
-        extra={
-            "event": "api.publications.favorite",
-            "user_id": current_user.id,
-            "scholar_profile_id": payload.scholar_profile_id,
-            "publication_id": publication_id,
-            "is_favorite": bool(payload.is_favorite),
-        },
-    )
-    return success_payload(
-        request,
-        data={
-            "message": _favorite_message(is_favorite=bool(payload.is_favorite)),
-            "publication": _serialize_publication_item(current),
-        },
-    )
diff --git a/build/lib/app/api/routers/runs.py b/build/lib/app/api/routers/runs.py
deleted file mode 100644
index 4e85af4..0000000
--- a/build/lib/app/api/routers/runs.py
+++ /dev/null
@@ -1,845 +0,0 @@
-from __future__ import annotations
-
-import logging
-import re
-from typing import Any
-
-from fastapi import APIRouter, Depends, Query, Request
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.api.deps import get_api_current_user
-from app.api.errors import ApiException
-from app.api.responses import success_payload
-from fastapi.responses import StreamingResponse
-from app.api.schemas import (
-    ManualRunEnvelope,
-    QueueClearEnvelope,
-    QueueItemEnvelope,
-    QueueListEnvelope,
-    RunDetailEnvelope,
-    RunsListEnvelope,
-)
-from app.db.models import RunStatus, RunTriggerType, User
-from app.db.session import get_db_session
-from app.services.domains.ingestion import application as ingestion_service
-from app.services.domains.ingestion import safety as run_safety_service
-from app.services.domains.runs import application as run_service
-from app.services.domains.runs.events import event_generator
-from app.services.domains.settings import application as user_settings_service
-from app.settings import settings
-from app.api.runtime_deps import get_ingestion_service
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/runs", tags=["api-runs"])
-
-IDEMPOTENCY_HEADER = "Idempotency-Key"
-IDEMPOTENCY_MAX_LENGTH = 128
-IDEMPOTENCY_PATTERN = re.compile(r"^[A-Za-z0-9._:-]{8,128}$")
-
-
-def _int_value(value: Any, default: int = 0) -> int:
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        return default
-
-
-def _str_value(value: Any) -> str | None:
-    if value is None:
-        return None
-    text = str(value).strip()
-    return text if text else None
-
-
-def _bool_value(value: Any, default: bool = False) -> bool:
-    if isinstance(value, bool):
-        return value
-    if isinstance(value, str):
-        lowered = value.strip().lower()
-        if lowered in {"1", "true", "yes", "on"}:
-            return True
-        if lowered in {"0", "false", "no", "off"}:
-            return False
-    return default
-
-
-def _normalize_idempotency_key(raw_value: str | None) -> str | None:
-    if raw_value is None:
-        return None
-    candidate = raw_value.strip()
-    if not candidate:
-        return None
-    if len(candidate) > IDEMPOTENCY_MAX_LENGTH or not IDEMPOTENCY_PATTERN.match(candidate):
-        raise ApiException(
-            status_code=400,
-            code="invalid_idempotency_key",
-            message=(
-                "Invalid Idempotency-Key. Use 8-128 characters from: "
-                "A-Z a-z 0-9 . _ : -"
-            ),
-        )
-    return candidate
-
-
-def _serialize_run(run) -> dict[str, Any]:
-    summary = run_service.extract_run_summary(run.error_log)
-    return {
-        "id": int(run.id),
-        "trigger_type": run.trigger_type.value,
-        "status": run.status.value,
-        "start_dt": run.start_dt,
-        "end_dt": run.end_dt,
-        "scholar_count": int(run.scholar_count or 0),
-        "new_publication_count": int(run.new_pub_count or 0),
-        "failed_count": int(summary["failed_count"]),
-        "partial_count": int(summary["partial_count"]),
-    }
-
-
-def _serialize_queue_item(item) -> dict[str, Any]:
-    return {
-        "id": int(item.id),
-        "scholar_profile_id": int(item.scholar_profile_id),
-        "scholar_label": item.scholar_label,
-        "status": item.status,
-        "reason": item.reason,
-        "dropped_reason": item.dropped_reason,
-        "attempt_count": int(item.attempt_count),
-        "resume_cstart": int(item.resume_cstart),
-        "next_attempt_dt": item.next_attempt_dt,
-        "updated_at": item.updated_at,
-        "last_error": item.last_error,
-        "last_run_id": item.last_run_id,
-    }
-
-
-def _normalize_attempt_log(value: Any) -> list[dict[str, Any]]:
-    if not isinstance(value, list):
-        return []
-    normalized: list[dict[str, Any]] = []
-    for item in value:
-        if not isinstance(item, dict):
-            continue
-        normalized.append(
-            {
-                "attempt": _int_value(item.get("attempt"), 0),
-                "cstart": _int_value(item.get("cstart"), 0),
-                "state": _str_value(item.get("state")),
-                "state_reason": _str_value(item.get("state_reason")),
-                "status_code": (
-                    _int_value(item.get("status_code"))
-                    if item.get("status_code") is not None
-                    else None
-                ),
-                "fetch_error": _str_value(item.get("fetch_error")),
-            }
-        )
-    return normalized
-
-
-def _normalize_page_logs(value: Any) -> list[dict[str, Any]]:
-    if not isinstance(value, list):
-        return []
-    normalized: list[dict[str, Any]] = []
-    for item in value:
-        if not isinstance(item, dict):
-            continue
-        warning_codes = item.get("warning_codes")
-        normalized.append(
-            {
-                "page": _int_value(item.get("page"), 0),
-                "cstart": _int_value(item.get("cstart"), 0),
-                "state": _str_value(item.get("state")) or "unknown",
-                "state_reason": _str_value(item.get("state_reason")),
-                "status_code": (
-                    _int_value(item.get("status_code"))
-                    if item.get("status_code") is not None
-                    else None
-                ),
-                "publication_count": _int_value(item.get("publication_count"), 0),
-                "attempt_count": _int_value(item.get("attempt_count"), 0),
-                "has_show_more_button": _bool_value(item.get("has_show_more_button"), False),
-                "articles_range": _str_value(item.get("articles_range")),
-                "warning_codes": [
-                    str(code)
-                    for code in (warning_codes if isinstance(warning_codes, list) else [])
-                ],
-            }
-        )
-    return normalized
-
-
-def _normalize_debug(value: Any) -> dict[str, Any] | None:
-    if not isinstance(value, dict):
-        return None
-    marker_counts = value.get("marker_counts_nonzero")
-    warning_codes = value.get("warning_codes")
-    return {
-        "status_code": (
-            _int_value(value.get("status_code"))
-            if value.get("status_code") is not None
-            else None
-        ),
-        "final_url": _str_value(value.get("final_url")),
-        "fetch_error": _str_value(value.get("fetch_error")),
-        "body_sha256": _str_value(value.get("body_sha256")),
-        "body_length": (
-            _int_value(value.get("body_length"))
-            if value.get("body_length") is not None
-            else None
-        ),
-        "has_show_more_button": (
-            _bool_value(value.get("has_show_more_button"), False)
-            if value.get("has_show_more_button") is not None
-            else None
-        ),
-        "articles_range": _str_value(value.get("articles_range")),
-        "state_reason": _str_value(value.get("state_reason")),
-        "warning_codes": [
-            str(code)
-            for code in (warning_codes if isinstance(warning_codes, list) else [])
-        ],
-        "marker_counts_nonzero": {
-            str(key): _int_value(count, 0)
-            for key, count in (marker_counts.items() if isinstance(marker_counts, dict) else [])
-        },
-        "page_logs": _normalize_page_logs(value.get("page_logs")),
-        "attempt_log": _normalize_attempt_log(value.get("attempt_log")),
-    }
-
-
-def _normalize_scholar_result(value: Any) -> dict[str, Any]:
-    if not isinstance(value, dict):
-        return {
-            "scholar_profile_id": 0,
-            "scholar_id": "unknown",
-            "state": "unknown",
-            "state_reason": None,
-            "outcome": "failed",
-            "attempt_count": 0,
-            "publication_count": 0,
-            "start_cstart": 0,
-            "continuation_cstart": None,
-            "continuation_enqueued": False,
-            "continuation_cleared": False,
-            "warnings": [],
-            "error": None,
-            "debug": None,
-        }
-    warnings = value.get("warnings")
-    return {
-        "scholar_profile_id": _int_value(value.get("scholar_profile_id"), 0),
-        "scholar_id": _str_value(value.get("scholar_id")) or "unknown",
-        "state": _str_value(value.get("state")) or "unknown",
-        "state_reason": _str_value(value.get("state_reason")),
-        "outcome": _str_value(value.get("outcome")) or "failed",
-        "attempt_count": _int_value(value.get("attempt_count"), 0),
-        "publication_count": _int_value(value.get("publication_count"), 0),
-        "start_cstart": _int_value(value.get("start_cstart"), 0),
-        "continuation_cstart": (
-            _int_value(value.get("continuation_cstart"))
-            if value.get("continuation_cstart") is not None
-            else None
-        ),
-        "continuation_enqueued": _bool_value(value.get("continuation_enqueued"), False),
-        "continuation_cleared": _bool_value(value.get("continuation_cleared"), False),
-        "warnings": [str(item) for item in (warnings if isinstance(warnings, list) else [])],
-        "error": _str_value(value.get("error")),
-        "debug": _normalize_debug(value.get("debug")),
-    }
-
-
-def _manual_run_payload_from_run(
-    run,
-    *,
-    idempotency_key: str | None,
-    reused_existing_run: bool,
-    safety_state: dict[str, Any],
-) -> dict[str, Any]:
-    summary = run_service.extract_run_summary(run.error_log)
-    return {
-        "run_id": int(run.id),
-        "status": run.status.value,
-        "scholar_count": int(run.scholar_count or 0),
-        "succeeded_count": int(summary["succeeded_count"]),
-        "failed_count": int(summary["failed_count"]),
-        "partial_count": int(summary["partial_count"]),
-        "new_publication_count": int(run.new_pub_count or 0),
-        "reused_existing_run": reused_existing_run,
-        "idempotency_key": idempotency_key,
-        "safety_state": safety_state,
-    }
-
-
-async def _load_safety_state(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-) -> dict[str, Any]:
-    user_settings = await user_settings_service.get_or_create_settings(
-        db_session,
-        user_id=user_id,
-    )
-    previous_safety_state = run_safety_service.get_safety_event_context(user_settings)
-    if run_safety_service.clear_expired_cooldown(user_settings):
-        await db_session.commit()
-        await db_session.refresh(user_settings)
-        logger.info(
-            "api.runs.safety_cooldown_cleared",
-            extra={
-                "event": "api.runs.safety_cooldown_cleared",
-                "user_id": user_id,
-                "reason": previous_safety_state.get("cooldown_reason"),
-                "cooldown_until": previous_safety_state.get("cooldown_until"),
-                "metric_name": "api_runs_safety_cooldown_cleared_total",
-                "metric_value": 1,
-            },
-    )
-    return run_safety_service.get_safety_state_payload(user_settings)
-
-
-def _raise_manual_runs_disabled(*, user_id: int, safety_state: dict[str, Any]) -> None:
-    logger.warning(
-        "api.runs.manual_blocked_policy",
-        extra={
-            "event": "api.runs.manual_blocked_policy",
-            "user_id": user_id,
-            "policy": {"manual_run_allowed": False},
-            "safety_state": safety_state,
-            "metric_name": "api_runs_manual_blocked_policy_total",
-            "metric_value": 1,
-        },
-    )
-    raise ApiException(
-        status_code=403,
-        code="manual_runs_disabled",
-        message="Manual checks are disabled by server policy.",
-        details={
-            "policy": {"manual_run_allowed": False},
-            "safety_state": safety_state,
-        },
-    )
-
-
-async def _reused_manual_run_payload(
-    db_session: AsyncSession,
-    *,
-    request: Request,
-    user_id: int,
-    idempotency_key: str | None,
-    safety_state: dict[str, Any],
-) -> dict[str, Any] | None:
-    if idempotency_key is None:
-        return None
-    previous_run = await run_service.get_manual_run_by_idempotency_key(
-        db_session,
-        user_id=user_id,
-        idempotency_key=idempotency_key,
-    )
-    if previous_run is None:
-        return None
-    if previous_run.status == RunStatus.RUNNING:
-        raise ApiException(
-            status_code=409,
-            code="run_in_progress",
-            message="A run with this idempotency key is still in progress.",
-            details={"run_id": int(previous_run.id), "idempotency_key": idempotency_key},
-        )
-    return success_payload(
-        request,
-        data=_manual_run_payload_from_run(
-            previous_run,
-            idempotency_key=idempotency_key,
-            reused_existing_run=True,
-            safety_state=safety_state,
-        ),
-    )
-
-
-async def _run_ingestion_for_manual(
-    db_session: AsyncSession,
-    *,
-    ingest_service: ingestion_service.ScholarIngestionService,
-    user_id: int,
-    idempotency_key: str | None,
-):
-    user_settings = await user_settings_service.get_or_create_settings(
-        db_session,
-        user_id=user_id,
-    )
-    return await ingest_service.run_for_user(
-        db_session,
-        user_id=user_id,
-        trigger_type=RunTriggerType.MANUAL,
-        request_delay_seconds=user_settings.request_delay_seconds,
-        network_error_retries=settings.ingestion_network_error_retries,
-        retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
-        max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
-        page_size=settings.ingestion_page_size,
-        auto_queue_continuations=settings.ingestion_continuation_queue_enabled,
-        queue_delay_seconds=settings.ingestion_continuation_base_delay_seconds,
-        idempotency_key=idempotency_key,
-        alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
-        alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
-        alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
-    )
-
-
-async def _recover_integrity_error(
-    db_session: AsyncSession,
-    *,
-    request: Request,
-    user_id: int,
-    idempotency_key: str | None,
-    original_exc: IntegrityError,
-) -> dict[str, Any]:
-    if idempotency_key is None:
-        logger.exception(
-            "api.runs.manual_integrity_error",
-            extra={"event": "api.runs.manual_integrity_error", "user_id": user_id},
-        )
-        raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
-    existing_run = await run_service.get_manual_run_by_idempotency_key(
-        db_session,
-        user_id=user_id,
-        idempotency_key=idempotency_key,
-    )
-    if existing_run is None:
-        logger.exception(
-            "api.runs.manual_integrity_error",
-            extra={"event": "api.runs.manual_integrity_error", "user_id": user_id},
-        )
-        raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
-    if existing_run.status == RunStatus.RUNNING:
-        raise ApiException(
-            status_code=409,
-            code="run_in_progress",
-            message="A run with this idempotency key is still in progress.",
-            details={"run_id": int(existing_run.id), "idempotency_key": idempotency_key},
-        ) from original_exc
-    return success_payload(
-        request,
-        data=_manual_run_payload_from_run(
-            existing_run,
-            idempotency_key=idempotency_key,
-            reused_existing_run=True,
-            safety_state=await _load_safety_state(db_session, user_id=user_id),
-        ),
-    )
-
-
-async def _execute_manual_run(
-    db_session: AsyncSession,
-    *,
-    request: Request,
-    ingest_service: ingestion_service.ScholarIngestionService,
-    user_id: int,
-    idempotency_key: str | None,
-):
-    try:
-        return await _run_ingestion_for_manual(
-            db_session,
-            ingest_service=ingest_service,
-            user_id=user_id,
-            idempotency_key=idempotency_key,
-        )
-    except ingestion_service.RunAlreadyInProgressError as exc:
-        await db_session.rollback()
-        raise ApiException(
-            status_code=409,
-            code="run_in_progress",
-            message="A run is already in progress for this account.",
-        ) from exc
-    except ingestion_service.RunBlockedBySafetyPolicyError as exc:
-        await db_session.rollback()
-        _raise_manual_blocked_safety(exc=exc, user_id=user_id)
-    except IntegrityError as exc:
-        await db_session.rollback()
-        return await _recover_integrity_error(
-            db_session,
-            request=request,
-            user_id=user_id,
-            idempotency_key=idempotency_key,
-            original_exc=exc,
-        )
-    except Exception as exc:
-        await db_session.rollback()
-        _raise_manual_failed(exc=exc, user_id=user_id)
-
-
-def _raise_manual_blocked_safety(*, exc, user_id: int) -> None:
-    logger.info(
-        "api.runs.manual_blocked_safety",
-        extra={
-            "event": "api.runs.manual_blocked_safety",
-            "user_id": user_id,
-            "reason": exc.safety_state.get("cooldown_reason"),
-            "cooldown_until": exc.safety_state.get("cooldown_until"),
-            "cooldown_remaining_seconds": exc.safety_state.get("cooldown_remaining_seconds"),
-            "metric_name": "api_runs_manual_blocked_safety_total",
-            "metric_value": 1,
-        },
-    )
-    raise ApiException(
-        status_code=429,
-        code=exc.code,
-        message=exc.message,
-        details={"safety_state": exc.safety_state},
-    ) from exc
-
-
-def _raise_manual_failed(*, exc: Exception, user_id: int) -> None:
-    logger.exception(
-        "api.runs.manual_failed",
-        extra={"event": "api.runs.manual_failed", "user_id": user_id},
-    )
-    raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from exc
-
-
-def _manual_run_success_payload(
-    *,
-    run_summary,
-    idempotency_key: str | None,
-    safety_state: dict[str, Any],
-) -> dict[str, Any]:
-    return {
-        "run_id": run_summary.crawl_run_id,
-        "status": run_summary.status.value,
-        "scholar_count": run_summary.scholar_count,
-        "succeeded_count": run_summary.succeeded_count,
-        "failed_count": run_summary.failed_count,
-        "partial_count": run_summary.partial_count,
-        "new_publication_count": run_summary.new_publication_count,
-        "reused_existing_run": False,
-        "idempotency_key": idempotency_key,
-        "safety_state": safety_state,
-    }
-
-
-@router.get(
-    "",
-    response_model=RunsListEnvelope,
-)
-async def list_runs(
-    request: Request,
-    failed_only: bool = Query(default=False),
-    limit: int = Query(default=100, ge=1, le=500),
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    runs = await run_service.list_runs_for_user(
-        db_session,
-        user_id=current_user.id,
-        limit=limit,
-        failed_only=failed_only,
-    )
-    safety_state = await _load_safety_state(
-        db_session,
-        user_id=current_user.id,
-    )
-    return success_payload(
-        request,
-        data={
-            "runs": [_serialize_run(run) for run in runs],
-            "safety_state": safety_state,
-        },
-    )
-
-
-@router.get(
-    "/{run_id}",
-    response_model=RunDetailEnvelope,
-)
-async def get_run(
-    run_id: int,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    run = await run_service.get_run_for_user(
-        db_session,
-        user_id=current_user.id,
-        run_id=run_id,
-    )
-    if run is None:
-        raise ApiException(
-            status_code=404,
-            code="run_not_found",
-            message="Run not found.",
-        )
-    error_log = run.error_log if isinstance(run.error_log, dict) else {}
-    scholar_results = error_log.get("scholar_results")
-    if not isinstance(scholar_results, list):
-        scholar_results = []
-    safety_state = await _load_safety_state(
-        db_session,
-        user_id=current_user.id,
-    )
-    return success_payload(
-        request,
-        data={
-            "run": _serialize_run(run),
-            "summary": run_service.extract_run_summary(error_log),
-            "scholar_results": [_normalize_scholar_result(item) for item in scholar_results],
-            "safety_state": safety_state,
-        },
-    )
-
-
-@router.post(
-    "/{run_id}/cancel",
-    response_model=RunDetailEnvelope,
-)
-async def cancel_run(
-    run_id: int,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    run = await run_service.get_run_for_user(
-        db_session,
-        user_id=current_user.id,
-        run_id=run_id,
-    )
-    if run is None:
-        raise ApiException(
-            status_code=404,
-            code="run_not_found",
-            message="Run not found.",
-        )
-        
-    if run.status == RunStatus.RUNNING:
-        run.status = RunStatus.CANCELED
-        await db_session.commit()
-        await db_session.refresh(run)
-
-    error_log = run.error_log if isinstance(run.error_log, dict) else {}
-    scholar_results = error_log.get("scholar_results")
-    if not isinstance(scholar_results, list):
-        scholar_results = []
-        
-    safety_state = await _load_safety_state(
-        db_session,
-        user_id=current_user.id,
-    )
-    
-    return success_payload(
-        request,
-        data={
-            "run": _serialize_run(run),
-            "summary": run_service.extract_run_summary(error_log),
-            "scholar_results": [_normalize_scholar_result(item) for item in scholar_results],
-            "safety_state": safety_state,
-        },
-    )
-
-
-@router.post(
-    "/manual",
-    response_model=ManualRunEnvelope,
-)
-async def run_manual(
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-    ingest_service: ingestion_service.ScholarIngestionService = Depends(get_ingestion_service),
-):
-    safety_state = await _load_safety_state(
-        db_session,
-        user_id=current_user.id,
-    )
-    if not settings.ingestion_manual_run_allowed:
-        _raise_manual_runs_disabled(user_id=current_user.id, safety_state=safety_state)
-
-    idempotency_key = _normalize_idempotency_key(request.headers.get(IDEMPOTENCY_HEADER))
-    reused_payload = await _reused_manual_run_payload(
-        db_session,
-        request=request,
-        user_id=current_user.id,
-        idempotency_key=idempotency_key,
-        safety_state=safety_state,
-    )
-    if reused_payload is not None:
-        return reused_payload
-
-    run_summary = await _execute_manual_run(
-        db_session,
-        request=request,
-        ingest_service=ingest_service,
-        user_id=current_user.id,
-        idempotency_key=idempotency_key,
-    )
-    if isinstance(run_summary, dict):
-        return run_summary
-
-    current_safety_state = await _load_safety_state(
-        db_session,
-        user_id=current_user.id,
-    )
-    return success_payload(
-        request,
-        data=_manual_run_success_payload(
-            run_summary=run_summary,
-            idempotency_key=idempotency_key,
-            safety_state=current_safety_state,
-        ),
-    )
-
-
-
-@router.get(
-    "/queue/items",
-    response_model=QueueListEnvelope,
-)
-async def list_queue_items(
-    request: Request,
-    limit: int = Query(default=200, ge=1, le=500),
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    items = await run_service.list_queue_items_for_user(
-        db_session,
-        user_id=current_user.id,
-        limit=limit,
-    )
-    return success_payload(
-        request,
-        data={
-            "queue_items": [_serialize_queue_item(item) for item in items],
-        },
-    )
-
-
-@router.post(
-    "/queue/{queue_item_id}/retry",
-    response_model=QueueItemEnvelope,
-)
-async def retry_queue_item(
-    queue_item_id: int,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    try:
-        queue_item = await run_service.retry_queue_item_for_user(
-            db_session,
-            user_id=current_user.id,
-            queue_item_id=queue_item_id,
-        )
-    except run_service.QueueTransitionError as exc:
-        raise ApiException(
-            status_code=409,
-            code=exc.code,
-            message=exc.message,
-            details={"current_status": exc.current_status},
-        ) from exc
-    if queue_item is None:
-        raise ApiException(
-            status_code=404,
-            code="queue_item_not_found",
-            message="Queue item not found.",
-        )
-    return success_payload(
-        request,
-        data=_serialize_queue_item(queue_item),
-    )
-
-
-@router.post(
-    "/queue/{queue_item_id}/drop",
-    response_model=QueueItemEnvelope,
-)
-async def drop_queue_item(
-    queue_item_id: int,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    try:
-        dropped = await run_service.drop_queue_item_for_user(
-            db_session,
-            user_id=current_user.id,
-            queue_item_id=queue_item_id,
-        )
-    except run_service.QueueTransitionError as exc:
-        raise ApiException(
-            status_code=409,
-            code=exc.code,
-            message=exc.message,
-            details={"current_status": exc.current_status},
-        ) from exc
-    if dropped is None:
-        raise ApiException(
-            status_code=404,
-            code="queue_item_not_found",
-            message="Queue item not found.",
-        )
-    return success_payload(
-        request,
-        data=_serialize_queue_item(dropped),
-    )
-
-
-@router.delete(
-    "/queue/{queue_item_id}",
-    response_model=QueueClearEnvelope,
-)
-async def clear_queue_item(
-    queue_item_id: int,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    try:
-        deleted = await run_service.clear_queue_item_for_user(
-            db_session,
-            user_id=current_user.id,
-            queue_item_id=queue_item_id,
-        )
-    except run_service.QueueTransitionError as exc:
-        raise ApiException(
-            status_code=409,
-            code=exc.code,
-            message=exc.message,
-            details={"current_status": exc.current_status},
-        ) from exc
-    if deleted is None:
-        raise ApiException(
-            status_code=404,
-            code="queue_item_not_found",
-            message="Queue item not found.",
-        )
-    return success_payload(
-        request,
-        data={
-            "queue_item_id": deleted.queue_item_id,
-            "previous_status": deleted.previous_status,
-            "status": "cleared",
-            "message": "Queue item cleared.",
-        },
-    )
-
-
-@router.get("/{run_id}/stream")
-async def stream_run_events(
-    run_id: int,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    run = await run_service.get_run_for_user(
-        db_session,
-        user_id=current_user.id,
-        run_id=run_id,
-    )
-    if run is None:
-        raise ApiException(
-            status_code=404,
-            code="run_not_found",
-            message="Run not found.",
-        )
-    return StreamingResponse(
-        event_generator(run_id),
-        media_type="text/event-stream"
-    )
diff --git a/build/lib/app/api/routers/scholars.py b/build/lib/app/api/routers/scholars.py
deleted file mode 100644
index f4be187..0000000
--- a/build/lib/app/api/routers/scholars.py
+++ /dev/null
@@ -1,557 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-
-from fastapi import APIRouter, Depends, File, Query, Request, UploadFile
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.api.deps import get_api_current_user
-from app.api.errors import ApiException
-from app.api.responses import success_payload
-from app.api.runtime_deps import get_scholar_source
-from app.api.schemas import (
-    DataExportEnvelope,
-    DataImportEnvelope,
-    DataImportRequest,
-    MessageEnvelope,
-    ScholarCreateRequest,
-    ScholarEnvelope,
-    ScholarImageUrlUpdateRequest,
-    ScholarSearchEnvelope,
-    ScholarsListEnvelope,
-)
-from app.db.models import User
-from app.db.session import get_db_session
-from app.services.domains.portability import application as import_export_service
-from app.services.domains.scholars import application as scholar_service
-from app.services.domains.scholar.source import ScholarSource
-from app.settings import settings
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/scholars", tags=["api-scholars"])
-
-
-def _uploaded_image_media_path(scholar_profile_id: int) -> str:
-    return f"/scholar-images/{scholar_profile_id}/upload"
-
-
-def _serialize_scholar(profile) -> dict[str, object]:
-    uploaded_image_url = None
-    if profile.profile_image_upload_path:
-        uploaded_image_url = _uploaded_image_media_path(int(profile.id))
-
-    profile_image_url, profile_image_source = scholar_service.resolve_profile_image(
-        profile,
-        uploaded_image_url=uploaded_image_url,
-    )
-
-    return {
-        "id": int(profile.id),
-        "scholar_id": profile.scholar_id,
-        "display_name": profile.display_name,
-        "profile_image_url": profile_image_url,
-        "profile_image_source": profile_image_source,
-        "is_enabled": bool(profile.is_enabled),
-        "baseline_completed": bool(profile.baseline_completed),
-        "last_run_dt": profile.last_run_dt,
-        "last_run_status": (
-            profile.last_run_status.value if profile.last_run_status is not None else None
-        ),
-    }
-
-
-async def _hydrate_scholar_metadata_if_needed(
-    db_session: AsyncSession,
-    *,
-    profile,
-    source: ScholarSource,
-    user_id: int,
-):
-    try:
-        if not profile.profile_image_url or not (profile.display_name or "").strip():
-            return await asyncio.wait_for(
-                scholar_service.hydrate_profile_metadata(
-                    db_session,
-                    profile=profile,
-                    source=source,
-                ),
-                timeout=5.0,
-            )
-    except Exception:
-        logger.warning(
-            "api.scholars.create_metadata_hydration_failed",
-            extra={
-                "event": "api.scholars.create_metadata_hydration_failed",
-                "user_id": user_id,
-                "scholar_profile_id": profile.id,
-            },
-        )
-    return profile
-
-
-def _search_kwargs() -> dict[str, object]:
-    return {
-        "network_error_retries": settings.ingestion_network_error_retries,
-        "retry_backoff_seconds": settings.ingestion_retry_backoff_seconds,
-        "search_enabled": settings.scholar_name_search_enabled,
-        "cache_ttl_seconds": settings.scholar_name_search_cache_ttl_seconds,
-        "blocked_cache_ttl_seconds": settings.scholar_name_search_blocked_cache_ttl_seconds,
-        "cache_max_entries": settings.scholar_name_search_cache_max_entries,
-        "min_interval_seconds": settings.scholar_name_search_min_interval_seconds,
-        "interval_jitter_seconds": settings.scholar_name_search_interval_jitter_seconds,
-        "cooldown_block_threshold": settings.scholar_name_search_cooldown_block_threshold,
-        "cooldown_seconds": settings.scholar_name_search_cooldown_seconds,
-        "retry_alert_threshold": settings.scholar_name_search_alert_retry_count_threshold,
-        "cooldown_rejection_alert_threshold": (
-            settings.scholar_name_search_alert_cooldown_rejections_threshold
-        ),
-    }
-
-
-def _search_response_data(query: str, parsed) -> dict[str, object]:
-    return {
-        "query": query.strip(),
-        "state": parsed.state.value,
-        "state_reason": parsed.state_reason,
-        "action_hint": scholar_service.scrape_state_hint(
-            state=parsed.state,
-            state_reason=parsed.state_reason,
-        ),
-        "candidates": [
-            {
-                "scholar_id": item.scholar_id,
-                "display_name": item.display_name,
-                "affiliation": item.affiliation,
-                "email_domain": item.email_domain,
-                "cited_by_count": item.cited_by_count,
-                "interests": item.interests,
-                "profile_url": item.profile_url,
-                "profile_image_url": item.profile_image_url,
-            }
-            for item in parsed.candidates
-        ],
-        "warnings": parsed.warnings,
-    }
-
-
-async def _read_uploaded_image(image: UploadFile) -> bytes:
-    try:
-        return await image.read()
-    finally:
-        await image.close()
-
-
-async def _require_user_profile(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int,
-):
-    profile = await scholar_service.get_user_scholar_by_id(
-        db_session,
-        user_id=user_id,
-        scholar_profile_id=scholar_profile_id,
-    )
-    if profile is None:
-        raise ApiException(
-            status_code=404,
-            code="scholar_not_found",
-            message="Scholar not found.",
-        )
-    return profile
-
-
-@router.get(
-    "",
-    response_model=ScholarsListEnvelope,
-)
-async def list_scholars(
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    scholars = await scholar_service.list_scholars_for_user(
-        db_session,
-        user_id=current_user.id,
-    )
-    return success_payload(
-        request,
-        data={
-            "scholars": [_serialize_scholar(profile) for profile in scholars],
-        },
-    )
-
-
-@router.get(
-    "/export",
-    response_model=DataExportEnvelope,
-)
-async def export_scholars_and_publications(
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    data = await import_export_service.export_user_data(
-        db_session,
-        user_id=current_user.id,
-    )
-    return success_payload(request, data=data)
-
-
-@router.post(
-    "/import",
-    response_model=DataImportEnvelope,
-)
-async def import_scholars_and_publications(
-    payload: DataImportRequest,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    if (
-        payload.schema_version is not None
-        and int(payload.schema_version) != import_export_service.EXPORT_SCHEMA_VERSION
-    ):
-        raise ApiException(
-            status_code=400,
-            code="invalid_import_schema_version",
-            message=(
-                "Import schema version is not supported. "
-                f"Expected {import_export_service.EXPORT_SCHEMA_VERSION}."
-            ),
-        )
-    try:
-        result = await import_export_service.import_user_data(
-            db_session,
-            user_id=current_user.id,
-            scholars=[item.model_dump() for item in payload.scholars],
-            publications=[item.model_dump() for item in payload.publications],
-        )
-    except import_export_service.ImportExportError as exc:
-        raise ApiException(
-            status_code=400,
-            code="invalid_import_payload",
-            message=str(exc),
-        ) from exc
-    logger.info(
-        "api.scholars.imported",
-        extra={
-            "event": "api.scholars.imported",
-            "user_id": current_user.id,
-            **result,
-        },
-    )
-    return success_payload(request, data=result)
-
-
-@router.post(
-    "",
-    response_model=ScholarEnvelope,
-    status_code=201,
-)
-async def create_scholar(
-    payload: ScholarCreateRequest,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    source: ScholarSource = Depends(get_scholar_source),
-    current_user: User = Depends(get_api_current_user),
-):
-    try:
-        created = await scholar_service.create_scholar_for_user(
-            db_session,
-            user_id=current_user.id,
-            scholar_id=payload.scholar_id,
-            display_name="",
-            profile_image_url=payload.profile_image_url,
-        )
-    except scholar_service.ScholarServiceError as exc:
-        raise ApiException(
-            status_code=400,
-            code="invalid_scholar",
-            message=str(exc),
-        ) from exc
-    logger.info(
-        "api.scholars.created",
-        extra={
-            "event": "api.scholars.created",
-            "user_id": current_user.id,
-            "scholar_profile_id": created.id,
-        },
-    )
-    created = await _hydrate_scholar_metadata_if_needed(
-        db_session,
-        profile=created,
-        source=source,
-        user_id=current_user.id,
-    )
-
-    return success_payload(
-        request,
-        data=_serialize_scholar(created),
-    )
-
-
-@router.get(
-    "/search",
-    response_model=ScholarSearchEnvelope,
-)
-async def search_scholars(
-    request: Request,
-    query: str = Query(..., min_length=2, max_length=120),
-    limit: int = Query(10, ge=1, le=25),
-    db_session: AsyncSession = Depends(get_db_session),
-    source: ScholarSource = Depends(get_scholar_source),
-    current_user: User = Depends(get_api_current_user),
-):
-    try:
-        parsed = await scholar_service.search_author_candidates(
-            source=source,
-            db_session=db_session,
-            query=query,
-            limit=limit,
-            **_search_kwargs(),
-        )
-    except scholar_service.ScholarServiceError as exc:
-        raise ApiException(
-            status_code=400,
-            code="invalid_scholar_search",
-            message=str(exc),
-        ) from exc
-
-    logger.info(
-        "api.scholars.search.completed",
-        extra={
-            "event": "api.scholars.search.completed",
-            "user_id": current_user.id,
-            "query": query.strip(),
-            "candidate_count": len(parsed.candidates),
-            "state": parsed.state.value,
-        },
-    )
-    return success_payload(
-        request,
-        data=_search_response_data(query, parsed),
-    )
-
-
-@router.patch(
-    "/{scholar_profile_id}/toggle",
-    response_model=ScholarEnvelope,
-)
-async def toggle_scholar(
-    scholar_profile_id: int,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    profile = await scholar_service.get_user_scholar_by_id(
-        db_session,
-        user_id=current_user.id,
-        scholar_profile_id=scholar_profile_id,
-    )
-    if profile is None:
-        raise ApiException(
-            status_code=404,
-            code="scholar_not_found",
-            message="Scholar not found.",
-        )
-    updated = await scholar_service.toggle_scholar_enabled(db_session, profile=profile)
-    logger.info(
-        "api.scholars.toggled",
-        extra={
-            "event": "api.scholars.toggled",
-            "user_id": current_user.id,
-            "scholar_profile_id": updated.id,
-            "is_enabled": updated.is_enabled,
-        },
-    )
-    return success_payload(
-        request,
-        data=_serialize_scholar(updated),
-    )
-
-
-@router.delete(
-    "/{scholar_profile_id}",
-    response_model=MessageEnvelope,
-)
-async def delete_scholar(
-    scholar_profile_id: int,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    profile = await scholar_service.get_user_scholar_by_id(
-        db_session,
-        user_id=current_user.id,
-        scholar_profile_id=scholar_profile_id,
-    )
-    if profile is None:
-        raise ApiException(
-            status_code=404,
-            code="scholar_not_found",
-            message="Scholar not found.",
-        )
-    await scholar_service.delete_scholar(
-        db_session,
-        profile=profile,
-        upload_dir=settings.scholar_image_upload_dir,
-    )
-    logger.info(
-        "api.scholars.deleted",
-        extra={
-            "event": "api.scholars.deleted",
-            "user_id": current_user.id,
-            "scholar_profile_id": scholar_profile_id,
-        },
-    )
-    return success_payload(
-        request,
-        data={"message": "Scholar deleted."},
-    )
-
-
-@router.put(
-    "/{scholar_profile_id}/image/url",
-    response_model=ScholarEnvelope,
-)
-async def update_scholar_image_url(
-    scholar_profile_id: int,
-    payload: ScholarImageUrlUpdateRequest,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    profile = await scholar_service.get_user_scholar_by_id(
-        db_session,
-        user_id=current_user.id,
-        scholar_profile_id=scholar_profile_id,
-    )
-    if profile is None:
-        raise ApiException(
-            status_code=404,
-            code="scholar_not_found",
-            message="Scholar not found.",
-        )
-
-    try:
-        updated = await scholar_service.set_profile_image_override_url(
-            db_session,
-            profile=profile,
-            image_url=payload.image_url,
-            upload_dir=settings.scholar_image_upload_dir,
-        )
-    except scholar_service.ScholarServiceError as exc:
-        raise ApiException(
-            status_code=400,
-            code="invalid_scholar_image",
-            message=str(exc),
-        ) from exc
-
-    logger.info(
-        "api.scholars.image_url_updated",
-        extra={
-            "event": "api.scholars.image_url_updated",
-            "user_id": current_user.id,
-            "scholar_profile_id": updated.id,
-        },
-    )
-    return success_payload(
-        request,
-        data=_serialize_scholar(updated),
-    )
-
-
-@router.post(
-    "/{scholar_profile_id}/image/upload",
-    response_model=ScholarEnvelope,
-)
-async def upload_scholar_image(
-    scholar_profile_id: int,
-    request: Request,
-    image: UploadFile = File(...),
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    profile = await _require_user_profile(
-        db_session,
-        user_id=current_user.id,
-        scholar_profile_id=scholar_profile_id,
-    )
-
-    image_bytes = await _read_uploaded_image(image)
-    try:
-        updated = await scholar_service.set_profile_image_upload(
-            db_session,
-            profile=profile,
-            content_type=image.content_type,
-            image_bytes=image_bytes,
-            upload_dir=settings.scholar_image_upload_dir,
-            max_upload_bytes=settings.scholar_image_upload_max_bytes,
-        )
-    except scholar_service.ScholarServiceError as exc:
-        raise ApiException(
-            status_code=400,
-            code="invalid_scholar_image",
-            message=str(exc),
-        ) from exc
-
-    image_size = len(image_bytes)
-    logger.info(
-        "api.scholars.image_uploaded",
-        extra={
-            "event": "api.scholars.image_uploaded",
-            "user_id": current_user.id,
-            "scholar_profile_id": updated.id,
-            "content_type": image.content_type,
-            "size_bytes": image_size,
-        },
-    )
-    return success_payload(
-        request,
-        data=_serialize_scholar(updated),
-    )
-
-
-@router.delete(
-    "/{scholar_profile_id}/image",
-    response_model=ScholarEnvelope,
-)
-async def clear_scholar_image_customization(
-    scholar_profile_id: int,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    profile = await scholar_service.get_user_scholar_by_id(
-        db_session,
-        user_id=current_user.id,
-        scholar_profile_id=scholar_profile_id,
-    )
-    if profile is None:
-        raise ApiException(
-            status_code=404,
-            code="scholar_not_found",
-            message="Scholar not found.",
-        )
-
-    updated = await scholar_service.clear_profile_image_customization(
-        db_session,
-        profile=profile,
-        upload_dir=settings.scholar_image_upload_dir,
-    )
-    logger.info(
-        "api.scholars.image_customization_cleared",
-        extra={
-            "event": "api.scholars.image_customization_cleared",
-            "user_id": current_user.id,
-            "scholar_profile_id": updated.id,
-        },
-    )
-    return success_payload(
-        request,
-        data=_serialize_scholar(updated),
-    )
-
diff --git a/build/lib/app/api/routers/settings.py b/build/lib/app/api/routers/settings.py
deleted file mode 100644
index 5a2ef91..0000000
--- a/build/lib/app/api/routers/settings.py
+++ /dev/null
@@ -1,189 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-from fastapi import APIRouter, Depends, Request
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.api.deps import get_api_current_user
-from app.api.errors import ApiException
-from app.api.responses import success_payload
-from app.api.schemas import SettingsEnvelope, SettingsUpdateRequest
-from app.db.models import User
-from app.db.session import get_db_session
-from app.services.domains.ingestion import safety as run_safety_service
-from app.services.domains.settings import application as user_settings_service
-from app.settings import settings as settings_module
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/settings", tags=["api-settings"])
-
-
-def _serialize_settings(user_settings) -> dict[str, object]:
-    min_run_interval_minutes, min_request_delay_seconds = _minimum_policy()
-    return {
-        "auto_run_enabled": bool(user_settings.auto_run_enabled) and settings_module.ingestion_automation_allowed,
-        "run_interval_minutes": int(user_settings.run_interval_minutes),
-        "request_delay_seconds": int(user_settings.request_delay_seconds),
-        "nav_visible_pages": list(user_settings.nav_visible_pages or []),
-        "policy": {
-            "min_run_interval_minutes": min_run_interval_minutes,
-            "min_request_delay_seconds": min_request_delay_seconds,
-            "automation_allowed": bool(settings_module.ingestion_automation_allowed),
-            "manual_run_allowed": bool(settings_module.ingestion_manual_run_allowed),
-            "blocked_failure_threshold": max(1, int(settings_module.ingestion_alert_blocked_failure_threshold)),
-            "network_failure_threshold": max(1, int(settings_module.ingestion_alert_network_failure_threshold)),
-            "cooldown_blocked_seconds": max(60, int(settings_module.ingestion_safety_cooldown_blocked_seconds)),
-            "cooldown_network_seconds": max(60, int(settings_module.ingestion_safety_cooldown_network_seconds)),
-        },
-        "safety_state": run_safety_service.get_safety_state_payload(user_settings),
-        "openalex_api_key": user_settings.openalex_api_key,
-        "crossref_api_token": user_settings.crossref_api_token,
-        "crossref_api_mailto": user_settings.crossref_api_mailto,
-    }
-
-
-def _minimum_policy() -> tuple[int, int]:
-    min_run_interval_minutes = user_settings_service.resolve_run_interval_minimum(
-        settings_module.ingestion_min_run_interval_minutes
-    )
-    min_request_delay_seconds = user_settings_service.resolve_request_delay_minimum(
-        settings_module.ingestion_min_request_delay_seconds
-    )
-    return min_run_interval_minutes, min_request_delay_seconds
-
-
-def _parse_settings_payload(payload: SettingsUpdateRequest, user_settings) -> tuple[int, int, list[str]]:
-    min_run_interval_minutes, min_request_delay_seconds = _minimum_policy()
-    parsed_interval = user_settings_service.parse_run_interval_minutes(
-        str(payload.run_interval_minutes),
-        minimum=min_run_interval_minutes,
-    )
-    parsed_delay = user_settings_service.parse_request_delay_seconds(
-        str(payload.request_delay_seconds),
-        minimum=min_request_delay_seconds,
-    )
-    parsed_nav_visible_pages = user_settings_service.parse_nav_visible_pages(
-        payload.nav_visible_pages
-        if payload.nav_visible_pages is not None
-        else list(user_settings.nav_visible_pages or user_settings_service.DEFAULT_NAV_VISIBLE_PAGES)
-    )
-    return parsed_interval, parsed_delay, parsed_nav_visible_pages
-
-
-async def _clear_expired_cooldown_with_log(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    user_settings,
-) -> None:
-    previous_safety_state = run_safety_service.get_safety_event_context(user_settings)
-    if not run_safety_service.clear_expired_cooldown(user_settings):
-        return
-    await db_session.commit()
-    await db_session.refresh(user_settings)
-    logger.info(
-        "api.settings.safety_cooldown_cleared",
-        extra={
-            "event": "api.settings.safety_cooldown_cleared",
-            "user_id": user_id,
-            "reason": previous_safety_state.get("cooldown_reason"),
-            "cooldown_until": previous_safety_state.get("cooldown_until"),
-            "metric_name": "api_settings_safety_cooldown_cleared_total",
-            "metric_value": 1,
-        },
-    )
-
-
-def _effective_auto_run_enabled(payload: SettingsUpdateRequest) -> bool:
-    return bool(payload.auto_run_enabled) and settings_module.ingestion_automation_allowed
-
-
-def _log_settings_update(*, user_id: int, updated) -> None:
-    logger.info(
-        "api.settings.updated",
-        extra={
-            "event": "api.settings.updated",
-            "user_id": user_id,
-            "auto_run_enabled": updated.auto_run_enabled,
-            "run_interval_minutes": updated.run_interval_minutes,
-            "request_delay_seconds": updated.request_delay_seconds,
-            "nav_visible_pages": updated.nav_visible_pages,
-            "openalex_api_key": "SET" if updated.openalex_api_key else "UNSET",
-        },
-    )
-
-
-@router.get(
-    "",
-    response_model=SettingsEnvelope,
-)
-async def get_settings(
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    user_settings = await user_settings_service.get_or_create_settings(
-        db_session,
-        user_id=current_user.id,
-    )
-    await _clear_expired_cooldown_with_log(
-        db_session,
-        user_id=current_user.id,
-        user_settings=user_settings,
-    )
-    return success_payload(
-        request,
-        data=_serialize_settings(user_settings),
-    )
-
-
-@router.put(
-    "",
-    response_model=SettingsEnvelope,
-)
-async def update_settings(
-    payload: SettingsUpdateRequest,
-    request: Request,
-    db_session: AsyncSession = Depends(get_db_session),
-    current_user: User = Depends(get_api_current_user),
-):
-    user_settings = await user_settings_service.get_or_create_settings(
-        db_session,
-        user_id=current_user.id,
-    )
-
-    try:
-        parsed_interval, parsed_delay, parsed_nav_visible_pages = _parse_settings_payload(
-            payload,
-            user_settings,
-        )
-    except user_settings_service.UserSettingsServiceError as exc:
-        raise ApiException(
-            status_code=400,
-            code="invalid_settings",
-            message=str(exc),
-        ) from exc
-
-    updated = await user_settings_service.update_settings(
-        db_session,
-        settings=user_settings,
-        auto_run_enabled=_effective_auto_run_enabled(payload),
-        run_interval_minutes=parsed_interval,
-        request_delay_seconds=parsed_delay,
-        nav_visible_pages=parsed_nav_visible_pages,
-        openalex_api_key=payload.openalex_api_key,
-        crossref_api_token=payload.crossref_api_token,
-        crossref_api_mailto=payload.crossref_api_mailto,
-    )
-    await _clear_expired_cooldown_with_log(
-        db_session,
-        user_id=current_user.id,
-        user_settings=updated,
-    )
-    _log_settings_update(user_id=current_user.id, updated=updated)
-    return success_payload(
-        request,
-        data=_serialize_settings(updated),
-    )
diff --git a/build/lib/app/api/runtime_deps.py b/build/lib/app/api/runtime_deps.py
deleted file mode 100644
index 3a692a3..0000000
--- a/build/lib/app/api/runtime_deps.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from __future__ import annotations
-
-from fastapi import Depends
-
-from app.services.domains.ingestion import application as ingestion_service
-from app.services.domains.scholar import source as scholar_source_service
-
-
-def get_scholar_source() -> scholar_source_service.ScholarSource:
-    return scholar_source_service.LiveScholarSource()
-
-
-def get_ingestion_service(
-    source: scholar_source_service.ScholarSource = Depends(get_scholar_source),
-) -> ingestion_service.ScholarIngestionService:
-    return ingestion_service.ScholarIngestionService(source=source)
diff --git a/build/lib/app/api/schemas.py b/build/lib/app/api/schemas.py
deleted file mode 100644
index bac3bb9..0000000
--- a/build/lib/app/api/schemas.py
+++ /dev/null
@@ -1,884 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-from typing import Any, Literal
-
-from pydantic import BaseModel, ConfigDict, Field, model_validator
-
-
-class ApiMeta(BaseModel):
-    request_id: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ApiErrorData(BaseModel):
-    code: str
-    message: str
-    details: Any | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ApiErrorEnvelope(BaseModel):
-    error: ApiErrorData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MessageData(BaseModel):
-    message: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MessageEnvelope(BaseModel):
-    data: MessageData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class SessionUserData(BaseModel):
-    id: int
-    email: str
-    is_admin: bool
-    is_active: bool
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AuthMeData(BaseModel):
-    authenticated: bool
-    csrf_token: str
-    user: SessionUserData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AuthMeEnvelope(BaseModel):
-    data: AuthMeData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class CsrfBootstrapData(BaseModel):
-    csrf_token: str
-    authenticated: bool
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class CsrfBootstrapEnvelope(BaseModel):
-    data: CsrfBootstrapData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class LoginRequest(BaseModel):
-    email: str
-    password: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class LoginData(BaseModel):
-    authenticated: bool
-    csrf_token: str
-    user: SessionUserData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class LoginEnvelope(BaseModel):
-    data: LoginData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ChangePasswordRequest(BaseModel):
-    current_password: str
-    new_password: str
-    confirm_password: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarItemData(BaseModel):
-    id: int
-    scholar_id: str
-    display_name: str | None
-    profile_image_url: str | None
-    profile_image_source: str
-    is_enabled: bool
-    baseline_completed: bool
-    last_run_dt: datetime | None
-    last_run_status: str | None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarsListData(BaseModel):
-    scholars: list[ScholarItemData]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarsListEnvelope(BaseModel):
-    data: ScholarsListData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarCreateRequest(BaseModel):
-    scholar_id: str
-    profile_image_url: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarEnvelope(BaseModel):
-    data: ScholarItemData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarSearchCandidateData(BaseModel):
-    scholar_id: str
-    display_name: str
-    affiliation: str | None
-    email_domain: str | None
-    cited_by_count: int | None
-    interests: list[str] = Field(default_factory=list)
-    profile_url: str
-    profile_image_url: str | None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarSearchData(BaseModel):
-    query: str
-    state: str
-    state_reason: str
-    action_hint: str | None = None
-    candidates: list[ScholarSearchCandidateData]
-    warnings: list[str] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarSearchEnvelope(BaseModel):
-    data: ScholarSearchData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarImageUrlUpdateRequest(BaseModel):
-    image_url: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarExportItemData(BaseModel):
-    scholar_id: str
-    display_name: str | None = None
-    is_enabled: bool = True
-    profile_image_override_url: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class PublicationExportItemData(BaseModel):
-    scholar_id: str
-    cluster_id: str | None = None
-    fingerprint_sha256: str | None = None
-    title: str
-    year: int | None = None
-    citation_count: int = 0
-    author_text: str | None = None
-    venue_text: str | None = None
-    pub_url: str | None = None
-    pdf_url: str | None = None
-    is_read: bool = False
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DataExportData(BaseModel):
-    schema_version: int
-    exported_at: str
-    scholars: list[ScholarExportItemData]
-    publications: list[PublicationExportItemData]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DataExportEnvelope(BaseModel):
-    data: DataExportData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DataImportRequest(BaseModel):
-    schema_version: int | None = None
-    scholars: list[ScholarExportItemData] = Field(default_factory=list)
-    publications: list[PublicationExportItemData] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DataImportResultData(BaseModel):
-    scholars_created: int
-    scholars_updated: int
-    publications_created: int
-    publications_updated: int
-    links_created: int
-    links_updated: int
-    skipped_records: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DataImportEnvelope(BaseModel):
-    data: DataImportResultData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunListItemData(BaseModel):
-    id: int
-    trigger_type: str
-    status: str
-    start_dt: datetime
-    end_dt: datetime | None
-    scholar_count: int
-    new_publication_count: int
-    failed_count: int
-    partial_count: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunsListData(BaseModel):
-    runs: list[RunListItemData]
-    safety_state: ScrapeSafetyStateData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunsListEnvelope(BaseModel):
-    data: RunsListData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunSummaryData(BaseModel):
-    succeeded_count: int
-    failed_count: int
-    partial_count: int
-    failed_state_counts: dict[str, int] = Field(default_factory=dict)
-    failed_reason_counts: dict[str, int] = Field(default_factory=dict)
-    scrape_failure_counts: dict[str, int] = Field(default_factory=dict)
-    retry_counts: dict[str, int] = Field(default_factory=dict)
-    alert_thresholds: dict[str, int] = Field(default_factory=dict)
-    alert_flags: dict[str, bool] = Field(default_factory=dict)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScrapeSafetyCountersData(BaseModel):
-    consecutive_blocked_runs: int = 0
-    consecutive_network_runs: int = 0
-    cooldown_entry_count: int = 0
-    blocked_start_count: int = 0
-    last_blocked_failure_count: int = 0
-    last_network_failure_count: int = 0
-    last_evaluated_run_id: int | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScrapeSafetyStateData(BaseModel):
-    cooldown_active: bool
-    cooldown_reason: str | None = None
-    cooldown_reason_label: str | None = None
-    cooldown_until: datetime | None = None
-    cooldown_remaining_seconds: int = 0
-    recommended_action: str | None = None
-    counters: ScrapeSafetyCountersData = Field(default_factory=ScrapeSafetyCountersData)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunAttemptLogData(BaseModel):
-    attempt: int
-    cstart: int
-    state: str | None = None
-    state_reason: str | None = None
-    status_code: int | None = None
-    fetch_error: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunPageLogData(BaseModel):
-    page: int
-    cstart: int
-    state: str
-    state_reason: str | None = None
-    status_code: int | None = None
-    publication_count: int = 0
-    attempt_count: int = 0
-    has_show_more_button: bool = False
-    articles_range: str | None = None
-    warning_codes: list[str] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunDebugData(BaseModel):
-    status_code: int | None = None
-    final_url: str | None = None
-    fetch_error: str | None = None
-    body_sha256: str | None = None
-    body_length: int | None = None
-    has_show_more_button: bool | None = None
-    articles_range: str | None = None
-    state_reason: str | None = None
-    warning_codes: list[str] = Field(default_factory=list)
-    marker_counts_nonzero: dict[str, int] = Field(default_factory=dict)
-    page_logs: list[RunPageLogData] = Field(default_factory=list)
-    attempt_log: list[RunAttemptLogData] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunScholarResultData(BaseModel):
-    scholar_profile_id: int
-    scholar_id: str
-    state: str
-    state_reason: str | None = None
-    outcome: str
-    attempt_count: int = 0
-    publication_count: int = 0
-    start_cstart: int = 0
-    continuation_cstart: int | None = None
-    continuation_enqueued: bool = False
-    continuation_cleared: bool = False
-    warnings: list[str] = Field(default_factory=list)
-    error: str | None = None
-    debug: RunDebugData | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunDetailData(BaseModel):
-    run: RunListItemData
-    summary: RunSummaryData
-    scholar_results: list[RunScholarResultData]
-    safety_state: ScrapeSafetyStateData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunDetailEnvelope(BaseModel):
-    data: RunDetailData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ManualRunData(BaseModel):
-    run_id: int
-    status: str
-    scholar_count: int
-    succeeded_count: int
-    failed_count: int
-    partial_count: int
-    new_publication_count: int
-    reused_existing_run: bool
-    idempotency_key: str | None = None
-    safety_state: ScrapeSafetyStateData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ManualRunEnvelope(BaseModel):
-    data: ManualRunData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueItemData(BaseModel):
-    id: int
-    scholar_profile_id: int
-    scholar_label: str
-    status: str
-    reason: str
-    dropped_reason: str | None
-    attempt_count: int
-    resume_cstart: int
-    next_attempt_dt: datetime | None
-    updated_at: datetime
-    last_error: str | None
-    last_run_id: int | None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueListData(BaseModel):
-    queue_items: list[QueueItemData]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueListEnvelope(BaseModel):
-    data: QueueListData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueItemEnvelope(BaseModel):
-    data: QueueItemData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueClearData(BaseModel):
-    queue_item_id: int
-    previous_status: str
-    status: str
-    message: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueClearEnvelope(BaseModel):
-    data: QueueClearData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUserData(BaseModel):
-    id: int
-    email: str
-    is_active: bool
-    is_admin: bool
-    created_at: datetime
-    updated_at: datetime
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUsersListData(BaseModel):
-    users: list[AdminUserData]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUsersListEnvelope(BaseModel):
-    data: AdminUsersListData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUserCreateRequest(BaseModel):
-    email: str
-    password: str
-    is_admin: bool = False
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUserActiveUpdateRequest(BaseModel):
-    is_active: bool
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUserEnvelope(BaseModel):
-    data: AdminUserData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminResetPasswordRequest(BaseModel):
-    new_password: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbIntegrityCheckData(BaseModel):
-    name: str
-    count: int
-    severity: str
-    message: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbIntegrityData(BaseModel):
-    status: str
-    checked_at: datetime
-    failures: list[str] = Field(default_factory=list)
-    warnings: list[str] = Field(default_factory=list)
-    checks: list[AdminDbIntegrityCheckData] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbIntegrityEnvelope(BaseModel):
-    data: AdminDbIntegrityData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbRepairJobData(BaseModel):
-    id: int
-    job_name: str
-    requested_by: str | None
-    dry_run: bool
-    status: str
-    scope: dict[str, Any] = Field(default_factory=dict)
-    summary: dict[str, Any] = Field(default_factory=dict)
-    error_text: str | None
-    started_at: datetime | None
-    finished_at: datetime | None
-    created_at: datetime
-    updated_at: datetime
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbRepairJobsData(BaseModel):
-    jobs: list[AdminDbRepairJobData] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbRepairJobsEnvelope(BaseModel):
-    data: AdminDbRepairJobsData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DisplayIdentifierData(BaseModel):
-    kind: str
-    value: str
-    label: str
-    url: str | None
-    confidence_score: float = Field(ge=0.0, le=1.0)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueItemData(BaseModel):
-    publication_id: int
-    title: str
-    display_identifier: DisplayIdentifierData | None = None
-    pdf_url: str | None
-    status: str
-    attempt_count: int
-    last_failure_reason: str | None
-    last_failure_detail: str | None
-    last_source: str | None
-    requested_by_user_id: int | None
-    requested_by_email: str | None
-    queued_at: datetime | None
-    last_attempt_at: datetime | None
-    resolved_at: datetime | None
-    updated_at: datetime
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueData(BaseModel):
-    items: list[AdminPdfQueueItemData] = Field(default_factory=list)
-    total_count: int = 0
-    page: int = 1
-    page_size: int = 100
-    has_next: bool = False
-    has_prev: bool = False
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueEnvelope(BaseModel):
-    data: AdminPdfQueueData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueRequeueData(BaseModel):
-    publication_id: int
-    queued: bool
-    status: str
-    message: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueRequeueEnvelope(BaseModel):
-    data: AdminPdfQueueRequeueData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueBulkEnqueueData(BaseModel):
-    requested_count: int
-    queued_count: int
-    message: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueBulkEnqueueEnvelope(BaseModel):
-    data: AdminPdfQueueBulkEnqueueData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminRepairPublicationLinksRequest(BaseModel):
-    scope_mode: Literal["single_user", "all_users"] = "single_user"
-    user_id: int | None = Field(default=None, ge=1)
-    scholar_profile_ids: list[int] = Field(default_factory=list, max_length=200)
-    dry_run: bool = True
-    gc_orphan_publications: bool = False
-    requested_by: str | None = None
-    confirmation_text: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-    @model_validator(mode="after")
-    def validate_scope(self) -> "AdminRepairPublicationLinksRequest":
-        if self.scope_mode == "single_user" and self.user_id is None:
-            raise ValueError("user_id is required when scope_mode=single_user.")
-        if self.scope_mode == "all_users" and self.user_id is not None:
-            raise ValueError("user_id must be omitted when scope_mode=all_users.")
-        if not self.dry_run and self.scope_mode == "all_users":
-            expected = "REPAIR ALL USERS"
-            provided = (self.confirmation_text or "").strip()
-            if provided != expected:
-                raise ValueError(
-                    "confirmation_text must equal 'REPAIR ALL USERS' "
-                    "when applying a repair to all users."
-                )
-        return self
-
-
-class AdminRepairPublicationLinksResultData(BaseModel):
-    job_id: int
-    status: str
-    scope: dict[str, Any] = Field(default_factory=dict)
-    summary: dict[str, Any] = Field(default_factory=dict)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminRepairPublicationLinksEnvelope(BaseModel):
-    data: AdminRepairPublicationLinksResultData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class SettingsPolicyData(BaseModel):
-    min_run_interval_minutes: int
-    min_request_delay_seconds: int
-    automation_allowed: bool
-    manual_run_allowed: bool
-    blocked_failure_threshold: int
-    network_failure_threshold: int
-    cooldown_blocked_seconds: int
-    cooldown_network_seconds: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class SettingsData(BaseModel):
-    auto_run_enabled: bool
-    run_interval_minutes: int
-    request_delay_seconds: int
-    nav_visible_pages: list[str]
-    policy: SettingsPolicyData
-    safety_state: ScrapeSafetyStateData
-    
-    openalex_api_key: str | None = None
-    crossref_api_token: str | None = None
-    crossref_api_mailto: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class SettingsEnvelope(BaseModel):
-    data: SettingsData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class SettingsUpdateRequest(BaseModel):
-    auto_run_enabled: bool
-    run_interval_minutes: int
-    request_delay_seconds: int
-    nav_visible_pages: list[str] | None = None
-
-    openalex_api_key: str | None = None
-    crossref_api_token: str | None = None
-    crossref_api_mailto: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class PublicationItemData(BaseModel):
-    publication_id: int
-    scholar_profile_id: int
-    scholar_label: str
-    title: str
-    year: int | None
-    citation_count: int
-    venue_text: str | None
-    pub_url: str | None
-    display_identifier: DisplayIdentifierData | None = None
-    pdf_url: str | None
-    pdf_status: str = "untracked"
-    pdf_attempt_count: int = 0
-    pdf_failure_reason: str | None = None
-    pdf_failure_detail: str | None = None
-    is_read: bool
-    is_favorite: bool = False
-    first_seen_at: datetime
-    is_new_in_latest_run: bool
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class PublicationsListData(BaseModel):
-    mode: str
-    favorite_only: bool = False
-    selected_scholar_profile_id: int | None
-    unread_count: int
-    favorites_count: int
-    latest_count: int
-    new_count: int
-    total_count: int
-    page: int
-    page_size: int
-    has_next: bool = False
-    has_prev: bool = False
-    publications: list[PublicationItemData]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class PublicationsListEnvelope(BaseModel):
-    data: PublicationsListData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MarkAllReadData(BaseModel):
-    message: str
-    updated_count: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MarkAllReadEnvelope(BaseModel):
-    data: MarkAllReadData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class PublicationSelectionItem(BaseModel):
-    scholar_profile_id: int
-    publication_id: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MarkSelectedReadRequest(BaseModel):
-    selections: list[PublicationSelectionItem] = Field(min_length=1, max_length=500)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MarkSelectedReadData(BaseModel):
-    message: str
-    requested_count: int
-    updated_count: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MarkSelectedReadEnvelope(BaseModel):
-    data: MarkSelectedReadData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RetryPublicationPdfRequest(BaseModel):
-    scholar_profile_id: int = Field(ge=1)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RetryPublicationPdfData(BaseModel):
-    message: str
-    queued: bool
-    resolved_pdf: bool
-    publication: PublicationItemData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RetryPublicationPdfEnvelope(BaseModel):
-    data: RetryPublicationPdfData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class TogglePublicationFavoriteRequest(BaseModel):
-    scholar_profile_id: int = Field(ge=1)
-    is_favorite: bool
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class TogglePublicationFavoriteData(BaseModel):
-    message: str
-    publication: PublicationItemData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class TogglePublicationFavoriteEnvelope(BaseModel):
-    data: TogglePublicationFavoriteData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
diff --git a/build/lib/app/auth/__init__.py b/build/lib/app/auth/__init__.py
deleted file mode 100644
index 79644a4..0000000
--- a/build/lib/app/auth/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-"""Authentication package for scholarr."""
-
diff --git a/build/lib/app/auth/deps.py b/build/lib/app/auth/deps.py
deleted file mode 100644
index 50424ae..0000000
--- a/build/lib/app/auth/deps.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from functools import lru_cache
-
-from app.auth.rate_limit import SlidingWindowRateLimiter
-from app.auth.security import PasswordService
-from app.auth.service import AuthService
-from app.settings import settings
-
-
-@lru_cache
-def get_password_service() -> PasswordService:
-    return PasswordService()
-
-
-@lru_cache
-def get_auth_service() -> AuthService:
-    return AuthService(password_service=get_password_service())
-
-
-@lru_cache
-def get_login_rate_limiter() -> SlidingWindowRateLimiter:
-    return SlidingWindowRateLimiter(
-        max_attempts=settings.login_rate_limit_attempts,
-        window_seconds=settings.login_rate_limit_window_seconds,
-    )
-
diff --git a/build/lib/app/auth/rate_limit.py b/build/lib/app/auth/rate_limit.py
deleted file mode 100644
index c3f5e8a..0000000
--- a/build/lib/app/auth/rate_limit.py
+++ /dev/null
@@ -1,69 +0,0 @@
-from __future__ import annotations
-
-from collections import deque
-from collections.abc import Callable
-from dataclasses import dataclass
-from math import ceil
-from threading import Lock
-from time import monotonic
-
-
-@dataclass(frozen=True)
-class RateLimitDecision:
-    allowed: bool
-    retry_after_seconds: int = 0
-
-
-class SlidingWindowRateLimiter:
-    def __init__(
-        self,
-        *,
-        max_attempts: int,
-        window_seconds: int,
-        now: Callable[[], float] = monotonic,
-    ) -> None:
-        self._max_attempts = max_attempts
-        self._window_seconds = window_seconds
-        self._now = now
-        self._attempts: dict[str, deque[float]] = {}
-        self._lock = Lock()
-
-    def check(self, key: str) -> RateLimitDecision:
-        with self._lock:
-            now_value = self._now()
-            attempts = self._attempts.get(key)
-            if attempts is None:
-                return RateLimitDecision(allowed=True)
-            self._trim_expired(attempts, now_value)
-            if not attempts:
-                self._attempts.pop(key, None)
-                return RateLimitDecision(allowed=True)
-            if len(attempts) >= self._max_attempts:
-                retry_after = self._window_seconds - (now_value - attempts[0])
-                return RateLimitDecision(
-                    allowed=False,
-                    retry_after_seconds=max(1, ceil(retry_after)),
-                )
-            return RateLimitDecision(allowed=True)
-
-    def record_failure(self, key: str) -> None:
-        with self._lock:
-            now_value = self._now()
-            attempts = self._attempts.get(key)
-            if attempts is None:
-                attempts = deque()
-                self._attempts[key] = attempts
-            self._trim_expired(attempts, now_value)
-            attempts.append(now_value)
-
-    def reset(self, key: str) -> None:
-        with self._lock:
-            self._attempts.pop(key, None)
-
-    def clear_all(self) -> None:
-        with self._lock:
-            self._attempts.clear()
-
-    def _trim_expired(self, attempts: deque[float], now_value: float) -> None:
-        while attempts and now_value - attempts[0] >= self._window_seconds:
-            attempts.popleft()
diff --git a/build/lib/app/auth/runtime.py b/build/lib/app/auth/runtime.py
deleted file mode 100644
index 777e799..0000000
--- a/build/lib/app/auth/runtime.py
+++ /dev/null
@@ -1,55 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-from fastapi import Request
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.auth.session import clear_session_user, get_session_user, set_session_user
-from app.db.models import User
-from app.security.csrf import CSRF_SESSION_KEY
-from app.services.domains.users import application as user_service
-
-logger = logging.getLogger(__name__)
-
-
-def invalidate_session(request: Request) -> None:
-    clear_session_user(request)
-    request.session.pop(CSRF_SESSION_KEY, None)
-
-
-async def get_authenticated_user(
-    request: Request,
-    db_session: AsyncSession,
-) -> User | None:
-    session_user = get_session_user(request)
-    if session_user is None:
-        return None
-
-    user = await user_service.get_user_by_id(db_session, session_user.id)
-    if user is None or not user.is_active:
-        logger.info(
-            "auth.session_invalidated",
-            extra={
-                "event": "auth.session_invalidated",
-                "session_user_id": session_user.id,
-            },
-        )
-        invalidate_session(request)
-        return None
-
-    if user.email != session_user.email or user.is_admin != session_user.is_admin:
-        set_session_user(
-            request,
-            user_id=user.id,
-            email=user.email,
-            is_admin=user.is_admin,
-        )
-
-    return user
-
-
-def login_rate_limit_key(request: Request, email: str) -> str:
-    client_host = request.client.host if request.client is not None else "unknown"
-    normalized_email = email.strip().lower()
-    return f"{client_host}:{normalized_email or '<empty>'}"
diff --git a/build/lib/app/auth/security.py b/build/lib/app/auth/security.py
deleted file mode 100644
index f89b122..0000000
--- a/build/lib/app/auth/security.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from __future__ import annotations
-
-from argon2 import PasswordHasher
-from argon2.exceptions import InvalidHashError, VerificationError
-
-
-class PasswordService:
-    def __init__(self, hasher: PasswordHasher | None = None) -> None:
-        self._hasher = hasher or PasswordHasher()
-
-    def hash_password(self, password: str) -> str:
-        return self._hasher.hash(password)
-
-    def verify_password(self, password_hash: str, password: str) -> bool:
-        try:
-            return bool(self._hasher.verify(password_hash, password))
-        except (InvalidHashError, VerificationError):
-            return False
-
diff --git a/build/lib/app/auth/service.py b/build/lib/app/auth/service.py
deleted file mode 100644
index 9772358..0000000
--- a/build/lib/app/auth/service.py
+++ /dev/null
@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.auth.security import PasswordService
-from app.db.models import User
-
-
-class AuthService:
-    def __init__(self, password_service: PasswordService) -> None:
-        self._password_service = password_service
-
-    async def authenticate_user(
-        self,
-        db_session: AsyncSession,
-        *,
-        email: str,
-        password: str,
-    ) -> User | None:
-        normalized_email = email.strip().lower()
-        if not normalized_email or not password:
-            return None
-        result = await db_session.execute(
-            select(User).where(User.email == normalized_email)
-        )
-        user = result.scalar_one_or_none()
-        if user is None or not user.is_active:
-            return None
-        if not self._password_service.verify_password(user.password_hash, password):
-            return None
-        return user
-
-    def hash_password(self, password: str) -> str:
-        return self._password_service.hash_password(password)
-
-    def verify_password(self, *, password_hash: str, password: str) -> bool:
-        return self._password_service.verify_password(password_hash, password)
diff --git a/build/lib/app/auth/session.py b/build/lib/app/auth/session.py
deleted file mode 100644
index 8c83197..0000000
--- a/build/lib/app/auth/session.py
+++ /dev/null
@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from starlette.requests import Request
-
-
-SESSION_USER_ID_KEY = "auth_user_id"
-SESSION_USER_EMAIL_KEY = "auth_user_email"
-SESSION_USER_IS_ADMIN_KEY = "auth_user_is_admin"
-
-
-@dataclass(frozen=True)
-class SessionUser:
-    id: int
-    email: str
-    is_admin: bool
-
-
-def get_session_user(request: Request) -> SessionUser | None:
-    user_id = request.session.get(SESSION_USER_ID_KEY)
-    email = request.session.get(SESSION_USER_EMAIL_KEY)
-    is_admin = request.session.get(SESSION_USER_IS_ADMIN_KEY)
-    if user_id is None or email is None or is_admin is None:
-        return None
-    try:
-        parsed_user_id = int(user_id)
-    except (TypeError, ValueError):
-        return None
-    if not isinstance(email, str):
-        return None
-    return SessionUser(id=parsed_user_id, email=email, is_admin=bool(is_admin))
-
-
-def set_session_user(
-    request: Request,
-    *,
-    user_id: int,
-    email: str,
-    is_admin: bool,
-) -> None:
-    request.session[SESSION_USER_ID_KEY] = int(user_id)
-    request.session[SESSION_USER_EMAIL_KEY] = email
-    request.session[SESSION_USER_IS_ADMIN_KEY] = bool(is_admin)
-
-
-def clear_session_user(request: Request) -> None:
-    request.session.pop(SESSION_USER_ID_KEY, None)
-    request.session.pop(SESSION_USER_EMAIL_KEY, None)
-    request.session.pop(SESSION_USER_IS_ADMIN_KEY, None)
diff --git a/build/lib/app/db/__init__.py b/build/lib/app/db/__init__.py
deleted file mode 100644
index 8b13789..0000000
--- a/build/lib/app/db/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/build/lib/app/db/base.py b/build/lib/app/db/base.py
deleted file mode 100644
index 6fa2049..0000000
--- a/build/lib/app/db/base.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from datetime import datetime, timezone
-
-from sqlalchemy import MetaData, event
-from sqlalchemy.orm import DeclarativeBase
-
-
-NAMING_CONVENTION = {
-    "ix": "ix_%(column_0_label)s",
-    "uq": "uq_%(table_name)s_%(column_0_name)s",
-    "ck": "ck_%(table_name)s_%(constraint_name)s",
-    "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
-    "pk": "pk_%(table_name)s",
-}
-
-
-class Base(DeclarativeBase):
-    metadata = MetaData(naming_convention=NAMING_CONVENTION)
-
-
-@event.listens_for(Base, "before_update", propagate=True)
-def _set_updated_at_before_update(_mapper, _connection, target) -> None:
-    # Keep audit timestamps current for ORM-managed updates.
-    if hasattr(target, "updated_at"):
-        target.updated_at = datetime.now(timezone.utc)
-
-
-metadata = Base.metadata
diff --git a/build/lib/app/db/models.py b/build/lib/app/db/models.py
deleted file mode 100644
index 1a8ad8a..0000000
--- a/build/lib/app/db/models.py
+++ /dev/null
@@ -1,546 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-from enum import StrEnum
-
-from sqlalchemy import (
-    Boolean,
-    CheckConstraint,
-    DateTime,
-    Enum,
-    Float,
-    ForeignKey,
-    Index,
-    Integer,
-    String,
-    Text,
-    UniqueConstraint,
-    func,
-    text,
-)
-from sqlalchemy.dialects.postgresql import JSONB
-from sqlalchemy.orm import Mapped, mapped_column
-
-from app.db.base import Base
-
-
-class RunTriggerType(StrEnum):
-    MANUAL = "manual"
-    SCHEDULED = "scheduled"
-
-
-class RunStatus(StrEnum):
-    RUNNING = "running"
-    SUCCESS = "success"
-    PARTIAL_FAILURE = "partial_failure"
-    FAILED = "failed"
-    CANCELED = "canceled"
-
-
-class QueueItemStatus(StrEnum):
-    QUEUED = "queued"
-    RETRYING = "retrying"
-    DROPPED = "dropped"
-
-
-RUN_STATUS_DB_ENUM = Enum(
-    RunStatus,
-    name="run_status",
-    values_callable=lambda members: [member.value for member in members],
-)
-RUN_TRIGGER_TYPE_DB_ENUM = Enum(
-    RunTriggerType,
-    name="run_trigger_type",
-    values_callable=lambda members: [member.value for member in members],
-)
-
-
-class User(Base):
-    __tablename__ = "users"
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    email: Mapped[str] = mapped_column(String(255), nullable=False, unique=True)
-    password_hash: Mapped[str] = mapped_column(String(255), nullable=False)
-    is_active: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("true")
-    )
-    is_admin: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("false")
-    )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class UserSetting(Base):
-    __tablename__ = "user_settings"
-    __table_args__ = (
-        CheckConstraint(
-            "run_interval_minutes >= 15",
-            name="run_interval_minutes_min_15",
-        ),
-        CheckConstraint(
-            "request_delay_seconds >= 2",
-            name="request_delay_seconds_min_2",
-        ),
-    )
-
-    user_id: Mapped[int] = mapped_column(
-        ForeignKey("users.id", ondelete="CASCADE"), primary_key=True
-    )
-    auto_run_enabled: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("false")
-    )
-    run_interval_minutes: Mapped[int] = mapped_column(
-        Integer, nullable=False, server_default=text("1440")
-    )
-    request_delay_seconds: Mapped[int] = mapped_column(
-        Integer, nullable=False, server_default=text("10")
-    )
-    nav_visible_pages: Mapped[list[str]] = mapped_column(
-        JSONB,
-        nullable=False,
-        server_default=text(
-            '\'["dashboard","scholars","publications","settings","style-guide","runs","users"]\'::jsonb'
-        ),
-    )
-    scrape_safety_state: Mapped[dict] = mapped_column(
-        JSONB,
-        nullable=False,
-        server_default=text("'{}'::jsonb"),
-    )
-    scrape_cooldown_until: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    scrape_cooldown_reason: Mapped[str | None] = mapped_column(String(64))
-    
-    openalex_api_key: Mapped[str | None] = mapped_column(String(255))
-    crossref_api_token: Mapped[str | None] = mapped_column(String(255))
-    crossref_api_mailto: Mapped[str | None] = mapped_column(String(255))
-
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class ScholarProfile(Base):
-    __tablename__ = "scholar_profiles"
-    __table_args__ = (
-        UniqueConstraint("user_id", "scholar_id", name="uq_scholar_profiles_user_scholar"),
-        Index("ix_scholar_profiles_user_enabled", "user_id", "is_enabled"),
-    )
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    user_id: Mapped[int] = mapped_column(
-        ForeignKey("users.id", ondelete="CASCADE"), nullable=False
-    )
-    scholar_id: Mapped[str] = mapped_column(String(64), nullable=False)
-    display_name: Mapped[str | None] = mapped_column(String(255))
-    profile_image_url: Mapped[str | None] = mapped_column(Text)
-    profile_image_override_url: Mapped[str | None] = mapped_column(Text)
-    profile_image_upload_path: Mapped[str | None] = mapped_column(Text)
-    last_initial_page_fingerprint_sha256: Mapped[str | None] = mapped_column(String(64))
-    last_initial_page_checked_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    is_enabled: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("true")
-    )
-    baseline_completed: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("false")
-    )
-    last_run_dt: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    last_run_status: Mapped[RunStatus | None] = mapped_column(
-        RUN_STATUS_DB_ENUM,
-    )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class CrawlRun(Base):
-    __tablename__ = "crawl_runs"
-    __table_args__ = (
-        Index("ix_crawl_runs_user_start", "user_id", "start_dt"),
-        Index(
-            "uq_crawl_runs_user_manual_idempotency_key",
-            "user_id",
-            "idempotency_key",
-            unique=True,
-            postgresql_where=text(
-                "idempotency_key IS NOT NULL AND trigger_type = 'manual'::run_trigger_type"
-            ),
-        ),
-    )
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    user_id: Mapped[int] = mapped_column(
-        ForeignKey("users.id", ondelete="CASCADE"), nullable=False
-    )
-    trigger_type: Mapped[RunTriggerType] = mapped_column(
-        RUN_TRIGGER_TYPE_DB_ENUM, nullable=False
-    )
-    status: Mapped[RunStatus] = mapped_column(
-        RUN_STATUS_DB_ENUM, nullable=False
-    )
-    start_dt: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    end_dt: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    scholar_count: Mapped[int] = mapped_column(
-        Integer, nullable=False, server_default=text("0")
-    )
-    new_pub_count: Mapped[int] = mapped_column(
-        Integer, nullable=False, server_default=text("0")
-    )
-    idempotency_key: Mapped[str | None] = mapped_column(String(128))
-    error_log: Mapped[dict] = mapped_column(
-        JSONB, nullable=False, server_default=text("'{}'::jsonb")
-    )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class Publication(Base):
-    __tablename__ = "publications"
-    __table_args__ = (
-        UniqueConstraint("fingerprint_sha256", name="uq_publications_fingerprint"),
-        Index(
-            "uq_publications_cluster_id_not_null",
-            "cluster_id",
-            unique=True,
-            postgresql_where=text("cluster_id IS NOT NULL"),
-        ),
-    )
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    cluster_id: Mapped[str | None] = mapped_column(String(64))
-    fingerprint_sha256: Mapped[str] = mapped_column(String(64), nullable=False)
-    title_raw: Mapped[str] = mapped_column(Text, nullable=False)
-    title_normalized: Mapped[str] = mapped_column(Text, nullable=False)
-    year: Mapped[int | None] = mapped_column(Integer)
-    citation_count: Mapped[int] = mapped_column(
-        Integer, nullable=False, server_default=text("0")
-    )
-    author_text: Mapped[str | None] = mapped_column(Text)
-    venue_text: Mapped[str | None] = mapped_column(Text)
-    pub_url: Mapped[str | None] = mapped_column(Text)
-    pdf_url: Mapped[str | None] = mapped_column(Text)
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class PublicationIdentifier(Base):
-    __tablename__ = "publication_identifiers"
-    __table_args__ = (
-        UniqueConstraint(
-            "publication_id",
-            "kind",
-            "value_normalized",
-            name="uq_publication_identifiers_publication_kind_value",
-        ),
-        CheckConstraint(
-            "confidence_score >= 0 AND confidence_score <= 1",
-            name="publication_identifiers_confidence_score_range",
-        ),
-        Index(
-            "ix_publication_identifiers_kind_value",
-            "kind",
-            "value_normalized",
-        ),
-        Index(
-            "ix_publication_identifiers_publication_id",
-            "publication_id",
-        ),
-    )
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    publication_id: Mapped[int] = mapped_column(
-        ForeignKey("publications.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    kind: Mapped[str] = mapped_column(String(32), nullable=False)
-    value_raw: Mapped[str] = mapped_column(Text, nullable=False)
-    value_normalized: Mapped[str] = mapped_column(String(255), nullable=False)
-    source: Mapped[str] = mapped_column(String(64), nullable=False)
-    confidence_score: Mapped[float] = mapped_column(
-        Float,
-        nullable=False,
-        server_default=text("0"),
-    )
-    evidence_url: Mapped[str | None] = mapped_column(Text)
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class PublicationPdfJob(Base):
-    __tablename__ = "publication_pdf_jobs"
-    __table_args__ = (
-        CheckConstraint(
-            "status IN ('queued', 'running', 'resolved', 'failed')",
-            name="publication_pdf_jobs_status_valid",
-        ),
-        Index("ix_publication_pdf_jobs_status", "status"),
-        Index("ix_publication_pdf_jobs_updated_at", "updated_at"),
-        Index("ix_publication_pdf_jobs_queued_at", "queued_at"),
-    )
-
-    publication_id: Mapped[int] = mapped_column(
-        ForeignKey("publications.id", ondelete="CASCADE"),
-        primary_key=True,
-    )
-    status: Mapped[str] = mapped_column(
-        String(16),
-        nullable=False,
-        server_default=text("'queued'"),
-    )
-    attempt_count: Mapped[int] = mapped_column(
-        Integer,
-        nullable=False,
-        server_default=text("0"),
-    )
-    queued_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    last_attempt_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    resolved_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    last_failure_reason: Mapped[str | None] = mapped_column(String(64))
-    last_failure_detail: Mapped[str | None] = mapped_column(Text)
-    last_source: Mapped[str | None] = mapped_column(String(32))
-    last_requested_by_user_id: Mapped[int | None] = mapped_column(
-        ForeignKey("users.id", ondelete="SET NULL"),
-    )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class PublicationPdfJobEvent(Base):
-    __tablename__ = "publication_pdf_job_events"
-    __table_args__ = (
-        Index("ix_publication_pdf_job_events_publication_created", "publication_id", "created_at"),
-        Index("ix_publication_pdf_job_events_created_at", "created_at"),
-        Index("ix_publication_pdf_job_events_event_type", "event_type"),
-    )
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    publication_id: Mapped[int] = mapped_column(
-        ForeignKey("publications.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    user_id: Mapped[int | None] = mapped_column(
-        ForeignKey("users.id", ondelete="SET NULL"),
-    )
-    event_type: Mapped[str] = mapped_column(String(32), nullable=False)
-    status: Mapped[str | None] = mapped_column(String(16))
-    source: Mapped[str | None] = mapped_column(String(32))
-    failure_reason: Mapped[str | None] = mapped_column(String(64))
-    message: Mapped[str | None] = mapped_column(Text)
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class ScholarPublication(Base):
-    __tablename__ = "scholar_publications"
-    __table_args__ = (
-        Index("ix_scholar_publications_is_read", "is_read"),
-        Index("ix_scholar_publications_is_favorite", "is_favorite"),
-    )
-
-    scholar_profile_id: Mapped[int] = mapped_column(
-        ForeignKey("scholar_profiles.id", ondelete="CASCADE"),
-        primary_key=True,
-    )
-    publication_id: Mapped[int] = mapped_column(
-        ForeignKey("publications.id", ondelete="CASCADE"),
-        primary_key=True,
-    )
-    is_read: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("false")
-    )
-    is_favorite: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("false")
-    )
-    first_seen_run_id: Mapped[int | None] = mapped_column(
-        ForeignKey("crawl_runs.id", ondelete="SET NULL")
-    )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class IngestionQueueItem(Base):
-    __tablename__ = "ingestion_queue_items"
-    __table_args__ = (
-        UniqueConstraint(
-            "user_id",
-            "scholar_profile_id",
-            name="uq_ingestion_queue_user_scholar",
-        ),
-        CheckConstraint(
-            "status IN ('queued', 'retrying', 'dropped')",
-            name="ingestion_queue_status_valid",
-        ),
-        Index("ix_ingestion_queue_next_attempt", "next_attempt_dt"),
-        Index("ix_ingestion_queue_status_next_attempt", "status", "next_attempt_dt"),
-    )
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    user_id: Mapped[int] = mapped_column(
-        ForeignKey("users.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    scholar_profile_id: Mapped[int] = mapped_column(
-        ForeignKey("scholar_profiles.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    resume_cstart: Mapped[int] = mapped_column(
-        Integer,
-        nullable=False,
-        server_default=text("0"),
-    )
-    reason: Mapped[str] = mapped_column(String(64), nullable=False)
-    status: Mapped[str] = mapped_column(
-        String(16),
-        nullable=False,
-        server_default=text("'queued'"),
-    )
-    attempt_count: Mapped[int] = mapped_column(
-        Integer,
-        nullable=False,
-        server_default=text("0"),
-    )
-    next_attempt_dt: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True),
-        nullable=False,
-        server_default=func.now(),
-    )
-    last_run_id: Mapped[int | None] = mapped_column(
-        ForeignKey("crawl_runs.id", ondelete="SET NULL"),
-    )
-    last_error: Mapped[str | None] = mapped_column(Text)
-    dropped_reason: Mapped[str | None] = mapped_column(String(128))
-    dropped_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class DataRepairJob(Base):
-    __tablename__ = "data_repair_jobs"
-    __table_args__ = (
-        CheckConstraint(
-            "status IN ('planned', 'running', 'completed', 'failed')",
-            name="data_repair_jobs_status_valid",
-        ),
-        Index("ix_data_repair_jobs_created_at", "created_at"),
-        Index("ix_data_repair_jobs_job_name_created_at", "job_name", "created_at"),
-    )
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    job_name: Mapped[str] = mapped_column(String(64), nullable=False)
-    requested_by: Mapped[str | None] = mapped_column(String(255))
-    scope: Mapped[dict] = mapped_column(
-        JSONB,
-        nullable=False,
-        server_default=text("'{}'::jsonb"),
-    )
-    dry_run: Mapped[bool] = mapped_column(
-        Boolean,
-        nullable=False,
-        server_default=text("true"),
-    )
-    status: Mapped[str] = mapped_column(
-        String(16),
-        nullable=False,
-        server_default=text("'planned'"),
-    )
-    summary: Mapped[dict] = mapped_column(
-        JSONB,
-        nullable=False,
-        server_default=text("'{}'::jsonb"),
-    )
-    error_text: Mapped[str | None] = mapped_column(Text)
-    started_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    finished_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class AuthorSearchRuntimeState(Base):
-    __tablename__ = "author_search_runtime_state"
-
-    state_key: Mapped[str] = mapped_column(String(64), primary_key=True)
-    last_live_request_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    cooldown_until: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    consecutive_blocked_count: Mapped[int] = mapped_column(
-        Integer,
-        nullable=False,
-        server_default=text("0"),
-    )
-    cooldown_rejection_count: Mapped[int] = mapped_column(
-        Integer,
-        nullable=False,
-        server_default=text("0"),
-    )
-    cooldown_alert_emitted: Mapped[bool] = mapped_column(
-        Boolean,
-        nullable=False,
-        server_default=text("false"),
-    )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-
-
-class AuthorSearchCacheEntry(Base):
-    __tablename__ = "author_search_cache_entries"
-    __table_args__ = (
-        Index("ix_author_search_cache_expires_at", "expires_at"),
-        Index("ix_author_search_cache_cached_at", "cached_at"),
-    )
-
-    query_key: Mapped[str] = mapped_column(String(256), primary_key=True)
-    payload: Mapped[dict] = mapped_column(
-        JSONB,
-        nullable=False,
-    )
-    expires_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True),
-        nullable=False,
-    )
-    cached_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
diff --git a/build/lib/app/db/session.py b/build/lib/app/db/session.py
deleted file mode 100644
index c05266e..0000000
--- a/build/lib/app/db/session.py
+++ /dev/null
@@ -1,99 +0,0 @@
-from collections.abc import AsyncIterator
-import logging
-import os
-
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import (
-    AsyncEngine,
-    AsyncSession,
-    async_sessionmaker,
-    create_async_engine,
-)
-from sqlalchemy.pool import NullPool
-
-from app.settings import settings
-
-logger = logging.getLogger(__name__)
-
-_engine: AsyncEngine | None = None
-_session_factory: async_sessionmaker[AsyncSession] | None = None
-
-
-def _normalized_pool_mode(raw_mode: str) -> str:
-    mode = (raw_mode or "").strip().lower()
-    if mode == "auto":
-        if os.getenv("PYTEST_CURRENT_TEST"):
-            return "null"
-        app_env = (os.getenv("APP_ENV") or "").strip().lower()
-        if app_env in {"test", "development", "dev", "local"}:
-            return "null"
-        return "queue"
-    if mode in {"null", "queue"}:
-        return mode
-    logger.warning(
-        "db.invalid_pool_mode_fallback",
-        extra={
-            "event": "db.invalid_pool_mode_fallback",
-            "database_pool_mode": raw_mode,
-            "fallback_mode": "queue",
-        },
-    )
-    return "queue"
-
-
-def get_engine() -> AsyncEngine:
-    global _engine
-    if _engine is None:
-        pool_mode = _normalized_pool_mode(settings.database_pool_mode)
-        engine_kwargs: dict[str, object] = {
-            "pool_pre_ping": True,
-        }
-        if pool_mode == "null":
-            engine_kwargs["poolclass"] = NullPool
-        else:
-            engine_kwargs["pool_size"] = max(1, int(settings.database_pool_size))
-            engine_kwargs["max_overflow"] = max(0, int(settings.database_pool_max_overflow))
-            engine_kwargs["pool_timeout"] = max(1, int(settings.database_pool_timeout_seconds))
-
-        _engine = create_async_engine(settings.database_url, **engine_kwargs)
-        logger.info(
-            "db.engine_initialized",
-            extra={
-                "event": "db.engine_initialized",
-                "pool_mode": pool_mode,
-            },
-        )
-    return _engine
-
-
-def get_session_factory() -> async_sessionmaker[AsyncSession]:
-    global _session_factory
-    if _session_factory is None:
-        _session_factory = async_sessionmaker(get_engine(), expire_on_commit=False)
-    return _session_factory
-
-
-async def get_db_session() -> AsyncIterator[AsyncSession]:
-    session_factory = get_session_factory()
-    async with session_factory() as session:
-        yield session
-
-
-async def check_database() -> bool:
-    engine = get_engine()
-    try:
-        async with engine.connect() as conn:
-            result = await conn.execute(text("SELECT 1"))
-            return result.scalar_one() == 1
-    except Exception:
-        logger.exception("db.healthcheck_failed", extra={"event": "db.healthcheck_failed"})
-        return False
-
-
-async def close_engine() -> None:
-    global _engine, _session_factory
-    if _engine is not None:
-        await _engine.dispose()
-        logger.info("db.engine_disposed", extra={"event": "db.engine_disposed"})
-        _engine = None
-        _session_factory = None
diff --git a/build/lib/app/http/__init__.py b/build/lib/app/http/__init__.py
deleted file mode 100644
index 9d48db4..0000000
--- a/build/lib/app/http/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from __future__ import annotations
diff --git a/build/lib/app/http/middleware.py b/build/lib/app/http/middleware.py
deleted file mode 100644
index ebe72f8..0000000
--- a/build/lib/app/http/middleware.py
+++ /dev/null
@@ -1,205 +0,0 @@
-from __future__ import annotations
-
-from secrets import token_urlsafe
-import logging
-import time
-
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import Response
-
-from app.logging_context import set_request_id
-
-REQUEST_ID_HEADER = "X-Request-ID"
-DEFAULT_PERMISSIONS_POLICY = (
-    "accelerometer=(), autoplay=(), camera=(), display-capture=(), "
-    "geolocation=(), gyroscope=(), microphone=(), payment=(), usb=()"
-)
-DEFAULT_CSP_POLICY = (
-    "default-src 'self'; "
-    "base-uri 'self'; "
-    "form-action 'self'; "
-    "frame-ancestors 'none'; "
-    "img-src 'self' data: https:; "
-    "script-src 'self'; "
-    "style-src 'self' 'unsafe-inline'; "
-    "font-src 'self' data:; "
-    "connect-src 'self'; "
-    "object-src 'none'"
-)
-DEFAULT_CSP_DOCS_POLICY = (
-    "default-src 'self'; "
-    "img-src 'self' data: https:; "
-    "script-src 'self' 'unsafe-inline'; "
-    "style-src 'self' 'unsafe-inline'; "
-    "font-src 'self' data:; "
-    "connect-src 'self' https:; "
-    "object-src 'none'; "
-    "frame-ancestors 'none'"
-)
-
-logger = logging.getLogger(__name__)
-
-
-class RequestLoggingMiddleware(BaseHTTPMiddleware):
-    def __init__(
-        self,
-        app,
-        *,
-        log_requests: bool = True,
-        skip_paths: tuple[str, ...] = (),
-    ) -> None:
-        super().__init__(app)
-        self._log_requests = log_requests
-        self._skip_paths = tuple(path for path in skip_paths if path)
-
-    async def dispatch(self, request: Request, call_next) -> Response:
-        request_id = request.headers.get(REQUEST_ID_HEADER) or token_urlsafe(12)
-        request.state.request_id = request_id
-        set_request_id(request_id)
-
-        start = time.perf_counter()
-        should_log = self._log_requests and not self._is_skipped_path(request.url.path)
-        if should_log:
-            logger.debug(
-                "request.started",
-                extra={
-                    "event": "request.started",
-                    "method": request.method,
-                    "path": request.url.path,
-                },
-            )
-
-        try:
-            response = await call_next(request)
-        except Exception:
-            duration_ms = int((time.perf_counter() - start) * 1000)
-            logger.exception(
-                "request.failed",
-                extra={
-                    "event": "request.failed",
-                    "method": request.method,
-                    "path": request.url.path,
-                    "duration_ms": duration_ms,
-                },
-            )
-            raise
-        else:
-            duration_ms = int((time.perf_counter() - start) * 1000)
-            response.headers[REQUEST_ID_HEADER] = request_id
-            if should_log:
-                logger.debug(
-                    "request.completed",
-                    extra={
-                        "event": "request.completed",
-                        "method": request.method,
-                        "path": request.url.path,
-                        "status_code": response.status_code,
-                        "duration_ms": duration_ms,
-                    },
-                )
-            return response
-        finally:
-            set_request_id(None)
-
-    def _is_skipped_path(self, path: str) -> bool:
-        return any(path.startswith(prefix) for prefix in self._skip_paths)
-
-
-class SecurityHeadersMiddleware(BaseHTTPMiddleware):
-    def __init__(
-        self,
-        app,
-        *,
-        enabled: bool = True,
-        x_content_type_options: str = "nosniff",
-        x_frame_options: str = "DENY",
-        referrer_policy: str = "strict-origin-when-cross-origin",
-        permissions_policy: str = DEFAULT_PERMISSIONS_POLICY,
-        cross_origin_opener_policy: str = "same-origin",
-        cross_origin_resource_policy: str = "same-origin",
-        content_security_policy_enabled: bool = True,
-        content_security_policy: str = DEFAULT_CSP_POLICY,
-        content_security_policy_docs: str = DEFAULT_CSP_DOCS_POLICY,
-        content_security_policy_report_only: bool = False,
-        strict_transport_security_enabled: bool = False,
-        strict_transport_security_max_age: int = 31_536_000,
-        strict_transport_security_include_subdomains: bool = True,
-        strict_transport_security_preload: bool = False,
-    ) -> None:
-        super().__init__(app)
-        self._enabled = enabled
-        self._x_content_type_options = x_content_type_options.strip()
-        self._x_frame_options = x_frame_options.strip()
-        self._referrer_policy = referrer_policy.strip()
-        self._permissions_policy = permissions_policy.strip()
-        self._cross_origin_opener_policy = cross_origin_opener_policy.strip()
-        self._cross_origin_resource_policy = cross_origin_resource_policy.strip()
-        self._csp_enabled = content_security_policy_enabled
-        self._csp_policy = content_security_policy.strip()
-        self._csp_docs_policy = content_security_policy_docs.strip()
-        self._csp_report_only = content_security_policy_report_only
-        self._hsts_enabled = strict_transport_security_enabled
-        self._hsts_max_age = max(0, strict_transport_security_max_age)
-        self._hsts_include_subdomains = strict_transport_security_include_subdomains
-        self._hsts_preload = strict_transport_security_preload
-
-    async def dispatch(self, request: Request, call_next) -> Response:
-        response = await call_next(request)
-        if not self._enabled:
-            return response
-
-        if self._x_content_type_options:
-            response.headers.setdefault("X-Content-Type-Options", self._x_content_type_options)
-        if self._x_frame_options:
-            response.headers.setdefault("X-Frame-Options", self._x_frame_options)
-        if self._referrer_policy:
-            response.headers.setdefault("Referrer-Policy", self._referrer_policy)
-        if self._permissions_policy:
-            response.headers.setdefault("Permissions-Policy", self._permissions_policy)
-        if self._cross_origin_opener_policy:
-            response.headers.setdefault(
-                "Cross-Origin-Opener-Policy",
-                self._cross_origin_opener_policy,
-            )
-        if self._cross_origin_resource_policy:
-            response.headers.setdefault(
-                "Cross-Origin-Resource-Policy",
-                self._cross_origin_resource_policy,
-            )
-
-        csp_policy = self._csp_policy_for_path(request.url.path)
-        if self._csp_enabled and csp_policy:
-            csp_header = (
-                "Content-Security-Policy-Report-Only"
-                if self._csp_report_only
-                else "Content-Security-Policy"
-            )
-            response.headers.setdefault(csp_header, csp_policy)
-
-        hsts = self._strict_transport_security_value()
-        if hsts:
-            response.headers.setdefault("Strict-Transport-Security", hsts)
-
-        return response
-
-    def _csp_policy_for_path(self, path: str) -> str:
-        if path.startswith("/docs") or path.startswith("/redoc"):
-            return self._csp_docs_policy or self._csp_policy
-        return self._csp_policy
-
-    def _strict_transport_security_value(self) -> str:
-        if not self._hsts_enabled:
-            return ""
-
-        directives = [f"max-age={self._hsts_max_age}"]
-        if self._hsts_include_subdomains:
-            directives.append("includeSubDomains")
-        if self._hsts_preload:
-            directives.append("preload")
-        return "; ".join(directives)
-
-
-def parse_skip_paths(raw_value: str) -> tuple[str, ...]:
-    parts = [part.strip() for part in raw_value.split(",")]
-    return tuple(part for part in parts if part)
diff --git a/build/lib/app/logging_config.py b/build/lib/app/logging_config.py
deleted file mode 100644
index 22907be..0000000
--- a/build/lib/app/logging_config.py
+++ /dev/null
@@ -1,183 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timezone
-import json
-import logging
-import sys
-from typing import Any
-
-from app.logging_context import get_request_id
-
-DEFAULT_REDACT_FIELDS = {
-    "authorization",
-    "cookie",
-    "csrf_token",
-    "new_password",
-    "password",
-    "password_hash",
-    "session",
-    "session_secret_key",
-}
-
-_BASE_RECORD = logging.makeLogRecord({})
-_STANDARD_RECORD_FIELDS = set(_BASE_RECORD.__dict__.keys()) | {"message", "asctime"}
-_NOISY_RECORD_FIELDS = {"color_message"}
-
-
-def parse_redact_fields(raw: str | None) -> set[str]:
-    fields = {field.strip().lower() for field in (raw or "").split(",") if field.strip()}
-    return DEFAULT_REDACT_FIELDS | fields
-
-
-def configure_logging(
-    *,
-    level: str,
-    log_format: str,
-    redact_fields: set[str],
-    include_uvicorn_access: bool,
-) -> None:
-    normalized_level = _normalize_level(level)
-    root_logger = logging.getLogger()
-    root_logger.handlers.clear()
-    root_logger.setLevel(normalized_level)
-
-    handler = logging.StreamHandler(stream=sys.stdout)
-    handler.setLevel(normalized_level)
-    handler.addFilter(RequestContextFilter())
-
-    normalized_format = log_format.strip().lower()
-    if normalized_format == "json":
-        handler.setFormatter(JsonLogFormatter(redact_fields=redact_fields))
-    else:
-        handler.setFormatter(ConsoleLogFormatter(redact_fields=redact_fields))
-
-    root_logger.addHandler(handler)
-
-    # Route server/framework logs through our single root handler.
-    for logger_name in ("uvicorn", "uvicorn.error"):
-        framework_logger = logging.getLogger(logger_name)
-        framework_logger.handlers.clear()
-        framework_logger.propagate = True
-        framework_logger.setLevel(normalized_level)
-
-    access_logger = logging.getLogger("uvicorn.access")
-    access_logger.handlers.clear()
-    access_logger.propagate = True
-    access_logger.setLevel(normalized_level if include_uvicorn_access else logging.WARNING)
-
-
-class RequestContextFilter(logging.Filter):
-    def filter(self, record: logging.LogRecord) -> bool:
-        if not getattr(record, "request_id", None):
-            request_id = get_request_id()
-            if request_id:
-                record.request_id = request_id
-        return True
-
-
-class JsonLogFormatter(logging.Formatter):
-    def __init__(self, *, redact_fields: set[str]) -> None:
-        super().__init__()
-        self._redact_fields = {field.lower() for field in redact_fields}
-
-    def format(self, record: logging.LogRecord) -> str:
-        payload: dict[str, Any] = {
-            "timestamp": _format_timestamp(record.created),
-            "level": record.levelname.lower(),
-            "logger": record.name,
-            "event": getattr(record, "event", record.getMessage()),
-        }
-        request_id = getattr(record, "request_id", None)
-        if request_id:
-            payload["request_id"] = request_id
-        payload.update(self._redact_mapping(_extra_fields(record)))
-        if record.exc_info:
-            payload["exception"] = self.formatException(record.exc_info)
-        return json.dumps(payload, ensure_ascii=True, default=str)
-
-    def _redact_mapping(self, value: dict[str, Any]) -> dict[str, Any]:
-        return {key: self._redact_value(key, item) for key, item in value.items()}
-
-    def _redact_value(self, key: str, value: Any) -> Any:
-        if key.lower() in self._redact_fields:
-            return "[REDACTED]"
-        if isinstance(value, dict):
-            return {nested_key: self._redact_value(nested_key, nested_value) for nested_key, nested_value in value.items()}
-        if isinstance(value, (list, tuple)):
-            return [self._redact_value(key, item) for item in value]
-        return value
-
-
-class ConsoleLogFormatter(logging.Formatter):
-    def __init__(self, *, redact_fields: set[str]) -> None:
-        super().__init__()
-        self._json_formatter = JsonLogFormatter(redact_fields=redact_fields)
-
-    def format(self, record: logging.LogRecord) -> str:
-        payload = json.loads(self._json_formatter.format(record))
-        timestamp = payload.get("timestamp", "")
-        level = _short_level(payload.get("level", "info"))
-        logger_name = str(payload.get("logger", "app"))
-        event = str(payload.get("event", ""))
-
-        parts = [timestamp, level, logger_name, event]
-
-        request_id = payload.pop("request_id", None)
-        method = payload.pop("method", None)
-        path = payload.pop("path", None)
-        status_code = payload.pop("status_code", None)
-        duration_ms = payload.pop("duration_ms", None)
-
-        if request_id:
-            parts.append(f"rid={request_id}")
-        if method and path:
-            parts.append(f"{method} {path}")
-        if status_code is not None:
-            parts.append(str(status_code))
-        if duration_ms is not None:
-            parts.append(f"{duration_ms}ms")
-
-        for key in sorted(payload.keys()):
-            if key in {"timestamp", "level", "logger", "event", "exception"}:
-                continue
-            parts.append(f"{key}={payload[key]}")
-
-        if "exception" in payload:
-            parts.append(f"exception={payload['exception']}")
-
-        return " | ".join(str(part) for part in parts if part)
-
-
-def _extra_fields(record: logging.LogRecord) -> dict[str, Any]:
-    extras: dict[str, Any] = {}
-    for key, value in record.__dict__.items():
-        if key in _STANDARD_RECORD_FIELDS or key.startswith("_"):
-            continue
-        if key in _NOISY_RECORD_FIELDS:
-            continue
-        extras[key] = value
-    return extras
-
-
-def _normalize_level(level: str) -> int:
-    normalized = level.strip().upper()
-    mapping = logging.getLevelNamesMapping()
-    if normalized not in mapping:
-        return logging.INFO
-    return mapping[normalized]
-
-
-def _format_timestamp(created_ts: float) -> str:
-    dt = datetime.fromtimestamp(created_ts, tz=timezone.utc)
-    return dt.strftime("%Y-%m-%d %H:%M:%SZ")
-
-
-def _short_level(level: str) -> str:
-    mapping = {
-        "debug": "DBG",
-        "info": "INF",
-        "warning": "WRN",
-        "error": "ERR",
-        "critical": "CRT",
-    }
-    return mapping.get(level.lower(), level[:3].upper())
diff --git a/build/lib/app/logging_context.py b/build/lib/app/logging_context.py
deleted file mode 100644
index ee578fb..0000000
--- a/build/lib/app/logging_context.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from contextvars import ContextVar
-
-
-_request_id_ctx: ContextVar[str | None] = ContextVar("request_id", default=None)
-
-
-def get_request_id() -> str | None:
-    return _request_id_ctx.get()
-
-
-def set_request_id(value: str | None) -> None:
-    _request_id_ctx.set(value)
-
diff --git a/build/lib/app/main.py b/build/lib/app/main.py
deleted file mode 100644
index e628bd9..0000000
--- a/build/lib/app/main.py
+++ /dev/null
@@ -1,168 +0,0 @@
-from __future__ import annotations
-
-from contextlib import asynccontextmanager
-import logging
-from pathlib import Path
-
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import FileResponse
-from fastapi.staticfiles import StaticFiles
-from starlette.middleware.sessions import SessionMiddleware
-
-from app.api.errors import register_api_exception_handlers
-from app.api.media import router as media_router
-from app.api.router import router as api_router
-from app.api.runtime_deps import get_ingestion_service, get_scholar_source
-from app.db.session import check_database
-from app.db.session import close_engine
-from app.http.middleware import (
-    RequestLoggingMiddleware,
-    SecurityHeadersMiddleware,
-    parse_skip_paths,
-)
-from app.logging_config import configure_logging, parse_redact_fields
-from app.security.csrf import CSRFMiddleware
-from app.services.domains.ingestion.scheduler import SchedulerService
-from app.settings import settings
-
-logger = logging.getLogger(__name__)
-BUILD_MARKER = "2026-02-19.phase2.direct-pdf-import-export-dashboard-sync"
-
-configure_logging(
-    level=settings.log_level,
-    log_format=settings.log_format,
-    redact_fields=parse_redact_fields(settings.log_redact_fields),
-    include_uvicorn_access=settings.log_uvicorn_access,
-)
-
-scheduler_service = SchedulerService(
-    enabled=settings.scheduler_enabled,
-    tick_seconds=settings.scheduler_tick_seconds,
-    network_error_retries=settings.ingestion_network_error_retries,
-    retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
-    max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
-    page_size=settings.ingestion_page_size,
-    continuation_queue_enabled=settings.ingestion_continuation_queue_enabled,
-    continuation_base_delay_seconds=settings.ingestion_continuation_base_delay_seconds,
-    continuation_max_delay_seconds=settings.ingestion_continuation_max_delay_seconds,
-    continuation_max_attempts=settings.ingestion_continuation_max_attempts,
-    queue_batch_size=settings.scheduler_queue_batch_size,
-)
-
-
-def _log_startup_build_marker() -> None:
-    logger.info(
-        "app.startup_build_marker",
-        extra={
-            "event": "app.startup_build_marker",
-            "build_marker": BUILD_MARKER,
-            "frontend_enabled": settings.frontend_enabled,
-            "scheduler_enabled": settings.scheduler_enabled,
-            "log_format": settings.log_format,
-        },
-    )
-
-
-@asynccontextmanager
-async def lifespan(_: FastAPI):
-    _log_startup_build_marker()
-    
-    from app.db.session import get_session_factory
-    from sqlalchemy import text
-    try:
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            await session.execute(text("UPDATE crawl_runs SET status = 'failed' WHERE status = 'running'"))
-            await session.commit()
-            logger.info("app.startup_orphaned_runs_cleaned", extra={"event": "app.startup_orphaned_runs_cleaned"})
-    except Exception as e:
-        logger.error(f"Failed to clean orphaned runs at startup: {e}")
-
-    await scheduler_service.start()
-    yield
-    await scheduler_service.stop()
-    await close_engine()
-
-
-app = FastAPI(title=settings.app_name, lifespan=lifespan)
-register_api_exception_handlers(app)
-app.add_middleware(CSRFMiddleware)
-app.add_middleware(
-    SessionMiddleware,
-    secret_key=settings.session_secret_key,
-    same_site="lax",
-    https_only=settings.session_cookie_secure,
-)
-app.add_middleware(
-    RequestLoggingMiddleware,
-    log_requests=settings.log_requests,
-    skip_paths=parse_skip_paths(settings.log_request_skip_paths),
-)
-app.add_middleware(
-    SecurityHeadersMiddleware,
-    enabled=settings.security_headers_enabled,
-    x_content_type_options=settings.security_x_content_type_options,
-    x_frame_options=settings.security_x_frame_options,
-    referrer_policy=settings.security_referrer_policy,
-    permissions_policy=settings.security_permissions_policy,
-    cross_origin_opener_policy=settings.security_cross_origin_opener_policy,
-    cross_origin_resource_policy=settings.security_cross_origin_resource_policy,
-    content_security_policy_enabled=settings.security_csp_enabled,
-    content_security_policy=settings.security_csp_policy,
-    content_security_policy_docs=settings.security_csp_docs_policy,
-    content_security_policy_report_only=settings.security_csp_report_only,
-    strict_transport_security_enabled=settings.security_strict_transport_security_enabled,
-    strict_transport_security_max_age=settings.security_strict_transport_security_max_age,
-    strict_transport_security_include_subdomains=(
-        settings.security_strict_transport_security_include_subdomains
-    ),
-    strict_transport_security_preload=settings.security_strict_transport_security_preload,
-)
-app.include_router(api_router)
-app.include_router(media_router)
-
-
-@app.get("/healthz")
-async def healthz() -> dict[str, str]:
-    if await check_database():
-        return {"status": "ok"}
-    raise HTTPException(status_code=500, detail="database unavailable")
-
-
-def _configure_frontend_routes(application: FastAPI) -> None:
-    if not settings.frontend_enabled:
-        return
-
-    dist_dir = Path(settings.frontend_dist_dir)
-    index_file = dist_dir / "index.html"
-
-    if not index_file.is_file():
-        return
-
-    assets_dir = dist_dir / "assets"
-    if assets_dir.is_dir():
-        application.mount("/assets", StaticFiles(directory=assets_dir), name="frontend-assets")
-
-    @application.get("/", include_in_schema=False)
-    async def frontend_index() -> FileResponse:
-        return FileResponse(index_file)
-
-    @application.get("/{full_path:path}", include_in_schema=False)
-    async def frontend_entry(full_path: str) -> FileResponse:
-        normalized = full_path.lstrip("/")
-        if normalized in {"healthz", "api"} or normalized.startswith("api/"):
-            raise HTTPException(status_code=404, detail="Not Found")
-
-        candidate = (dist_dir / normalized).resolve()
-        try:
-            candidate.relative_to(dist_dir.resolve())
-        except ValueError as error:
-            raise HTTPException(status_code=404, detail="Not Found") from error
-
-        if candidate.is_file():
-            return FileResponse(candidate)
-
-        return FileResponse(index_file)
-
-
-_configure_frontend_routes(app)
diff --git a/build/lib/app/security/__init__.py b/build/lib/app/security/__init__.py
deleted file mode 100644
index 4033692..0000000
--- a/build/lib/app/security/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-"""Security middleware and helpers for scholarr."""
-
diff --git a/build/lib/app/security/csrf.py b/build/lib/app/security/csrf.py
deleted file mode 100644
index 70eecac..0000000
--- a/build/lib/app/security/csrf.py
+++ /dev/null
@@ -1,133 +0,0 @@
-from __future__ import annotations
-
-import logging
-from secrets import compare_digest, token_urlsafe
-from urllib.parse import parse_qs
-
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import JSONResponse, PlainTextResponse, Response
-from starlette.types import Message
-
-
-CSRF_SESSION_KEY = "csrf_token"
-CSRF_FORM_FIELD = "csrf_token"
-CSRF_HEADER_NAME = "x-csrf-token"
-SAFE_METHODS = {"GET", "HEAD", "OPTIONS", "TRACE"}
-logger = logging.getLogger(__name__)
-
-
-def ensure_csrf_token(request: Request) -> str:
-    token = request.session.get(CSRF_SESSION_KEY)
-    if token is None:
-        token = token_urlsafe(32)
-        request.session[CSRF_SESSION_KEY] = token
-    return str(token)
-
-
-class CSRFMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app, *, exempt_paths: set[str] | None = None) -> None:
-        super().__init__(app)
-        self._exempt_paths = exempt_paths or set()
-
-    async def dispatch(self, request: Request, call_next) -> Response:
-        if self._should_skip(request):
-            return await call_next(request)
-
-        session_token = request.session.get(CSRF_SESSION_KEY)
-        if not session_token:
-            logger.warning(
-                "csrf.missing_session_token",
-                extra={
-                    "event": "csrf.missing_session_token",
-                    "method": request.method,
-                    "path": request.url.path,
-                },
-            )
-            return self._csrf_error_response(
-                request,
-                code="csrf_missing",
-                message="CSRF token missing.",
-            )
-
-        request_token = request.headers.get(CSRF_HEADER_NAME)
-        if request_token is None and self._is_form_payload(request):
-            body = await request.body()
-            request_token = self._token_from_form_body(request, body)
-            request._receive = self._build_receive(body)  # type: ignore[attr-defined]
-
-        if not request_token or not compare_digest(str(session_token), str(request_token)):
-            logger.warning(
-                "csrf.invalid_token",
-                extra={
-                    "event": "csrf.invalid_token",
-                    "method": request.method,
-                    "path": request.url.path,
-                },
-            )
-            return self._csrf_error_response(
-                request,
-                code="csrf_invalid",
-                message="CSRF token invalid.",
-            )
-
-        return await call_next(request)
-
-    def _should_skip(self, request: Request) -> bool:
-        if request.method in SAFE_METHODS:
-            return True
-        path = request.url.path
-        return path in self._exempt_paths
-
-    def _is_form_payload(self, request: Request) -> bool:
-        content_type = request.headers.get("content-type", "")
-        return content_type.startswith("application/x-www-form-urlencoded") or (
-            content_type.startswith("multipart/form-data")
-        )
-
-    def _token_from_form_body(self, request: Request, body: bytes) -> str | None:
-        content_type = request.headers.get("content-type", "")
-        if not content_type.startswith("application/x-www-form-urlencoded"):
-            return None
-        parsed = parse_qs(body.decode("utf-8"), keep_blank_values=True)
-        values = parsed.get(CSRF_FORM_FIELD)
-        if not values:
-            return None
-        return values[0]
-
-    def _build_receive(self, body: bytes):
-        consumed = False
-
-        async def receive() -> Message:
-            nonlocal consumed
-            if consumed:
-                return {"type": "http.request", "body": b"", "more_body": False}
-            consumed = True
-            return {"type": "http.request", "body": body, "more_body": False}
-
-        return receive
-
-    def _csrf_error_response(
-        self,
-        request: Request,
-        *,
-        code: str,
-        message: str,
-    ) -> Response:
-        if request.url.path.startswith("/api/"):
-            request_state = getattr(request, "state", None)
-            request_id = getattr(request_state, "request_id", None) if request_state else None
-            return JSONResponse(
-                {
-                    "error": {
-                        "code": code,
-                        "message": message,
-                        "details": None,
-                    },
-                    "meta": {
-                        "request_id": request_id,
-                    },
-                },
-                status_code=403,
-            )
-        return PlainTextResponse(message, status_code=403)
diff --git a/build/lib/app/services/__init__.py b/build/lib/app/services/__init__.py
deleted file mode 100644
index 167f869..0000000
--- a/build/lib/app/services/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-"""Service layer for scholarr application workflows."""
-
diff --git a/build/lib/app/services/domains/__init__.py b/build/lib/app/services/domains/__init__.py
deleted file mode 100644
index 9d48db4..0000000
--- a/build/lib/app/services/domains/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from __future__ import annotations
diff --git a/build/lib/app/services/domains/arxiv/application.py b/build/lib/app/services/domains/arxiv/application.py
deleted file mode 100644
index 1581a7d..0000000
--- a/build/lib/app/services/domains/arxiv/application.py
+++ /dev/null
@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import TYPE_CHECKING
-import xml.etree.ElementTree as ET
-
-import httpx
-
-from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
-from app.settings import settings
-
-if TYPE_CHECKING:
-    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
-
-logger = logging.getLogger(__name__)
-
-
-def _build_arxiv_query(title: str, author_surname: str | None) -> str | None:
-    parts = []
-    if title:
-        # arXiv api allows strict title searching using ti:
-        clean_title = title.replace('"', '').replace("'", "")
-        parts.append(f'ti:"{clean_title}"')
-    if author_surname:
-        parts.append(f'au:"{author_surname}"')
-    
-    if not parts:
-        return None
-    return " AND ".join(parts)
-
-
-async def discover_arxiv_id_for_publication(
-    *,
-    item: PublicationListItem | UnreadPublicationItem,
-    request_email: str | None = None,
-    timeout_seconds: float = 3.0,
-) -> str | None:
-    title = (item.title or "").strip()
-    if not title:
-        return None
-        
-    author_surname = None
-    if item.scholar_label:
-        tokens = [t for t in item.scholar_label.strip().split() if t]
-        if tokens:
-            author_surname = tokens[-1].lower()
-
-    query = _build_arxiv_query(title, author_surname)
-    if not query:
-        return None
-
-    url = "https://export.arxiv.org/api/query"
-    params = {
-        "search_query": query,
-        "start": 0,
-        "max_results": 3,
-    }
-
-    headers = {"User-Agent": f"scholar-scraper/1.0 (mailto:{request_email or settings.crossref_api_mailto or 'unknown@example.com'})"}
-    
-    try:
-        async with httpx.AsyncClient(timeout=timeout_seconds, follow_redirects=True, headers=headers) as client:
-            response = await client.get(url, params=params)
-            response.raise_for_status()
-            
-        root = ET.fromstring(response.text)
-        namespace = {'atom': 'http://www.w3.org/2005/Atom'}
-        
-        for entry in root.findall('atom:entry', namespace):
-            id_elem = entry.find('atom:id', namespace)
-            if id_elem is not None and id_elem.text:
-                candidate = str(id_elem.text)
-                if '/abs/' in candidate:
-                    candidate = candidate.split('/abs/')[-1]
-                normalized = normalize_arxiv_id(candidate)
-                if normalized:
-                    logger.debug("arxiv.id_discovered", extra={"event": "arxiv.id_discovered", "arxiv_id": normalized})
-                    return normalized
-                    
-    except Exception as exc:
-        logger.debug(f"Failed to query arXiv API: {exc}")
-        
-    return None
diff --git a/build/lib/app/services/domains/crossref/__init__.py b/build/lib/app/services/domains/crossref/__init__.py
deleted file mode 100644
index 8adb7ba..0000000
--- a/build/lib/app/services/domains/crossref/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-from app.services.domains.crossref.application import discover_doi_for_publication
-
-__all__ = ["discover_doi_for_publication"]
diff --git a/build/lib/app/services/domains/crossref/application.py b/build/lib/app/services/domains/crossref/application.py
deleted file mode 100644
index f0e1311..0000000
--- a/build/lib/app/services/domains/crossref/application.py
+++ /dev/null
@@ -1,382 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-import re
-import threading
-import time
-from typing import TYPE_CHECKING
-
-from crossref.restful import Etiquette, Works
-
-from app.services.domains.doi.normalize import normalize_doi
-from app.settings import settings
-
-if TYPE_CHECKING:
-    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
-
-TOKEN_RE = re.compile(r"[a-z0-9]+")
-NON_ALNUM_RE = re.compile(r"[^a-z0-9\\s]+")
-STOP_WORDS = {"the", "and", "for", "with", "from", "method", "study", "analysis"}
-_RATE_LOCK = threading.Lock()
-_LAST_REQUEST_AT = 0.0
-logger = logging.getLogger(__name__)
-STRICT_TITLE_MATCH_THRESHOLD = 0.75
-RELAXED_TITLE_MATCH_THRESHOLD = 0.85
-
-
-def _rate_limit_wait(min_interval_seconds: float) -> None:
-    global _LAST_REQUEST_AT
-    interval = max(float(min_interval_seconds), 0.0)
-    with _RATE_LOCK:
-        elapsed = time.monotonic() - _LAST_REQUEST_AT
-        remaining = interval - elapsed
-        if remaining > 0:
-            time.sleep(remaining)
-        _LAST_REQUEST_AT = time.monotonic()
-
-
-def _normalized_tokens(value: str) -> list[str]:
-    lowered = value.lower().replace("’", "'").replace("“", "\"").replace("”", "\"")
-    lowered = NON_ALNUM_RE.sub(" ", lowered)
-    return [token for token in TOKEN_RE.findall(lowered) if len(token) >= 3]
-
-
-def _normalized_query(value: str) -> str:
-    tokens = [token for token in _normalized_tokens(value) if token not in STOP_WORDS]
-    if len(tokens) < 3:
-        tokens = _normalized_tokens(value)
-    if len(tokens) < 3:
-        return ""
-    return " ".join(tokens[:12]).strip()
-
-
-def _query_author(value: str) -> str | None:
-    tokens = [token for token in value.strip().split() if token]
-    if len(tokens) < 2:
-        return None
-    return " ".join(tokens[:2])[:64]
-
-
-def _author_surname(value: str) -> str | None:
-    tokens = [token for token in value.strip().split() if token]
-    if not tokens:
-        return None
-    return NON_ALNUM_RE.sub("", tokens[-1].lower()) or None
-
-
-def _query_filters(year: int | None) -> list[tuple[str, str] | None]:
-    if year is None:
-        return [None]
-    return [
-        (f"{year - 1}-01-01", f"{year + 1}-12-31"),
-        (f"{year}-01-01", f"{year}-12-31"),
-        None,
-    ]
-
-
-def _candidate_title(item: dict) -> str:
-    titles = item.get("title")
-    if isinstance(titles, list) and titles:
-        return str(titles[0] or "")
-    return str(item.get("title") or "")
-
-
-def _title_match_score(source: str, candidate: str) -> float:
-    source_tokens = {token for token in _normalized_tokens(source) if len(token) >= 3}
-    candidate_tokens = {token for token in _normalized_tokens(candidate) if len(token) >= 3}
-    if not source_tokens or not candidate_tokens:
-        return 0.0
-    return len(source_tokens & candidate_tokens) / float(len(source_tokens))
-
-
-def _candidate_year(item: dict) -> int | None:
-    issued = item.get("issued")
-    if not isinstance(issued, dict):
-        return None
-    date_parts = issued.get("date-parts")
-    if not isinstance(date_parts, list) or not date_parts:
-        return None
-    first = date_parts[0]
-    if not isinstance(first, list) or not first:
-        return None
-    try:
-        return int(first[0])
-    except (TypeError, ValueError):
-        return None
-
-
-def _candidate_author_match(item: dict, surname: str | None) -> bool:
-    if not surname:
-        return True
-    authors = item.get("author")
-    if not isinstance(authors, list):
-        return False
-    for author in authors:
-        if not isinstance(author, dict):
-            continue
-        family = NON_ALNUM_RE.sub("", str(author.get("family") or "").lower())
-        if family and family == surname:
-            return True
-    return False
-
-
-def _candidate_rank(*, title: str, year: int | None, item: dict) -> tuple[float, str | None]:
-    doi = normalize_doi(str(item.get("DOI") or ""))
-    if doi is None:
-        return 0.0, None
-    score = _title_match_score(title, _candidate_title(item))
-    candidate_year = _candidate_year(item)
-    if year is not None and candidate_year is not None:
-        if abs(year - candidate_year) > 1:
-            return 0.0, None
-        score += 0.1
-    return score, doi
-
-
-def _year_delta(source_year: int | None, candidate_year: int | None) -> int | None:
-    if source_year is None or candidate_year is None:
-        return None
-    return abs(int(source_year) - int(candidate_year))
-
-
-def _candidate_rank_relaxed(
-    *,
-    title: str,
-    year: int | None,
-    item: dict,
-    author_surname: str | None,
-) -> tuple[float, str | None]:
-    doi = normalize_doi(str(item.get("DOI") or ""))
-    if doi is None:
-        return 0.0, None
-    score = _title_match_score(title, _candidate_title(item))
-    if score <= 0:
-        return 0.0, None
-    candidate_year = _candidate_year(item)
-    delta = _year_delta(year, candidate_year)
-    if delta is not None:
-        if delta <= 1:
-            score += 0.05
-        elif delta <= 3:
-            score += 0.0
-        elif delta <= 5:
-            score -= 0.03
-        else:
-            score -= 0.08
-    if _candidate_author_match(item, author_surname):
-        score += 0.03
-    return score, doi
-
-
-def _best_candidate_doi_strict(
-    *,
-    title: str,
-    year: int | None,
-    items: list[dict],
-    author_surname: str | None,
-) -> str | None:
-    best_score = 0.0
-    best_doi: str | None = None
-    best_year: int | None = None
-    for item in items:
-        if not isinstance(item, dict):
-            continue
-        if not _candidate_author_match(item, author_surname):
-            continue
-        score, doi = _candidate_rank(title=title, year=year, item=item)
-        candidate_year = _candidate_year(item)
-        if doi is None or score < STRICT_TITLE_MATCH_THRESHOLD:
-            continue
-        if score > best_score:
-            best_score = score
-            best_doi = doi
-            best_year = candidate_year
-            continue
-        if abs(score - best_score) > 0.02:
-            continue
-        if best_year is None or candidate_year is None:
-            continue
-        if candidate_year < best_year:
-            best_doi = doi
-            best_year = candidate_year
-    return best_doi
-
-
-def _best_candidate_doi_relaxed(
-    *,
-    title: str,
-    year: int | None,
-    items: list[dict],
-    author_surname: str | None,
-) -> str | None:
-    best_score = 0.0
-    best_doi: str | None = None
-    best_author_match = False
-    best_delta: int | None = None
-    best_year: int | None = None
-    for item in items:
-        if not isinstance(item, dict):
-            continue
-        score, doi = _candidate_rank_relaxed(
-            title=title,
-            year=year,
-            item=item,
-            author_surname=author_surname,
-        )
-        if doi is None or score < RELAXED_TITLE_MATCH_THRESHOLD:
-            continue
-        candidate_year = _candidate_year(item)
-        candidate_author_match = _candidate_author_match(item, author_surname)
-        candidate_delta = _year_delta(year, candidate_year)
-        if score > best_score:
-            best_score = score
-            best_doi = doi
-            best_author_match = candidate_author_match
-            best_delta = candidate_delta
-            best_year = candidate_year
-            continue
-        if abs(score - best_score) > 0.02:
-            continue
-        if candidate_author_match and not best_author_match:
-            best_doi = doi
-            best_author_match = True
-            best_delta = candidate_delta
-            best_year = candidate_year
-            continue
-        if best_delta is None and candidate_delta is not None:
-            best_doi = doi
-            best_author_match = candidate_author_match
-            best_delta = candidate_delta
-            best_year = candidate_year
-            continue
-        if best_delta is not None and candidate_delta is not None and candidate_delta < best_delta:
-            best_doi = doi
-            best_author_match = candidate_author_match
-            best_delta = candidate_delta
-            best_year = candidate_year
-            continue
-        if best_year is None or candidate_year is None:
-            continue
-        if candidate_year < best_year:
-            best_doi = doi
-            best_author_match = candidate_author_match
-            best_delta = candidate_delta
-            best_year = candidate_year
-    return best_doi
-
-
-def _best_candidate_doi(
-    *,
-    title: str,
-    year: int | None,
-    items: list[dict],
-    author_surname: str | None,
-) -> str | None:
-    strict_match = _best_candidate_doi_strict(
-        title=title,
-        year=year,
-        items=items,
-        author_surname=author_surname,
-    )
-    if strict_match:
-        return strict_match
-    return _best_candidate_doi_relaxed(
-        title=title,
-        year=year,
-        items=items,
-        author_surname=author_surname,
-    )
-
-
-def _works_client(email: str | None) -> Works:
-    if email:
-        etiquette = Etiquette(settings.app_name, "0.1.0", "https://scholarr.local", email)
-        return Works(etiquette=etiquette)
-    return Works()
-
-
-def _fetch_items_sync(
-    *,
-    query: str,
-    author: str | None,
-    date_range: tuple[str, str] | None,
-    max_rows: int,
-    email: str | None,
-    min_interval_seconds: float,
-) -> list[dict]:
-    _rate_limit_wait(min_interval_seconds)
-    works = _works_client(email)
-    params = {"bibliographic": query}
-    if author:
-        params["author"] = author
-    request = works.query(**params)
-    if date_range is not None:
-        from_date, until_date = date_range
-        request = request.filter(from_pub_date=from_date, until_pub_date=until_date)
-    request = request.select(["DOI", "title", "issued", "score", "author"])
-    items: list[dict] = []
-    for entry in request:
-        if isinstance(entry, dict):
-            items.append(entry)
-        if len(items) >= max(max_rows, 1):
-            break
-    return items
-
-
-async def _fetch_items(
-    *,
-    query: str,
-    author: str | None,
-    date_range: tuple[str, str] | None,
-    max_rows: int,
-    email: str | None,
-) -> list[dict]:
-    timeout = max(float(settings.crossref_timeout_seconds), 0.5)
-    try:
-        return await asyncio.wait_for(
-            asyncio.to_thread(
-                _fetch_items_sync,
-                query=query,
-                author=author,
-                date_range=date_range,
-                max_rows=max_rows,
-                email=email,
-                min_interval_seconds=settings.crossref_min_interval_seconds,
-            ),
-            timeout=timeout,
-        )
-    except Exception:
-        return []
-
-
-async def discover_doi_for_publication(
-    *,
-    item: PublicationListItem | UnreadPublicationItem,
-    max_rows: int = 10,
-    email: str | None = None,
-) -> str | None:
-    title = (item.title or "").strip()
-    query = _normalized_query(title)
-    if not query:
-        return None
-    author = _query_author(item.scholar_label)
-    author_surname = _author_surname(item.scholar_label)
-    for date_range in _query_filters(item.year):
-        items = await _fetch_items(
-            query=query,
-            author=author,
-            date_range=date_range,
-            max_rows=max_rows,
-            email=email,
-        )
-        doi = _best_candidate_doi(
-            title=title,
-            year=item.year,
-            items=items,
-            author_surname=author_surname,
-        )
-        if doi:
-            logger.debug("crossref.doi_discovered", extra={"event": "crossref.doi_discovered"})
-            return doi
-    return None
diff --git a/build/lib/app/services/domains/dbops/__init__.py b/build/lib/app/services/domains/dbops/__init__.py
deleted file mode 100644
index f5b02e4..0000000
--- a/build/lib/app/services/domains/dbops/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from app.services.domains.dbops.application import run_publication_link_repair
-from app.services.domains.dbops.integrity import collect_integrity_report
-from app.services.domains.dbops.query import list_repair_jobs
-
-__all__ = ["collect_integrity_report", "list_repair_jobs", "run_publication_link_repair"]
diff --git a/build/lib/app/services/domains/dbops/application.py b/build/lib/app/services/domains/dbops/application.py
deleted file mode 100644
index e7ace77..0000000
--- a/build/lib/app/services/domains/dbops/application.py
+++ /dev/null
@@ -1,364 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timezone
-from typing import Any
-
-from sqlalchemy import delete, exists, func, select, update
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import DataRepairJob, IngestionQueueItem, Publication, ScholarProfile, ScholarPublication
-
-
-REPAIR_STATUS_PLANNED = "planned"
-REPAIR_STATUS_RUNNING = "running"
-REPAIR_STATUS_COMPLETED = "completed"
-REPAIR_STATUS_FAILED = "failed"
-SCOPE_MODE_SINGLE_USER = "single_user"
-SCOPE_MODE_ALL_USERS = "all_users"
-
-
-def _utcnow() -> datetime:
-    return datetime.now(timezone.utc)
-
-
-def _normalize_scope_mode(scope_mode: str) -> str:
-    normalized = scope_mode.strip().lower()
-    if normalized in {SCOPE_MODE_SINGLE_USER, SCOPE_MODE_ALL_USERS}:
-        return normalized
-    raise ValueError("Unknown scope mode.")
-
-
-def _scope_user_id(*, scope_mode: str, user_id: int | None) -> int | None:
-    if scope_mode == SCOPE_MODE_SINGLE_USER:
-        if user_id is None:
-            raise ValueError("user_id is required when scope_mode=single_user.")
-        return int(user_id)
-    if user_id is not None:
-        raise ValueError("user_id must be omitted when scope_mode=all_users.")
-    return None
-
-
-def _scope_payload(
-    *,
-    scope_mode: str,
-    user_id: int | None,
-    target_scholar_profile_ids: list[int],
-    orphan_gc: bool,
-) -> dict[str, Any]:
-    payload: dict[str, Any] = {
-        "scope_mode": scope_mode,
-        "scholar_profile_ids": [int(value) for value in target_scholar_profile_ids],
-        "gc_orphan_publications": bool(orphan_gc),
-    }
-    if user_id is not None:
-        payload["user_id"] = int(user_id)
-    return payload
-
-
-async def _target_scholar_profile_ids(
-    db_session: AsyncSession,
-    *,
-    scope_mode: str,
-    user_id: int | None,
-    scholar_profile_ids: list[int] | None,
-) -> list[int]:
-    stmt = select(ScholarProfile.id)
-    if scope_mode == SCOPE_MODE_SINGLE_USER:
-        stmt = stmt.where(ScholarProfile.user_id == user_id)
-    if scholar_profile_ids:
-        normalized_ids = [int(value) for value in scholar_profile_ids]
-        stmt = stmt.where(ScholarProfile.id.in_(normalized_ids))
-    result = await db_session.execute(stmt.order_by(ScholarProfile.id.asc()))
-    ids = [int(row[0]) for row in result.all()]
-    if not ids:
-        raise ValueError("No target scholar profiles found for the requested scope.")
-    return ids
-
-
-async def _count_scope(
-    db_session: AsyncSession,
-    *,
-    user_id: int | None,
-    target_scholar_profile_ids: list[int],
-) -> dict[str, int]:
-    links_result = await db_session.execute(
-        select(func.count())
-        .select_from(ScholarPublication)
-        .where(ScholarPublication.scholar_profile_id.in_(target_scholar_profile_ids))
-    )
-    queue_stmt = (
-        select(func.count())
-        .select_from(IngestionQueueItem)
-        .where(IngestionQueueItem.scholar_profile_id.in_(target_scholar_profile_ids))
-    )
-    if user_id is not None:
-        queue_stmt = queue_stmt.where(IngestionQueueItem.user_id == user_id)
-    queue_result = await db_session.execute(queue_stmt)
-    return {
-        "target_scholar_count": len(target_scholar_profile_ids),
-        "links_in_scope": int(links_result.scalar_one() or 0),
-        "queue_items_in_scope": int(queue_result.scalar_one() or 0),
-    }
-
-
-async def _count_orphan_publications(db_session: AsyncSession) -> int:
-    stmt = (
-        select(func.count())
-        .select_from(Publication)
-        .where(
-            ~exists(
-                select(1).where(ScholarPublication.publication_id == Publication.id)
-            )
-        )
-    )
-    result = await db_session.execute(stmt)
-    return int(result.scalar_one() or 0)
-
-
-async def _create_job(
-    db_session: AsyncSession,
-    *,
-    requested_by: str | None,
-    scope: dict[str, Any],
-    dry_run: bool,
-) -> DataRepairJob:
-    job = DataRepairJob(
-        job_name="repair_publication_links",
-        requested_by=(requested_by or "").strip() or None,
-        scope=scope,
-        dry_run=dry_run,
-        status=REPAIR_STATUS_PLANNED,
-        summary={},
-    )
-    db_session.add(job)
-    await db_session.flush()
-    return job
-
-
-def _job_summary(
-    *,
-    counts: dict[str, int],
-    dry_run: bool,
-    links_deleted: int,
-    queue_items_deleted: int,
-    scholars_reset: int,
-    orphan_publications_before: int,
-    orphan_publications_deleted: int,
-) -> dict[str, Any]:
-    return {
-        **counts,
-        "dry_run": bool(dry_run),
-        "links_deleted": int(links_deleted),
-        "queue_items_deleted": int(queue_items_deleted),
-        "scholars_reset": int(scholars_reset),
-        "orphan_publications_before": int(orphan_publications_before),
-        "orphan_publications_deleted": int(orphan_publications_deleted),
-    }
-
-
-async def _delete_links_for_targets(db_session: AsyncSession, *, target_scholar_profile_ids: list[int]) -> int:
-    result = await db_session.execute(
-        delete(ScholarPublication).where(
-            ScholarPublication.scholar_profile_id.in_(target_scholar_profile_ids)
-        )
-    )
-    return int(result.rowcount or 0)
-
-
-async def _delete_queue_for_targets(
-    db_session: AsyncSession,
-    *,
-    user_id: int | None,
-    target_scholar_profile_ids: list[int],
-) -> int:
-    stmt = delete(IngestionQueueItem).where(
-        IngestionQueueItem.scholar_profile_id.in_(target_scholar_profile_ids)
-    )
-    if user_id is not None:
-        stmt = stmt.where(IngestionQueueItem.user_id == user_id)
-    result = await db_session.execute(stmt)
-    return int(result.rowcount or 0)
-
-
-async def _reset_scholar_tracking_state(
-    db_session: AsyncSession,
-    *,
-    user_id: int | None,
-    target_scholar_profile_ids: list[int],
-) -> int:
-    stmt = update(ScholarProfile).where(ScholarProfile.id.in_(target_scholar_profile_ids))
-    if user_id is not None:
-        stmt = stmt.where(ScholarProfile.user_id == user_id)
-    result = await db_session.execute(
-        stmt.values(
-            baseline_completed=False,
-            last_initial_page_fingerprint_sha256=None,
-            last_initial_page_checked_at=None,
-            last_run_dt=None,
-            last_run_status=None,
-        )
-    )
-    return int(result.rowcount or 0)
-
-
-async def _delete_orphan_publications(db_session: AsyncSession) -> int:
-    result = await db_session.execute(
-        delete(Publication).where(
-            ~exists(select(1).where(ScholarPublication.publication_id == Publication.id))
-        )
-    )
-    return int(result.rowcount or 0)
-
-
-async def _mutation_counts(
-    db_session: AsyncSession,
-    *,
-    user_id: int | None,
-    target_ids: list[int],
-    dry_run: bool,
-    gc_orphan_publications: bool,
-) -> tuple[int, int, int, int]:
-    if dry_run:
-        return 0, 0, 0, 0
-    links_deleted = await _delete_links_for_targets(
-        db_session,
-        target_scholar_profile_ids=target_ids,
-    )
-    queue_deleted = await _delete_queue_for_targets(
-        db_session,
-        user_id=user_id,
-        target_scholar_profile_ids=target_ids,
-    )
-    scholars_reset = await _reset_scholar_tracking_state(
-        db_session,
-        user_id=user_id,
-        target_scholar_profile_ids=target_ids,
-    )
-    orphan_deleted = 0
-    if gc_orphan_publications:
-        orphan_deleted = await _delete_orphan_publications(db_session)
-    return links_deleted, queue_deleted, scholars_reset, orphan_deleted
-
-
-def _result_payload(*, job: DataRepairJob, scope: dict[str, Any], summary: dict[str, Any]) -> dict[str, Any]:
-    return {
-        "job_id": int(job.id),
-        "status": job.status,
-        "scope": scope,
-        "summary": summary,
-    }
-
-
-async def _complete_job(
-    db_session: AsyncSession,
-    *,
-    job: DataRepairJob,
-    summary: dict[str, Any],
-    scope: dict[str, Any],
-) -> dict[str, Any]:
-    job.summary = summary
-    job.status = REPAIR_STATUS_COMPLETED
-    job.finished_at = _utcnow()
-    await db_session.commit()
-    return _result_payload(job=job, scope=scope, summary=summary)
-
-
-async def _fail_job(db_session: AsyncSession, *, job: DataRepairJob, error: Exception) -> None:
-    await db_session.rollback()
-    job.status = REPAIR_STATUS_FAILED
-    job.error_text = str(error)
-    job.finished_at = _utcnow()
-    db_session.add(job)
-    await db_session.commit()
-
-
-async def _prepare_repair_job(
-    db_session: AsyncSession,
-    *,
-    scope_mode: str,
-    user_id: int | None,
-    scholar_profile_ids: list[int] | None,
-    dry_run: bool,
-    gc_orphan_publications: bool,
-    requested_by: str | None,
-) -> tuple[int | None, list[int], dict[str, Any], DataRepairJob]:
-    normalized_scope = _normalize_scope_mode(scope_mode)
-    scope_user_id = _scope_user_id(scope_mode=normalized_scope, user_id=user_id)
-    target_ids = await _target_scholar_profile_ids(
-        db_session,
-        scope_mode=normalized_scope,
-        user_id=scope_user_id,
-        scholar_profile_ids=scholar_profile_ids,
-    )
-    scope = _scope_payload(
-        scope_mode=normalized_scope,
-        user_id=scope_user_id,
-        target_scholar_profile_ids=target_ids,
-        orphan_gc=gc_orphan_publications,
-    )
-    job = await _create_job(db_session, requested_by=requested_by, scope=scope, dry_run=dry_run)
-    job.status = REPAIR_STATUS_RUNNING
-    job.started_at = _utcnow()
-    return scope_user_id, target_ids, scope, job
-
-
-async def _build_repair_summary(
-    db_session: AsyncSession,
-    *,
-    scope_user_id: int | None,
-    target_ids: list[int],
-    dry_run: bool,
-    gc_orphan_publications: bool,
-) -> dict[str, Any]:
-    counts = await _count_scope(db_session, user_id=scope_user_id, target_scholar_profile_ids=target_ids)
-    orphan_before = await _count_orphan_publications(db_session)
-    links_deleted, queue_deleted, scholars_reset, orphan_deleted = await _mutation_counts(
-        db_session,
-        user_id=scope_user_id,
-        target_ids=target_ids,
-        dry_run=dry_run,
-        gc_orphan_publications=gc_orphan_publications,
-    )
-    return _job_summary(
-        counts=counts,
-        dry_run=dry_run,
-        links_deleted=links_deleted,
-        queue_items_deleted=queue_deleted,
-        scholars_reset=scholars_reset,
-        orphan_publications_before=orphan_before,
-        orphan_publications_deleted=orphan_deleted,
-    )
-
-
-async def run_publication_link_repair(
-    db_session: AsyncSession,
-    *,
-    scope_mode: str = SCOPE_MODE_SINGLE_USER,
-    user_id: int | None = None,
-    scholar_profile_ids: list[int] | None = None,
-    dry_run: bool = True,
-    gc_orphan_publications: bool = False,
-    requested_by: str | None = None,
-) -> dict[str, Any]:
-    scope_user_id, target_ids, scope, job = await _prepare_repair_job(
-        db_session,
-        scope_mode=scope_mode,
-        user_id=user_id,
-        scholar_profile_ids=scholar_profile_ids,
-        dry_run=dry_run,
-        gc_orphan_publications=gc_orphan_publications,
-        requested_by=requested_by,
-    )
-
-    try:
-        summary = await _build_repair_summary(
-            db_session,
-            scope_user_id=scope_user_id,
-            target_ids=target_ids,
-            dry_run=dry_run,
-            gc_orphan_publications=gc_orphan_publications,
-        )
-        return await _complete_job(db_session, job=job, summary=summary, scope=scope)
-    except Exception as exc:
-        await _fail_job(db_session, job=job, error=exc)
-        raise
diff --git a/build/lib/app/services/domains/dbops/integrity.py b/build/lib/app/services/domains/dbops/integrity.py
deleted file mode 100644
index 4d9c43c..0000000
--- a/build/lib/app/services/domains/dbops/integrity.py
+++ /dev/null
@@ -1,175 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timezone
-from typing import Any
-
-from sqlalchemy import func, select, text
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import Publication
-
-INTEGRITY_CHECK_DEFS = (
-    (
-        "legacy_cluster_id_format",
-        "warning",
-        "Publications with non-namespaced cluster IDs.",
-    ),
-    (
-        "negative_citation_count",
-        "failure",
-        "Publications with negative citation counts.",
-    ),
-    (
-        "orphan_publications",
-        "warning",
-        "Publications with no scholar links.",
-    ),
-    (
-        "orphan_scholar_publication_links",
-        "failure",
-        "Link rows missing parent scholar/publication.",
-    ),
-    (
-        "duplicate_fingerprint_keys",
-        "failure",
-        "Duplicate publication fingerprint keys.",
-    ),
-    (
-        "duplicate_cluster_ids",
-        "failure",
-        "Duplicate non-null publication cluster IDs.",
-    ),
-    (
-        "missing_pdf_url",
-        "metric",
-        "Publications without a resolved PDF URL.",
-    ),
-)
-
-
-async def _legacy_cluster_id_count(db_session: AsyncSession) -> int:
-    stmt = (
-        select(func.count())
-        .select_from(Publication)
-        .where(Publication.cluster_id.is_not(None))
-        .where(~Publication.cluster_id.like("cfv:%"))
-        .where(~Publication.cluster_id.like("cluster:%"))
-    )
-    result = await db_session.execute(stmt)
-    return int(result.scalar_one() or 0)
-
-
-async def _negative_citation_count(db_session: AsyncSession) -> int:
-    result = await db_session.execute(
-        select(func.count()).select_from(Publication).where(Publication.citation_count < 0)
-    )
-    return int(result.scalar_one() or 0)
-
-
-async def _missing_pdf_url_count(db_session: AsyncSession) -> int:
-    result = await db_session.execute(
-        select(func.count()).select_from(Publication).where(Publication.pdf_url.is_(None))
-    )
-    return int(result.scalar_one() or 0)
-
-
-async def _count_from_sql(db_session: AsyncSession, *, sql: str) -> int:
-    result = await db_session.execute(text(sql))
-    return int(result.scalar_one() or 0)
-
-
-def _issues_for_severity(*, checks: list[dict[str, Any]], severity: str) -> list[str]:
-    return [row["name"] for row in checks if row["severity"] == severity and row["count"] > 0]
-
-
-def _check_row(*, name: str, count: int, severity: str, message: str) -> dict[str, Any]:
-    return {
-        "name": name,
-        "count": int(count),
-        "severity": severity,
-        "message": message,
-    }
-
-
-async def _collect_counts(db_session: AsyncSession) -> dict[str, int]:
-    orphan_publications = await _count_from_sql(
-        db_session,
-        sql=(
-            "SELECT count(*) FROM publications p "
-            "LEFT JOIN scholar_publications sp ON sp.publication_id = p.id "
-            "WHERE sp.publication_id IS NULL"
-        ),
-    )
-    orphan_links = await _count_from_sql(
-        db_session,
-        sql=(
-            "SELECT count(*) FROM scholar_publications sp "
-            "LEFT JOIN publications p ON p.id = sp.publication_id "
-            "LEFT JOIN scholar_profiles s ON s.id = sp.scholar_profile_id "
-            "WHERE p.id IS NULL OR s.id IS NULL"
-        ),
-    )
-    duplicate_fingerprints = await _count_from_sql(
-        db_session,
-        sql=(
-            "SELECT count(*) FROM ("
-            "SELECT fingerprint_sha256 FROM publications "
-            "GROUP BY fingerprint_sha256 HAVING count(*) > 1"
-            ") dup"
-        ),
-    )
-    duplicate_cluster_ids = await _count_from_sql(
-        db_session,
-        sql=(
-            "SELECT count(*) FROM ("
-            "SELECT cluster_id FROM publications "
-            "WHERE cluster_id IS NOT NULL "
-            "GROUP BY cluster_id HAVING count(*) > 1"
-            ") dup"
-        ),
-    )
-    return {
-        "legacy_cluster_id_format": await _legacy_cluster_id_count(db_session),
-        "negative_citation_count": await _negative_citation_count(db_session),
-        "orphan_publications": orphan_publications,
-        "orphan_scholar_publication_links": orphan_links,
-        "duplicate_fingerprint_keys": duplicate_fingerprints,
-        "duplicate_cluster_ids": duplicate_cluster_ids,
-        "missing_pdf_url": await _missing_pdf_url_count(db_session),
-    }
-
-
-def _build_checks(*, counts: dict[str, int]) -> list[dict[str, Any]]:
-    return [
-        _check_row(
-            name=name,
-            count=counts[name],
-            severity=severity,
-            message=message,
-        )
-        for name, severity, message in INTEGRITY_CHECK_DEFS
-    ]
-
-
-def _status_from_issues(*, failures: list[str], warnings: list[str]) -> str:
-    status = "ok"
-    if failures:
-        status = "failed"
-    elif warnings:
-        status = "warning"
-    return status
-
-
-async def collect_integrity_report(db_session: AsyncSession) -> dict[str, Any]:
-    counts = await _collect_counts(db_session)
-    checks = _build_checks(counts=counts)
-    failures = _issues_for_severity(checks=checks, severity="failure")
-    warnings = _issues_for_severity(checks=checks, severity="warning")
-
-    return {
-        "status": _status_from_issues(failures=failures, warnings=warnings),
-        "checked_at": datetime.now(timezone.utc).isoformat(),
-        "failures": failures,
-        "warnings": warnings,
-        "checks": checks,
-    }
diff --git a/build/lib/app/services/domains/dbops/query.py b/build/lib/app/services/domains/dbops/query.py
deleted file mode 100644
index 2e95e31..0000000
--- a/build/lib/app/services/domains/dbops/query.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from __future__ import annotations
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import DataRepairJob
-
-
-def _bounded_limit(limit: int) -> int:
-    return max(1, min(int(limit), 200))
-
-
-async def list_repair_jobs(
-    db_session: AsyncSession,
-    *,
-    limit: int = 50,
-) -> list[DataRepairJob]:
-    bounded = _bounded_limit(limit)
-    result = await db_session.execute(
-        select(DataRepairJob).order_by(DataRepairJob.created_at.desc()).limit(bounded)
-    )
-    return list(result.scalars())
diff --git a/build/lib/app/services/domains/doi/normalize.py b/build/lib/app/services/domains/doi/normalize.py
deleted file mode 100644
index 4719cf3..0000000
--- a/build/lib/app/services/domains/doi/normalize.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-import re
-from urllib.parse import unquote
-
-DOI_RE = re.compile(r"10\.\d{4,9}/[-._;()/:A-Z0-9]+", re.I)
-
-
-def normalize_doi(value: str | None) -> str | None:
-    if not value:
-        return None
-    match = DOI_RE.search(unquote(value))
-    if not match:
-        return None
-    return match.group(0).rstrip(" .;,)").lower()
-
-
-def first_doi_from_texts(*values: str | None) -> str | None:
-    for value in values:
-        doi = normalize_doi(value)
-        if doi:
-            return doi
-    return None
diff --git a/build/lib/app/services/domains/ingestion/__init__.py b/build/lib/app/services/domains/ingestion/__init__.py
deleted file mode 100644
index 9d48db4..0000000
--- a/build/lib/app/services/domains/ingestion/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from __future__ import annotations
diff --git a/build/lib/app/services/domains/ingestion/application.py b/build/lib/app/services/domains/ingestion/application.py
deleted file mode 100644
index 63656b4..0000000
--- a/build/lib/app/services/domains/ingestion/application.py
+++ /dev/null
@@ -1,2413 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from datetime import datetime, timezone
-import hashlib
-import logging
-from typing import Any
-
-from sqlalchemy import select, text
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import (
-    CrawlRun,
-    Publication,
-    RunStatus,
-    RunTriggerType,
-    ScholarProfile,
-    ScholarPublication,
-)
-from app.services.domains.ingestion.constants import (
-    FAILED_STATES,
-    FAILURE_BUCKET_BLOCKED,
-    FAILURE_BUCKET_INGESTION,
-    FAILURE_BUCKET_LAYOUT,
-    FAILURE_BUCKET_NETWORK,
-    FAILURE_BUCKET_OTHER,
-    RESUMABLE_PARTIAL_REASON_PREFIXES,
-    RESUMABLE_PARTIAL_REASONS,
-    RUN_LOCK_NAMESPACE,
-)
-from app.services.domains.doi.normalize import first_doi_from_texts
-from app.services.domains.publication_identifiers import application as identifier_service
-from app.services.domains.ingestion.fingerprints import (
-    _build_body_excerpt,
-    _dedupe_publication_candidates,
-    _next_cstart_value,
-    build_initial_page_fingerprint,
-    build_publication_fingerprint,
-    build_publication_url,
-    normalize_title,
-)
-from app.services.domains.ingestion import queue as queue_service
-from app.services.domains.ingestion import safety as run_safety_service
-from app.services.domains.ingestion.types import (
-    PagedLoopState,
-    PagedParseResult,
-    RunAlertSummary,
-    RunAlreadyInProgressError,
-    RunBlockedBySafetyPolicyError,
-    RunExecutionSummary,
-    RunFailureSummary,
-    RunProgress,
-    ScholarProcessingOutcome,
-)
-from app.services.domains.settings import application as user_settings_service
-from app.services.domains.runs.events import run_events
-from app.services.domains.scholar.parser import (
-    ParseState,
-    ParsedProfilePage,
-    PublicationCandidate,
-    ScholarParserError,
-    parse_profile_page,
-)
-from app.services.domains.scholar.source import FetchResult, ScholarSource
-from app.settings import settings
-
-logger = logging.getLogger(__name__)
-
-
-def _int_or_default(value: Any, default: int = 0) -> int:
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        return default
-
-
-def _classify_failure_bucket(*, state: str, state_reason: str) -> str:
-    reason = state_reason.strip().lower()
-    normalized_state = state.strip().lower()
-
-    if normalized_state == ParseState.BLOCKED_OR_CAPTCHA.value or reason.startswith("blocked_"):
-        return FAILURE_BUCKET_BLOCKED
-    if normalized_state == ParseState.NETWORK_ERROR.value or reason.startswith("network_"):
-        return FAILURE_BUCKET_NETWORK
-    if normalized_state == ParseState.LAYOUT_CHANGED.value:
-        return FAILURE_BUCKET_LAYOUT
-    if normalized_state == "ingestion_error":
-        return FAILURE_BUCKET_INGESTION
-    return FAILURE_BUCKET_OTHER
-
-
-class ScholarIngestionService:
-    def __init__(self, *, source: ScholarSource) -> None:
-        self._source = source
-
-    @staticmethod
-    def _effective_request_delay_seconds(value: int) -> int:
-        policy_minimum = user_settings_service.resolve_request_delay_minimum(
-            settings.ingestion_min_request_delay_seconds
-        )
-        return max(policy_minimum, _int_or_default(value, policy_minimum))
-
-    @staticmethod
-    def _log_request_delay_coercion(
-        *,
-        user_id: int,
-        requested_request_delay_seconds: int,
-        effective_request_delay_seconds: int,
-    ) -> None:
-        logger.warning(
-            "ingestion.request_delay_coerced_to_policy_floor",
-            extra={
-                "event": "ingestion.request_delay_coerced_to_policy_floor",
-                "user_id": user_id,
-                "requested_request_delay_seconds": requested_request_delay_seconds,
-                "effective_request_delay_seconds": effective_request_delay_seconds,
-                "policy_minimum_request_delay_seconds": user_settings_service.resolve_request_delay_minimum(
-                    settings.ingestion_min_request_delay_seconds
-                ),
-                "metric_name": "ingestion_request_delay_coerced_total",
-                "metric_value": 1,
-            },
-        )
-
-    async def _load_user_settings_for_run(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_id: int,
-        trigger_type: RunTriggerType,
-    ):
-        user_settings = await user_settings_service.get_or_create_settings(
-            db_session,
-            user_id=user_id,
-        )
-        await self._enforce_safety_gate(
-            db_session,
-            user_settings=user_settings,
-            user_id=user_id,
-            trigger_type=trigger_type,
-        )
-        return user_settings
-
-    async def _enforce_safety_gate(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_settings,
-        user_id: int,
-        trigger_type: RunTriggerType,
-    ) -> None:
-        now_utc = datetime.now(timezone.utc)
-        previous = run_safety_service.get_safety_event_context(user_settings, now_utc=now_utc)
-        if run_safety_service.clear_expired_cooldown(user_settings, now_utc=now_utc):
-            await db_session.commit()
-            await db_session.refresh(user_settings)
-            logger.info(
-                "ingestion.safety_cooldown_cleared",
-                extra={
-                    "event": "ingestion.safety_cooldown_cleared",
-                    "user_id": user_id,
-                    "reason": previous.get("cooldown_reason"),
-                    "cooldown_until": previous.get("cooldown_until"),
-                    "metric_name": "ingestion_safety_cooldown_cleared_total",
-                    "metric_value": 1,
-                },
-            )
-            now_utc = datetime.now(timezone.utc)
-        if run_safety_service.is_cooldown_active(user_settings, now_utc=now_utc):
-            await self._raise_safety_blocked_start(
-                db_session,
-                user_settings=user_settings,
-                user_id=user_id,
-                trigger_type=trigger_type,
-                now_utc=now_utc,
-            )
-
-    async def _raise_safety_blocked_start(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_settings,
-        user_id: int,
-        trigger_type: RunTriggerType,
-        now_utc: datetime,
-    ) -> None:
-        safety_state = run_safety_service.register_cooldown_blocked_start(
-            user_settings,
-            now_utc=now_utc,
-        )
-        await db_session.commit()
-        logger.warning(
-            "ingestion.safety_policy_blocked_run_start",
-            extra={
-                "event": "ingestion.safety_policy_blocked_run_start",
-                "user_id": user_id,
-                "trigger_type": trigger_type.value,
-                "reason": safety_state.get("cooldown_reason"),
-                "cooldown_until": safety_state.get("cooldown_until"),
-                "cooldown_remaining_seconds": safety_state.get("cooldown_remaining_seconds"),
-                "blocked_start_count": ((safety_state.get("counters") or {}).get("blocked_start_count")),
-                "metric_name": "ingestion_safety_run_start_blocked_total",
-                "metric_value": 1,
-            },
-        )
-        raise RunBlockedBySafetyPolicyError(
-            code="scrape_cooldown_active",
-            message="Scrape safety cooldown is active; run start is temporarily blocked.",
-            safety_state=safety_state,
-        )
-
-    @staticmethod
-    def _normalize_run_targets(
-        *,
-        scholar_profile_ids: set[int] | None,
-        start_cstart_by_scholar_id: dict[int, int] | None,
-    ) -> tuple[set[int] | None, dict[int, int]]:
-        filtered_scholar_ids = (
-            {int(value) for value in scholar_profile_ids}
-            if scholar_profile_ids is not None
-            else None
-        )
-        start_cstart_map = {
-            int(key): max(0, int(value))
-            for key, value in (start_cstart_by_scholar_id or {}).items()
-        }
-        return filtered_scholar_ids, start_cstart_map
-
-    async def _load_target_scholars(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_id: int,
-        filtered_scholar_ids: set[int] | None,
-    ) -> list[ScholarProfile]:
-        scholars_stmt = (
-            select(ScholarProfile)
-            .where(ScholarProfile.user_id == user_id, ScholarProfile.is_enabled.is_(True))
-            .order_by(ScholarProfile.created_at.asc(), ScholarProfile.id.asc())
-        )
-        if filtered_scholar_ids is not None:
-            scholars_stmt = scholars_stmt.where(ScholarProfile.id.in_(filtered_scholar_ids))
-        scholars_result = await db_session.execute(scholars_stmt)
-        scholars = list(scholars_result.scalars().all())
-        await self._clear_missing_filtered_jobs(
-            db_session,
-            user_id=user_id,
-            filtered_scholar_ids=filtered_scholar_ids,
-            scholars=scholars,
-        )
-        return scholars
-
-    async def _clear_missing_filtered_jobs(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_id: int,
-        filtered_scholar_ids: set[int] | None,
-        scholars: list[ScholarProfile],
-    ) -> None:
-        if filtered_scholar_ids is None:
-            return
-        found_ids = {int(scholar.id) for scholar in scholars}
-        missing_ids = filtered_scholar_ids - found_ids
-        for scholar_profile_id in missing_ids:
-            await queue_service.clear_job_for_scholar(
-                db_session,
-                user_id=user_id,
-                scholar_profile_id=scholar_profile_id,
-            )
-
-    @staticmethod
-    def _create_running_run(
-        *,
-        user_id: int,
-        trigger_type: RunTriggerType,
-        scholar_count: int,
-        idempotency_key: str | None,
-    ) -> CrawlRun:
-        return CrawlRun(
-            user_id=user_id,
-            trigger_type=trigger_type,
-            status=RunStatus.RUNNING,
-            scholar_count=scholar_count,
-            new_pub_count=0,
-            idempotency_key=idempotency_key,
-            error_log={},
-        )
-
-    @staticmethod
-    def _log_run_started(
-        *,
-        user_id: int,
-        trigger_type: RunTriggerType,
-        scholar_count: int,
-        filtered: bool,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-        idempotency_key: str | None,
-        alert_blocked_failure_threshold: int,
-        alert_network_failure_threshold: int,
-        alert_retry_scheduled_threshold: int,
-    ) -> None:
-        logger.info(
-            "ingestion.run_started",
-            extra={
-                "event": "ingestion.run_started",
-                "user_id": user_id,
-                "trigger_type": trigger_type.value,
-                "scholar_count": scholar_count,
-                "is_filtered_run": filtered,
-                "request_delay_seconds": request_delay_seconds,
-                "network_error_retries": network_error_retries,
-                "retry_backoff_seconds": retry_backoff_seconds,
-                "max_pages_per_scholar": max_pages_per_scholar,
-                "page_size": page_size,
-                "idempotency_key": idempotency_key,
-                "alert_blocked_failure_threshold": alert_blocked_failure_threshold,
-                "alert_network_failure_threshold": alert_network_failure_threshold,
-                "alert_retry_scheduled_threshold": alert_retry_scheduled_threshold,
-            },
-        )
-
-    @staticmethod
-    async def _wait_between_scholars(*, index: int, request_delay_seconds: int) -> None:
-        if index <= 0 or request_delay_seconds <= 0:
-            return
-        await asyncio.sleep(float(request_delay_seconds))
-
-    @staticmethod
-    def _assert_valid_paged_parse_result(
-        *,
-        scholar_id: str,
-        paged_parse_result: PagedParseResult,
-    ) -> None:
-        parsed_page = paged_parse_result.parsed_page
-        if parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS}:
-            if any(code.startswith("layout_") for code in parsed_page.warnings):
-                raise RuntimeError(f"Layout warning marked as terminal for scholar_id={scholar_id}.")
-        for publication in paged_parse_result.publications:
-            if not publication.title.strip():
-                raise RuntimeError(f"Malformed publication title for scholar_id={scholar_id}.")
-            if publication.citation_count is not None and int(publication.citation_count) < 0:
-                raise RuntimeError(f"Negative citation count for scholar_id={scholar_id}.")
-
-    @staticmethod
-    def _apply_first_page_profile_metadata(
-        *,
-        scholar: ScholarProfile,
-        paged_parse_result: PagedParseResult,
-        run_dt: datetime,
-    ) -> None:
-        first_page = paged_parse_result.first_page_parsed_page
-        if first_page.profile_name and not (scholar.display_name or "").strip():
-            scholar.display_name = first_page.profile_name
-        if first_page.profile_image_url:
-            scholar.profile_image_url = first_page.profile_image_url
-        scholar.last_initial_page_checked_at = run_dt
-
-    @staticmethod
-    def _log_scholar_parsed(
-        *,
-        user_id: int,
-        run_id: int,
-        scholar: ScholarProfile,
-        paged_parse_result: PagedParseResult,
-    ) -> None:
-        parsed_page = paged_parse_result.parsed_page
-        logger.info(
-            "ingestion.scholar_parsed",
-            extra={
-                "event": "ingestion.scholar_parsed",
-                "user_id": user_id,
-                "crawl_run_id": run_id,
-                "scholar_profile_id": scholar.id,
-                "scholar_id": scholar.scholar_id,
-                "state": parsed_page.state.value,
-                "publication_count": len(paged_parse_result.publications),
-                "has_show_more_button": parsed_page.has_show_more_button,
-                "pages_fetched": paged_parse_result.pages_fetched,
-                "pages_attempted": paged_parse_result.pages_attempted,
-                "has_more_remaining": paged_parse_result.has_more_remaining,
-                "pagination_truncated_reason": paged_parse_result.pagination_truncated_reason,
-                "warning_count": len(parsed_page.warnings),
-                "skipped_no_change": paged_parse_result.skipped_no_change,
-            },
-        )
-
-    @staticmethod
-    def _build_result_entry(
-        *,
-        scholar: ScholarProfile,
-        start_cstart: int,
-        paged_parse_result: PagedParseResult,
-    ) -> dict[str, Any]:
-        parsed_page = paged_parse_result.parsed_page
-        return {
-            "scholar_profile_id": scholar.id,
-            "scholar_id": scholar.scholar_id,
-            "state": parsed_page.state.value,
-            "state_reason": parsed_page.state_reason,
-            "outcome": "failed",
-            "attempt_count": len(paged_parse_result.attempt_log),
-            "publication_count": len(paged_parse_result.publications),
-            "start_cstart": start_cstart,
-            "articles_range": parsed_page.articles_range,
-            "warnings": parsed_page.warnings,
-            "has_show_more_button": parsed_page.has_show_more_button,
-            "pages_fetched": paged_parse_result.pages_fetched,
-            "pages_attempted": paged_parse_result.pages_attempted,
-            "has_more_remaining": paged_parse_result.has_more_remaining,
-            "pagination_truncated_reason": paged_parse_result.pagination_truncated_reason,
-            "continuation_cstart": paged_parse_result.continuation_cstart,
-            "skipped_no_change": paged_parse_result.skipped_no_change,
-            "initial_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
-        }
-
-    def _skipped_no_change_outcome(
-        self,
-        *,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-    ) -> ScholarProcessingOutcome:
-        first_page = paged_parse_result.first_page_parsed_page
-        scholar.last_run_status = RunStatus.SUCCESS
-        scholar.last_run_dt = run_dt
-        result_entry["state"] = first_page.state.value
-        result_entry["state_reason"] = "no_change_initial_page_signature"
-        result_entry["outcome"] = "success"
-        result_entry["publication_count"] = 0
-        result_entry["warnings"] = first_page.warnings
-        result_entry["debug"] = {
-            "state_reason": "no_change_initial_page_signature",
-            "first_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
-            "attempt_log": paged_parse_result.attempt_log,
-            "page_logs": paged_parse_result.page_logs,
-        }
-        return ScholarProcessingOutcome(
-            result_entry=result_entry,
-            succeeded_count_delta=1,
-            failed_count_delta=0,
-            partial_count_delta=0,
-            discovered_publication_count=0,
-        )
-
-    async def _upsert_publications_outcome(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-    ) -> ScholarProcessingOutcome:
-        parsed_page = paged_parse_result.parsed_page
-        publications = paged_parse_result.publications
-        had_page_failure = parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}
-        has_partial_set = len(publications) > 0 and had_page_failure
-        if (not had_page_failure) or has_partial_set:
-            return await self._upsert_success_or_exception(
-                db_session,
-                run=run,
-                scholar=scholar,
-                run_dt=run_dt,
-                paged_parse_result=paged_parse_result,
-                result_entry=result_entry,
-                has_partial_publication_set=has_partial_set,
-            )
-        return self._parse_failure_outcome(
-            scholar=scholar,
-            run_dt=run_dt,
-            paged_parse_result=paged_parse_result,
-            result_entry=result_entry,
-        )
-
-    async def _upsert_success_or_exception(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-        has_partial_publication_set: bool,
-    ) -> ScholarProcessingOutcome:
-        try:
-            return await self._upsert_success(
-                db_session,
-                run=run,
-                scholar=scholar,
-                run_dt=run_dt,
-                paged_parse_result=paged_parse_result,
-                result_entry=result_entry,
-                has_partial_publication_set=has_partial_publication_set,
-            )
-        except Exception as exc:
-            return self._upsert_exception_outcome(
-                run=run,
-                scholar=scholar,
-                run_dt=run_dt,
-                paged_parse_result=paged_parse_result,
-                result_entry=result_entry,
-                exc=exc,
-            )
-
-    async def _upsert_success(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-        has_partial_publication_set: bool,
-    ) -> ScholarProcessingOutcome:
-        # We no longer aggregate and upsert the publications here.
-        # Eager DB insertions have already saved and committed them inside `_fetch_and_parse_all_pages_with_retry` and `_paginate_loop`.
-        discovered_count = paged_parse_result.discovered_publication_count
-        is_partial = (
-            paged_parse_result.has_more_remaining
-            or paged_parse_result.pagination_truncated_reason is not None
-            or has_partial_publication_set
-        )
-        scholar.last_run_status = RunStatus.PARTIAL_FAILURE if is_partial else RunStatus.SUCCESS
-        scholar.last_run_dt = run_dt
-        if not is_partial and paged_parse_result.first_page_fingerprint_sha256:
-            scholar.last_initial_page_fingerprint_sha256 = paged_parse_result.first_page_fingerprint_sha256
-        result_entry["outcome"] = "partial" if is_partial else "success"
-        if is_partial:
-            result_entry["debug"] = self._build_failure_debug_context(
-                fetch_result=paged_parse_result.fetch_result,
-                parsed_page=paged_parse_result.parsed_page,
-                attempt_log=paged_parse_result.attempt_log,
-                page_logs=paged_parse_result.page_logs,
-            )
-        return ScholarProcessingOutcome(
-            result_entry=result_entry,
-            succeeded_count_delta=1,
-            failed_count_delta=0,
-            partial_count_delta=1 if is_partial else 0,
-            discovered_publication_count=discovered_count,
-        )
-
-    def _upsert_exception_outcome(
-        self,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-        exc: Exception,
-    ) -> ScholarProcessingOutcome:
-        scholar.last_run_status = RunStatus.FAILED
-        scholar.last_run_dt = run_dt
-        result_entry["state"] = "ingestion_error"
-        result_entry["state_reason"] = "publication_upsert_exception"
-        result_entry["outcome"] = "failed"
-        result_entry["error"] = str(exc)
-        result_entry["debug"] = self._build_failure_debug_context(
-            fetch_result=paged_parse_result.fetch_result,
-            parsed_page=paged_parse_result.parsed_page,
-            attempt_log=paged_parse_result.attempt_log,
-            page_logs=paged_parse_result.page_logs,
-            exception=exc,
-        )
-        logger.exception(
-            "ingestion.scholar_failed",
-            extra={
-                "event": "ingestion.scholar_failed",
-                "crawl_run_id": run.id,
-                "scholar_profile_id": scholar.id,
-                "scholar_id": scholar.scholar_id,
-            },
-        )
-        return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
-
-    def _parse_failure_outcome(
-        self,
-        *,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-    ) -> ScholarProcessingOutcome:
-        scholar.last_run_status = RunStatus.FAILED
-        scholar.last_run_dt = run_dt
-        result_entry["debug"] = self._build_failure_debug_context(
-            fetch_result=paged_parse_result.fetch_result,
-            parsed_page=paged_parse_result.parsed_page,
-            attempt_log=paged_parse_result.attempt_log,
-            page_logs=paged_parse_result.page_logs,
-        )
-        logger.warning(
-            "ingestion.scholar_parse_failed",
-            extra={
-                "event": "ingestion.scholar_parse_failed",
-                "scholar_profile_id": scholar.id,
-                "scholar_id": scholar.scholar_id,
-                "state": paged_parse_result.parsed_page.state.value,
-                "state_reason": paged_parse_result.parsed_page.state_reason,
-                "status_code": paged_parse_result.fetch_result.status_code,
-            },
-        )
-        return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
-
-    async def _sync_continuation_queue(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_id: int,
-        scholar: ScholarProfile,
-        run: CrawlRun,
-        start_cstart: int,
-        result_entry: dict[str, Any],
-        paged_parse_result: PagedParseResult,
-        auto_queue_continuations: bool,
-        queue_delay_seconds: int,
-    ) -> None:
-        queue_reason, queue_cstart = self._resolve_continuation_queue_target(
-            outcome=str(result_entry.get("outcome", "")),
-            state=str(result_entry.get("state", "")),
-            pagination_truncated_reason=paged_parse_result.pagination_truncated_reason,
-            continuation_cstart=paged_parse_result.continuation_cstart,
-            fallback_cstart=start_cstart,
-        )
-        if auto_queue_continuations and queue_reason is not None:
-            await queue_service.upsert_job(
-                db_session,
-                user_id=user_id,
-                scholar_profile_id=scholar.id,
-                resume_cstart=queue_cstart,
-                reason=queue_reason,
-                run_id=run.id,
-                delay_seconds=queue_delay_seconds,
-            )
-            result_entry["continuation_enqueued"] = True
-            result_entry["continuation_reason"] = queue_reason
-            result_entry["continuation_cstart"] = queue_cstart
-            return
-        if await queue_service.clear_job_for_scholar(db_session, user_id=user_id, scholar_profile_id=scholar.id):
-            result_entry["continuation_cleared"] = True
-
-    async def _process_scholar(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        user_id: int,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-        start_cstart: int,
-        auto_queue_continuations: bool,
-        queue_delay_seconds: int,
-    ) -> ScholarProcessingOutcome:
-        try:
-            return await self._process_scholar_inner(
-                db_session,
-                run=run,
-                scholar=scholar,
-                user_id=user_id,
-                request_delay_seconds=request_delay_seconds,
-                network_error_retries=network_error_retries,
-                retry_backoff_seconds=retry_backoff_seconds,
-                rate_limit_retries=rate_limit_retries,
-                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-                max_pages_per_scholar=max_pages_per_scholar,
-                page_size=page_size,
-                start_cstart=start_cstart,
-                auto_queue_continuations=auto_queue_continuations,
-                queue_delay_seconds=queue_delay_seconds,
-            )
-        except Exception as exc:
-            return self._unexpected_scholar_exception_outcome(
-                run=run,
-                scholar=scholar,
-                start_cstart=start_cstart,
-                exc=exc,
-            )
-
-    async def _process_scholar_inner(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        user_id: int,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-        start_cstart: int,
-        auto_queue_continuations: bool,
-        queue_delay_seconds: int,
-    ) -> ScholarProcessingOutcome:
-        run_dt, paged_parse_result, result_entry = await self._fetch_and_prepare_scholar_result(
-            db_session,
-            run=run,
-            scholar=scholar,
-            user_id=user_id,
-            start_cstart=start_cstart,
-            request_delay_seconds=request_delay_seconds,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-            max_pages_per_scholar=max_pages_per_scholar,
-            page_size=page_size,
-        )
-        outcome = await self._resolve_scholar_outcome(
-            db_session,
-            run=run,
-            scholar=scholar,
-            run_dt=run_dt,
-            paged_parse_result=paged_parse_result,
-            result_entry=result_entry,
-        )
-        await self._sync_continuation_queue(
-            db_session,
-            user_id=user_id,
-            scholar=scholar,
-            run=run,
-            start_cstart=start_cstart,
-            result_entry=outcome.result_entry,
-            paged_parse_result=paged_parse_result,
-            auto_queue_continuations=auto_queue_continuations,
-            queue_delay_seconds=queue_delay_seconds,
-        )
-        return outcome
-
-    async def _fetch_and_prepare_scholar_result(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        user_id: int,
-        start_cstart: int,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-    ) -> tuple[datetime, PagedParseResult, dict[str, Any]]:
-        run_dt = datetime.now(timezone.utc)
-        paged_parse_result = await self._fetch_and_parse_all_pages_with_retry(
-            scholar=scholar,
-            run=run,
-            db_session=db_session,
-            start_cstart=start_cstart,
-            request_delay_seconds=request_delay_seconds,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-            max_pages=max_pages_per_scholar,
-            page_size=page_size,
-            previous_initial_page_fingerprint_sha256=scholar.last_initial_page_fingerprint_sha256,
-        )
-        self._assert_valid_paged_parse_result(scholar_id=scholar.scholar_id, paged_parse_result=paged_parse_result)
-        self._apply_first_page_profile_metadata(scholar=scholar, paged_parse_result=paged_parse_result, run_dt=run_dt)
-        self._log_scholar_parsed(user_id=user_id, run_id=run.id, scholar=scholar, paged_parse_result=paged_parse_result)
-        result_entry = self._build_result_entry(
-            scholar=scholar,
-            start_cstart=start_cstart,
-            paged_parse_result=paged_parse_result,
-        )
-        return run_dt, paged_parse_result, result_entry
-
-    async def _resolve_scholar_outcome(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-    ) -> ScholarProcessingOutcome:
-        if paged_parse_result.skipped_no_change:
-            return self._skipped_no_change_outcome(
-                scholar=scholar,
-                run_dt=run_dt,
-                paged_parse_result=paged_parse_result,
-                result_entry=result_entry,
-            )
-        return await self._upsert_publications_outcome(
-            db_session,
-            run=run,
-            scholar=scholar,
-            run_dt=run_dt,
-            paged_parse_result=paged_parse_result,
-            result_entry=result_entry,
-        )
-
-    @staticmethod
-    def _apply_outcome_to_progress(
-        *,
-        progress: RunProgress,
-        run: CrawlRun,
-        outcome: ScholarProcessingOutcome,
-    ) -> None:
-        progress.succeeded_count += outcome.succeeded_count_delta
-        progress.failed_count += outcome.failed_count_delta
-        progress.partial_count += outcome.partial_count_delta
-        run.new_pub_count = int(run.new_pub_count or 0) + outcome.discovered_publication_count
-        progress.scholar_results.append(outcome.result_entry)
-
-    def _unexpected_scholar_exception_outcome(
-        self,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        start_cstart: int,
-        exc: Exception,
-    ) -> ScholarProcessingOutcome:
-        scholar.last_run_status = RunStatus.FAILED
-        scholar.last_run_dt = datetime.now(timezone.utc)
-        logger.exception(
-            "ingestion.scholar_unexpected_failure",
-            extra={
-                "event": "ingestion.scholar_unexpected_failure",
-                "crawl_run_id": run.id,
-                "scholar_profile_id": scholar.id,
-                "scholar_id": scholar.scholar_id,
-            },
-        )
-        return ScholarProcessingOutcome(
-            result_entry={
-                "scholar_profile_id": scholar.id,
-                "scholar_id": scholar.scholar_id,
-                "state": "ingestion_error",
-                "state_reason": "scholar_processing_exception",
-                "outcome": "failed",
-                "attempt_count": 0,
-                "publication_count": 0,
-                "start_cstart": start_cstart,
-                "warnings": [],
-                "error": str(exc),
-                "debug": {"exception_type": type(exc).__name__, "exception_message": str(exc)},
-            },
-            succeeded_count_delta=0,
-            failed_count_delta=1,
-            partial_count_delta=0,
-            discovered_publication_count=0,
-        )
-
-    @staticmethod
-    def _summarize_failures(
-        *,
-        scholar_results: list[dict[str, Any]],
-    ) -> RunFailureSummary:
-        failed_state_counts: dict[str, int] = {}
-        failed_reason_counts: dict[str, int] = {}
-        scrape_failure_counts: dict[str, int] = {}
-        retries_scheduled_count = 0
-        scholars_with_retries_count = 0
-        retry_exhausted_count = 0
-        for entry in scholar_results:
-            retries_for_entry = max(0, _int_or_default(entry.get("attempt_count"), 0) - 1)
-            if retries_for_entry > 0:
-                retries_scheduled_count += retries_for_entry
-                scholars_with_retries_count += 1
-            if str(entry.get("outcome", "")) != "failed":
-                continue
-            state = str(entry.get("state", "")).strip()
-            if state not in FAILED_STATES:
-                continue
-            failed_state_counts[state] = failed_state_counts.get(state, 0) + 1
-            reason = str(entry.get("state_reason", "")).strip()
-            if reason:
-                failed_reason_counts[reason] = failed_reason_counts.get(reason, 0) + 1
-            bucket = _classify_failure_bucket(state=state, state_reason=reason)
-            scrape_failure_counts[bucket] = scrape_failure_counts.get(bucket, 0) + 1
-            if state == ParseState.NETWORK_ERROR.value and retries_for_entry > 0:
-                retry_exhausted_count += 1
-        return RunFailureSummary(
-            failed_state_counts=failed_state_counts,
-            failed_reason_counts=failed_reason_counts,
-            scrape_failure_counts=scrape_failure_counts,
-            retries_scheduled_count=retries_scheduled_count,
-            scholars_with_retries_count=scholars_with_retries_count,
-            retry_exhausted_count=retry_exhausted_count,
-        )
-
-    @staticmethod
-    def _build_alert_summary(
-        *,
-        failure_summary: RunFailureSummary,
-        alert_blocked_failure_threshold: int,
-        alert_network_failure_threshold: int,
-        alert_retry_scheduled_threshold: int,
-    ) -> RunAlertSummary:
-        blocked_failure_count = int(failure_summary.scrape_failure_counts.get(FAILURE_BUCKET_BLOCKED, 0))
-        network_failure_count = int(failure_summary.scrape_failure_counts.get(FAILURE_BUCKET_NETWORK, 0))
-        blocked_threshold = max(1, int(alert_blocked_failure_threshold))
-        network_threshold = max(1, int(alert_network_failure_threshold))
-        retry_threshold = max(1, int(alert_retry_scheduled_threshold))
-        alert_flags = {
-            "blocked_failure_threshold_exceeded": blocked_failure_count >= blocked_threshold,
-            "network_failure_threshold_exceeded": network_failure_count >= network_threshold,
-            "retry_scheduled_threshold_exceeded": failure_summary.retries_scheduled_count >= retry_threshold,
-        }
-        return RunAlertSummary(
-            blocked_failure_count=blocked_failure_count,
-            network_failure_count=network_failure_count,
-            blocked_failure_threshold=blocked_threshold,
-            network_failure_threshold=network_threshold,
-            retry_scheduled_threshold=retry_threshold,
-            alert_flags=alert_flags,
-        )
-
-    @staticmethod
-    def _log_alert_thresholds(
-        *,
-        user_id: int,
-        run_id: int,
-        failure_summary: RunFailureSummary,
-        alert_summary: RunAlertSummary,
-    ) -> None:
-        if alert_summary.alert_flags["blocked_failure_threshold_exceeded"]:
-            logger.warning(
-                "ingestion.alert_blocked_failure_threshold_exceeded",
-                extra={
-                    "event": "ingestion.alert_blocked_failure_threshold_exceeded",
-                    "user_id": user_id,
-                    "crawl_run_id": run_id,
-                    "blocked_failure_count": alert_summary.blocked_failure_count,
-                    "threshold": alert_summary.blocked_failure_threshold,
-                    "metric_name": "ingestion_blocked_failure_threshold_exceeded_total",
-                    "metric_value": 1,
-                },
-            )
-        if alert_summary.alert_flags["network_failure_threshold_exceeded"]:
-            logger.warning(
-                "ingestion.alert_network_failure_threshold_exceeded",
-                extra={
-                    "event": "ingestion.alert_network_failure_threshold_exceeded",
-                    "user_id": user_id,
-                    "crawl_run_id": run_id,
-                    "network_failure_count": alert_summary.network_failure_count,
-                    "threshold": alert_summary.network_failure_threshold,
-                    "metric_name": "ingestion_network_failure_threshold_exceeded_total",
-                    "metric_value": 1,
-                },
-            )
-        if alert_summary.alert_flags["retry_scheduled_threshold_exceeded"]:
-            logger.warning(
-                "ingestion.alert_retry_scheduled_threshold_exceeded",
-                extra={
-                    "event": "ingestion.alert_retry_scheduled_threshold_exceeded",
-                    "user_id": user_id,
-                    "crawl_run_id": run_id,
-                    "retries_scheduled_count": failure_summary.retries_scheduled_count,
-                    "threshold": alert_summary.retry_scheduled_threshold,
-                    "metric_name": "ingestion_retry_scheduled_threshold_exceeded_total",
-                    "metric_value": 1,
-                },
-            )
-
-    @staticmethod
-    def _apply_safety_outcome(
-        *,
-        user_settings,
-        run: CrawlRun,
-        user_id: int,
-        alert_summary: RunAlertSummary,
-    ) -> None:
-        pre_apply_state = run_safety_service.get_safety_event_context(
-            user_settings,
-            now_utc=datetime.now(timezone.utc),
-        )
-        safety_state, cooldown_trigger_reason = run_safety_service.apply_run_safety_outcome(
-            user_settings,
-            run_id=int(run.id),
-            blocked_failure_count=alert_summary.blocked_failure_count,
-            network_failure_count=alert_summary.network_failure_count,
-            blocked_failure_threshold=alert_summary.blocked_failure_threshold,
-            network_failure_threshold=alert_summary.network_failure_threshold,
-            blocked_cooldown_seconds=settings.ingestion_safety_cooldown_blocked_seconds,
-            network_cooldown_seconds=settings.ingestion_safety_cooldown_network_seconds,
-            now_utc=datetime.now(timezone.utc),
-        )
-        ScholarIngestionService._log_safety_transition(
-            user_id=user_id,
-            run_id=int(run.id),
-            alert_summary=alert_summary,
-            pre_apply_state=pre_apply_state,
-            safety_state=safety_state,
-            cooldown_trigger_reason=cooldown_trigger_reason,
-        )
-
-    @staticmethod
-    def _log_safety_transition(
-        *,
-        user_id: int,
-        run_id: int,
-        alert_summary: RunAlertSummary,
-        pre_apply_state: dict[str, Any],
-        safety_state: dict[str, Any],
-        cooldown_trigger_reason: str | None,
-    ) -> None:
-        if cooldown_trigger_reason is not None:
-            logger.warning(
-                "ingestion.safety_cooldown_entered",
-                extra={
-                    "event": "ingestion.safety_cooldown_entered",
-                    "user_id": user_id,
-                    "crawl_run_id": run_id,
-                    "reason": cooldown_trigger_reason,
-                    "blocked_failure_count": alert_summary.blocked_failure_count,
-                    "network_failure_count": alert_summary.network_failure_count,
-                    "blocked_failure_threshold": alert_summary.blocked_failure_threshold,
-                    "network_failure_threshold": alert_summary.network_failure_threshold,
-                    "cooldown_until": safety_state.get("cooldown_until"),
-                    "cooldown_remaining_seconds": safety_state.get("cooldown_remaining_seconds"),
-                    "safety_counters": safety_state.get("counters", {}),
-                    "metric_name": "ingestion_safety_cooldown_entered_total",
-                    "metric_value": 1,
-                },
-            )
-        elif pre_apply_state.get("cooldown_active") and not safety_state.get("cooldown_active"):
-            logger.info(
-                "ingestion.safety_cooldown_cleared",
-                extra={
-                    "event": "ingestion.safety_cooldown_cleared",
-                    "user_id": user_id,
-                    "crawl_run_id": run_id,
-                    "reason": pre_apply_state.get("cooldown_reason"),
-                    "cooldown_until": pre_apply_state.get("cooldown_until"),
-                    "metric_name": "ingestion_safety_cooldown_cleared_total",
-                    "metric_value": 1,
-                },
-            )
-
-    def _finalize_run_record(
-        self,
-        *,
-        run: CrawlRun,
-        scholars: list[ScholarProfile],
-        progress: RunProgress,
-        failure_summary: RunFailureSummary,
-        alert_summary: RunAlertSummary,
-        idempotency_key: str | None,
-    ) -> None:
-        run.end_dt = datetime.now(timezone.utc)
-        if run.status != RunStatus.CANCELED:
-            run.status = self._resolve_run_status(
-                scholar_count=len(scholars),
-                succeeded_count=progress.succeeded_count,
-                failed_count=progress.failed_count,
-                partial_count=progress.partial_count,
-            )
-        run.error_log = {
-            "scholar_results": progress.scholar_results,
-            "summary": {
-                "succeeded_count": progress.succeeded_count,
-                "failed_count": progress.failed_count,
-                "partial_count": progress.partial_count,
-                "failed_state_counts": failure_summary.failed_state_counts,
-                "failed_reason_counts": failure_summary.failed_reason_counts,
-                "scrape_failure_counts": failure_summary.scrape_failure_counts,
-                "retry_counts": {
-                    "retries_scheduled_count": failure_summary.retries_scheduled_count,
-                    "scholars_with_retries_count": failure_summary.scholars_with_retries_count,
-                    "retry_exhausted_count": failure_summary.retry_exhausted_count,
-                },
-                "alert_thresholds": {
-                    "blocked_failure_threshold": alert_summary.blocked_failure_threshold,
-                    "network_failure_threshold": alert_summary.network_failure_threshold,
-                    "retry_scheduled_threshold": alert_summary.retry_scheduled_threshold,
-                },
-                "alert_flags": alert_summary.alert_flags,
-            },
-            "meta": {"idempotency_key": idempotency_key} if idempotency_key else {},
-        }
-
-    @staticmethod
-    def _log_run_completed(
-        *,
-        user_id: int,
-        run: CrawlRun,
-        scholars: list[ScholarProfile],
-        progress: RunProgress,
-        alert_summary: RunAlertSummary,
-        failure_summary: RunFailureSummary,
-    ) -> None:
-        logger.info(
-            "ingestion.run_completed",
-            extra={
-                "event": "ingestion.run_completed",
-                "user_id": user_id,
-                "crawl_run_id": run.id,
-                "status": run.status.value,
-                "scholar_count": len(scholars),
-                "succeeded_count": progress.succeeded_count,
-                "failed_count": progress.failed_count,
-                "partial_count": progress.partial_count,
-                "new_publication_count": run.new_pub_count,
-                "blocked_failure_count": alert_summary.blocked_failure_count,
-                "network_failure_count": alert_summary.network_failure_count,
-                "retries_scheduled_count": failure_summary.retries_scheduled_count,
-                "alert_flags": alert_summary.alert_flags,
-            },
-        )
-
-    @staticmethod
-    def _paging_kwargs(
-        *,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-    ) -> dict[str, Any]:
-        return {
-            "request_delay_seconds": request_delay_seconds,
-            "network_error_retries": network_error_retries,
-            "retry_backoff_seconds": retry_backoff_seconds,
-            "rate_limit_retries": rate_limit_retries,
-            "rate_limit_backoff_seconds": rate_limit_backoff_seconds,
-            "max_pages_per_scholar": max_pages_per_scholar,
-            "page_size": page_size,
-        }
-
-    @staticmethod
-    def _threshold_kwargs(
-        *,
-        alert_blocked_failure_threshold: int,
-        alert_network_failure_threshold: int,
-        alert_retry_scheduled_threshold: int,
-    ) -> dict[str, Any]:
-        return {
-            "alert_blocked_failure_threshold": alert_blocked_failure_threshold,
-            "alert_network_failure_threshold": alert_network_failure_threshold,
-            "alert_retry_scheduled_threshold": alert_retry_scheduled_threshold,
-        }
-
-    @staticmethod
-    def _run_execution_summary(
-        *,
-        run: CrawlRun,
-        scholars: list[ScholarProfile],
-        progress: RunProgress,
-    ) -> RunExecutionSummary:
-        return RunExecutionSummary(
-            crawl_run_id=run.id,
-            status=run.status,
-            scholar_count=len(scholars),
-            succeeded_count=progress.succeeded_count,
-            failed_count=progress.failed_count,
-            partial_count=progress.partial_count,
-            new_publication_count=run.new_pub_count,
-        )
-
-    async def _initialize_run_for_user(self, db_session: AsyncSession, *, user_id: int, trigger_type: RunTriggerType, scholar_profile_ids: set[int] | None, start_cstart_by_scholar_id: dict[int, int] | None, request_delay_seconds: int, network_error_retries: int, retry_backoff_seconds: float, rate_limit_retries: int, rate_limit_backoff_seconds: float, max_pages_per_scholar: int, page_size: int, idempotency_key: str | None, alert_blocked_failure_threshold: int, alert_network_failure_threshold: int, alert_retry_scheduled_threshold: int) -> tuple[Any, CrawlRun, list[ScholarProfile], dict[int, int]]:
-        user_settings = await self._load_user_settings_for_run(
-            db_session,
-            user_id=user_id,
-            trigger_type=trigger_type,
-        )
-        if not await self._try_acquire_user_lock(db_session, user_id=user_id):
-            raise RunAlreadyInProgressError(f"Run already in progress for user_id={user_id}.")
-        filtered_scholar_ids, start_cstart_map = self._normalize_run_targets(
-            scholar_profile_ids=scholar_profile_ids,
-            start_cstart_by_scholar_id=start_cstart_by_scholar_id,
-        )
-        scholars = await self._load_target_scholars(
-            db_session,
-            user_id=user_id,
-            filtered_scholar_ids=filtered_scholar_ids,
-        )
-        run = await self._start_run_record_for_targets(
-            db_session,
-            user_id=user_id,
-            trigger_type=trigger_type,
-            scholars=scholars,
-            filtered=filtered_scholar_ids is not None,
-            request_delay_seconds=request_delay_seconds,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            max_pages_per_scholar=max_pages_per_scholar,
-            page_size=page_size,
-            idempotency_key=idempotency_key,
-            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
-            alert_network_failure_threshold=alert_network_failure_threshold,
-            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
-        )
-        return user_settings, run, scholars, start_cstart_map
-
-    async def _start_run_record_for_targets(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_id: int,
-        trigger_type: RunTriggerType,
-        scholars: list[ScholarProfile],
-        filtered: bool,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-        idempotency_key: str | None,
-        alert_blocked_failure_threshold: int,
-        alert_network_failure_threshold: int,
-        alert_retry_scheduled_threshold: int,
-    ) -> CrawlRun:
-        self._log_run_started(
-            user_id=user_id,
-            trigger_type=trigger_type,
-            scholar_count=len(scholars),
-            filtered=filtered,
-            request_delay_seconds=request_delay_seconds,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            max_pages_per_scholar=max_pages_per_scholar,
-            page_size=page_size,
-            idempotency_key=idempotency_key,
-            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
-            alert_network_failure_threshold=alert_network_failure_threshold,
-            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
-        )
-        run = self._create_running_run(
-            user_id=user_id,
-            trigger_type=trigger_type,
-            scholar_count=len(scholars),
-            idempotency_key=idempotency_key,
-        )
-        db_session.add(run)
-        await db_session.flush()
-        return run
-
-    async def _run_scholar_iteration(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholars: list[ScholarProfile],
-        user_id: int,
-        start_cstart_map: dict[int, int],
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-        auto_queue_continuations: bool,
-        queue_delay_seconds: int,
-    ) -> RunProgress:
-        from app.db.models import RunStatus
-
-        progress = RunProgress()
-        for index, scholar in enumerate(scholars):
-            await db_session.refresh(run)
-            if run.status == RunStatus.CANCELED:
-                logger.info(
-                    "ingestion.run_canceled",
-                    extra={"event": "ingestion.run_canceled", "run_id": run.id, "user_id": user_id},
-                )
-                break
-            await self._wait_between_scholars(index=index, request_delay_seconds=request_delay_seconds)
-            start_cstart = int(start_cstart_map.get(int(scholar.id), 0))
-            outcome = await self._process_scholar(
-                db_session,
-                run=run,
-                scholar=scholar,
-                user_id=user_id,
-                request_delay_seconds=request_delay_seconds,
-                network_error_retries=network_error_retries,
-                retry_backoff_seconds=retry_backoff_seconds,
-                rate_limit_retries=rate_limit_retries,
-                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-                max_pages_per_scholar=max_pages_per_scholar,
-                page_size=page_size,
-                start_cstart=start_cstart,
-                auto_queue_continuations=auto_queue_continuations,
-                queue_delay_seconds=queue_delay_seconds,
-            )
-            self._apply_outcome_to_progress(progress=progress, run=run, outcome=outcome)
-        return progress
-
-    def _complete_run_for_user(
-        self,
-        *,
-        user_settings: Any,
-        run: CrawlRun,
-        scholars: list[ScholarProfile],
-        user_id: int,
-        progress: RunProgress,
-        idempotency_key: str | None,
-        alert_blocked_failure_threshold: int,
-        alert_network_failure_threshold: int,
-        alert_retry_scheduled_threshold: int,
-    ) -> tuple[RunFailureSummary, RunAlertSummary]:
-        failure_summary = self._summarize_failures(scholar_results=progress.scholar_results)
-        alert_summary = self._build_alert_summary(
-            failure_summary=failure_summary,
-            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
-            alert_network_failure_threshold=alert_network_failure_threshold,
-            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
-        )
-        self._log_alert_thresholds(
-            user_id=user_id,
-            run_id=int(run.id),
-            failure_summary=failure_summary,
-            alert_summary=alert_summary,
-        )
-        self._apply_safety_outcome(user_settings=user_settings, run=run, user_id=user_id, alert_summary=alert_summary)
-        self._finalize_run_record(
-            run=run,
-            scholars=scholars,
-            progress=progress,
-            failure_summary=failure_summary,
-            alert_summary=alert_summary,
-            idempotency_key=idempotency_key,
-        )
-        return failure_summary, alert_summary
-
-    async def run_for_user(self, db_session: AsyncSession, *, user_id: int, trigger_type: RunTriggerType, request_delay_seconds: int, network_error_retries: int = 1, retry_backoff_seconds: float = 1.0, max_pages_per_scholar: int = 30, page_size: int = 100, scholar_profile_ids: set[int] | None = None, start_cstart_by_scholar_id: dict[int, int] | None = None, auto_queue_continuations: bool = True, queue_delay_seconds: int = 60, idempotency_key: str | None = None, alert_blocked_failure_threshold: int = 1, alert_network_failure_threshold: int = 2, alert_retry_scheduled_threshold: int = 3) -> RunExecutionSummary:
-        effective_request_delay_seconds = self._effective_request_delay_seconds(request_delay_seconds)
-        if effective_request_delay_seconds != _int_or_default(request_delay_seconds, effective_request_delay_seconds):
-            self._log_request_delay_coercion(
-                user_id=user_id,
-                requested_request_delay_seconds=_int_or_default(request_delay_seconds, 0),
-                effective_request_delay_seconds=effective_request_delay_seconds,
-            )
-        paging_kwargs = self._paging_kwargs(request_delay_seconds=effective_request_delay_seconds, network_error_retries=network_error_retries, retry_backoff_seconds=retry_backoff_seconds, rate_limit_retries=settings.ingestion_rate_limit_retries, rate_limit_backoff_seconds=settings.ingestion_rate_limit_backoff_seconds, max_pages_per_scholar=max_pages_per_scholar, page_size=page_size)
-        threshold_kwargs = self._threshold_kwargs(alert_blocked_failure_threshold=alert_blocked_failure_threshold, alert_network_failure_threshold=alert_network_failure_threshold, alert_retry_scheduled_threshold=alert_retry_scheduled_threshold)
-        user_settings, run, scholars, start_cstart_map = await self._initialize_run_for_user(
-            db_session,
-            user_id=user_id,
-            trigger_type=trigger_type,
-            scholar_profile_ids=scholar_profile_ids,
-            start_cstart_by_scholar_id=start_cstart_by_scholar_id,
-            idempotency_key=idempotency_key,
-            **paging_kwargs,
-            **threshold_kwargs,
-        )
-        progress = await self._run_scholar_iteration(
-            db_session,
-            run=run,
-            scholars=scholars,
-            user_id=user_id,
-            start_cstart_map=start_cstart_map,
-            auto_queue_continuations=auto_queue_continuations,
-            queue_delay_seconds=queue_delay_seconds,
-            **paging_kwargs,
-        )
-        failure_summary, alert_summary = self._complete_run_for_user(
-            user_settings=user_settings,
-            run=run,
-            scholars=scholars,
-            user_id=user_id,
-            progress=progress,
-            idempotency_key=idempotency_key,
-            **threshold_kwargs,
-        )
-        await db_session.commit()
-        self._log_run_completed(user_id=user_id, run=run, scholars=scholars, progress=progress, alert_summary=alert_summary, failure_summary=failure_summary)
-        return self._run_execution_summary(run=run, scholars=scholars, progress=progress)
-
-    async def _fetch_profile_page(
-        self,
-        *,
-        scholar_id: str,
-        cstart: int,
-        page_size: int,
-    ) -> FetchResult:
-        try:
-            page_fetcher = getattr(self._source, "fetch_profile_page_html", None)
-            if callable(page_fetcher):
-                return await page_fetcher(
-                    scholar_id,
-                    cstart=cstart,
-                    pagesize=page_size,
-                )
-            if cstart <= 0:
-                return await self._source.fetch_profile_html(scholar_id)
-            return FetchResult(
-                requested_url=(
-                    "https://scholar.google.com/citations"
-                    f"?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
-                ),
-                status_code=None,
-                final_url=None,
-                body="",
-                error="source_does_not_support_pagination",
-            )
-        except Exception as exc:
-            logger.exception(
-                "ingestion.fetch_unexpected_error",
-                extra={
-                    "event": "ingestion.fetch_unexpected_error",
-                    "scholar_id": scholar_id,
-                    "cstart": cstart,
-                    "page_size": page_size,
-                },
-            )
-            return FetchResult(
-                requested_url=(
-                    "https://scholar.google.com/citations"
-                    f"?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
-                ),
-                status_code=None,
-                final_url=None,
-                body="",
-                error=str(exc),
-            )
-
-    @staticmethod
-    def _attempt_log_entry(
-        *,
-        attempt: int,
-        cstart: int,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-    ) -> dict[str, Any]:
-        return {
-            "attempt": attempt,
-            "cstart": cstart,
-            "state": parsed_page.state.value,
-            "state_reason": parsed_page.state_reason,
-            "status_code": fetch_result.status_code,
-            "fetch_error": fetch_result.error,
-        }
-
-    @staticmethod
-    def _should_retry_page_fetch(
-        *,
-        parsed_page: ParsedProfilePage,
-        network_attempt_count: int,
-        rate_limit_attempt_count: int,
-        network_error_retries: int,
-        rate_limit_retries: int,
-    ) -> bool:
-        if parsed_page.state == ParseState.NETWORK_ERROR:
-            return network_attempt_count <= network_error_retries
-        if parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA and parsed_page.state_reason == "blocked_http_429_rate_limited":
-            return rate_limit_attempt_count <= rate_limit_retries
-        return False
-
-    @staticmethod
-    async def _sleep_retry_backoff(
-        *,
-        scholar_id: str,
-        cstart: int,
-        network_attempt_count: int,
-        rate_limit_attempt_count: int,
-        retry_backoff_seconds: float,
-        rate_limit_backoff_seconds: float,
-        state_reason: str,
-    ) -> None:
-        if state_reason == "blocked_http_429_rate_limited":
-            sleep_seconds = rate_limit_backoff_seconds * rate_limit_attempt_count
-            attempt_label = rate_limit_attempt_count
-        else:
-            sleep_seconds = retry_backoff_seconds * (2 ** (network_attempt_count - 1))
-            attempt_label = network_attempt_count
-
-        logger.warning(
-            "ingestion.scholar_retry_scheduled",
-            extra={
-                "event": "ingestion.scholar_retry_scheduled",
-                "scholar_id": scholar_id,
-                "cstart": cstart,
-                "attempt_count": attempt_label,
-                "sleep_seconds": sleep_seconds,
-                "state_reason": state_reason,
-            },
-        )
-        if sleep_seconds > 0:
-            await asyncio.sleep(sleep_seconds)
-
-    async def _fetch_and_parse_page_with_retry(
-        self,
-        *,
-        scholar_id: str,
-        cstart: int,
-        page_size: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-    ) -> tuple[FetchResult, ParsedProfilePage, list[dict[str, Any]]]:
-        network_attempts = 0
-        rate_limit_attempts = 0
-        attempt_log: list[dict[str, Any]] = []
-        fetch_result: FetchResult | None = None
-        parsed_page: ParsedProfilePage | None = None
-
-        while True:
-            fetch_result = await self._fetch_profile_page(
-                scholar_id=scholar_id,
-                cstart=cstart,
-                page_size=page_size,
-            )
-            parsed_page = self._parse_profile_page_or_layout_error(fetch_result=fetch_result)
-            
-            if parsed_page.state == ParseState.NETWORK_ERROR:
-                network_attempts += 1
-                total_attempts = network_attempts
-            elif parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA and parsed_page.state_reason == "blocked_http_429_rate_limited":
-                rate_limit_attempts += 1
-                total_attempts = rate_limit_attempts
-            else:
-                total_attempts = network_attempts + rate_limit_attempts + 1
-
-            attempt_log.append(
-                self._attempt_log_entry(
-                    attempt=total_attempts,
-                    cstart=cstart,
-                    fetch_result=fetch_result,
-                    parsed_page=parsed_page,
-                )
-            )
-
-            if not self._should_retry_page_fetch(
-                parsed_page=parsed_page,
-                network_attempt_count=network_attempts,
-                rate_limit_attempt_count=rate_limit_attempts,
-                network_error_retries=network_error_retries,
-                rate_limit_retries=rate_limit_retries,
-            ):
-                break
-
-            await self._sleep_retry_backoff(
-                scholar_id=scholar_id,
-                cstart=cstart,
-                network_attempt_count=network_attempts,
-                rate_limit_attempt_count=rate_limit_attempts,
-                retry_backoff_seconds=max(float(retry_backoff_seconds), 0.0),
-                rate_limit_backoff_seconds=max(float(rate_limit_backoff_seconds), 0.0),
-                state_reason=parsed_page.state_reason,
-            )
-
-        if fetch_result is None or parsed_page is None:
-            raise RuntimeError("Fetch-and-parse retry loop produced no result.")
-        return fetch_result, parsed_page, attempt_log
-
-    def _parse_profile_page_or_layout_error(
-        self,
-        *,
-        fetch_result: FetchResult,
-    ) -> ParsedProfilePage:
-        try:
-            return parse_profile_page(fetch_result)
-        except ScholarParserError as exc:
-            return self._parsed_page_from_parser_error(
-                fetch_result=fetch_result,
-                code=exc.code,
-            )
-
-    @staticmethod
-    def _parsed_page_from_parser_error(
-        *,
-        fetch_result: FetchResult,
-        code: str,
-    ) -> ParsedProfilePage:
-        return ParsedProfilePage(
-            state=ParseState.LAYOUT_CHANGED,
-            state_reason=code,
-            profile_name=None,
-            profile_image_url=None,
-            publications=[],
-            marker_counts={},
-            warnings=[code],
-            has_show_more_button=False,
-            has_operation_error_banner=False,
-            articles_range=None,
-        )
-
-    @staticmethod
-    def _page_log_entry(
-        *,
-        page_number: int,
-        cstart: int,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        attempt_count: int,
-    ) -> dict[str, Any]:
-        return {
-            "page": page_number,
-            "cstart": cstart,
-            "state": parsed_page.state.value,
-            "state_reason": parsed_page.state_reason,
-            "status_code": fetch_result.status_code,
-            "publication_count": len(parsed_page.publications),
-            "articles_range": parsed_page.articles_range,
-            "has_show_more_button": parsed_page.has_show_more_button,
-            "warning_codes": parsed_page.warnings,
-            "attempt_count": attempt_count,
-        }
-
-    @staticmethod
-    def _should_skip_no_change(
-        *,
-        start_cstart: int,
-        first_page_fingerprint_sha256: str | None,
-        previous_initial_page_fingerprint_sha256: str | None,
-        parsed_page: ParsedProfilePage,
-    ) -> bool:
-        return (
-            start_cstart <= 0
-            and first_page_fingerprint_sha256 is not None
-            and previous_initial_page_fingerprint_sha256 is not None
-            and first_page_fingerprint_sha256 == previous_initial_page_fingerprint_sha256
-            and parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS}
-        )
-
-    @staticmethod
-    def _skip_no_change_result(
-        *,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        first_page_fingerprint_sha256: str | None,
-        attempt_log: list[dict[str, Any]],
-        page_logs: list[dict[str, Any]],
-    ) -> PagedParseResult:
-        return PagedParseResult(
-            fetch_result=fetch_result,
-            parsed_page=parsed_page,
-            first_page_fetch_result=fetch_result,
-            first_page_parsed_page=parsed_page,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-            publications=[],
-            attempt_log=attempt_log,
-            page_logs=page_logs,
-            pages_fetched=1,
-            pages_attempted=1,
-            has_more_remaining=False,
-            pagination_truncated_reason=None,
-            continuation_cstart=None,
-            skipped_no_change=True,
-            discovered_publication_count=0,
-        )
-
-    @staticmethod
-    def _initial_failure_result(
-        *,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        first_page_fingerprint_sha256: str | None,
-        start_cstart: int,
-        attempt_log: list[dict[str, Any]],
-        page_logs: list[dict[str, Any]],
-    ) -> PagedParseResult:
-        continuation_cstart = start_cstart if parsed_page.state == ParseState.NETWORK_ERROR else None
-        return PagedParseResult(
-            fetch_result=fetch_result,
-            parsed_page=parsed_page,
-            first_page_fetch_result=fetch_result,
-            first_page_parsed_page=parsed_page,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-            publications=[],
-            attempt_log=attempt_log,
-            page_logs=page_logs,
-            pages_fetched=0,
-            pages_attempted=1,
-            has_more_remaining=False,
-            pagination_truncated_reason=None,
-            continuation_cstart=continuation_cstart,
-            skipped_no_change=False,
-            discovered_publication_count=0,
-        )
-
-    @staticmethod
-    def _build_loop_state(
-        *,
-        start_cstart: int,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        attempt_log: list[dict[str, Any]],
-        page_logs: list[dict[str, Any]],
-    ) -> PagedLoopState:
-        next_cstart = _next_cstart_value(
-            articles_range=parsed_page.articles_range,
-            fallback=start_cstart + len(parsed_page.publications),
-        )
-        return PagedLoopState(
-            fetch_result=fetch_result,
-            parsed_page=parsed_page,
-            attempt_log=attempt_log,
-            page_logs=page_logs,
-            publications=list(parsed_page.publications),
-            pages_fetched=1,
-            pages_attempted=1,
-            current_cstart=start_cstart,
-            next_cstart=next_cstart,
-        )
-
-    @staticmethod
-    def _set_truncated_state(
-        *,
-        state: PagedLoopState,
-        reason: str,
-        continuation_cstart: int,
-    ) -> None:
-        state.has_more_remaining = True
-        state.pagination_truncated_reason = reason
-        state.continuation_cstart = continuation_cstart
-
-    def _should_stop_pagination(self, *, state: PagedLoopState, bounded_max_pages: int) -> bool:
-        if state.pages_fetched >= bounded_max_pages:
-            self._set_truncated_state(
-                state=state,
-                reason="max_pages_reached",
-                continuation_cstart=(
-                    state.next_cstart if state.next_cstart > state.current_cstart else state.current_cstart
-                ),
-            )
-            return True
-        if state.next_cstart <= state.current_cstart:
-            self._set_truncated_state(
-                state=state,
-                reason="pagination_cursor_stalled",
-                continuation_cstart=state.current_cstart,
-            )
-            return True
-        return False
-
-    async def _fetch_next_page(
-        self,
-        *,
-        scholar_id: str,
-        state: PagedLoopState,
-        request_delay_seconds: int,
-        bounded_page_size: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-    ) -> tuple[FetchResult, ParsedProfilePage, list[dict[str, Any]]]:
-        if request_delay_seconds > 0:
-            await asyncio.sleep(float(request_delay_seconds))
-        state.current_cstart = state.next_cstart
-        return await self._fetch_and_parse_page_with_retry(
-            scholar_id=scholar_id,
-            cstart=state.current_cstart,
-            page_size=bounded_page_size,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-        )
-
-    @staticmethod
-    def _record_next_page(
-        *,
-        state: PagedLoopState,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        page_attempt_log: list[dict[str, Any]],
-    ) -> None:
-        state.pages_attempted += 1
-        state.attempt_log.extend(page_attempt_log)
-        state.page_logs.append(
-            ScholarIngestionService._page_log_entry(
-                page_number=state.pages_attempted,
-                cstart=state.current_cstart,
-                fetch_result=fetch_result,
-                parsed_page=parsed_page,
-                attempt_count=len(page_attempt_log),
-            )
-        )
-        state.fetch_result = fetch_result
-        state.parsed_page = parsed_page
-
-    @staticmethod
-    def _handle_page_state_transition(*, state: PagedLoopState) -> bool:
-        if state.parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}:
-            ScholarIngestionService._set_truncated_state(
-                state=state,
-                reason=f"page_state_{state.parsed_page.state.value}",
-                continuation_cstart=state.current_cstart,
-            )
-            return True
-        if state.parsed_page.state == ParseState.NO_RESULTS and len(state.parsed_page.publications) == 0:
-            state.pages_fetched += 1
-            return True
-        state.pages_fetched += 1
-        state.publications.extend(state.parsed_page.publications)
-        state.next_cstart = _next_cstart_value(
-            articles_range=state.parsed_page.articles_range,
-            fallback=state.current_cstart + len(state.parsed_page.publications),
-        )
-        return False
-
-    async def _fetch_initial_page_context(
-        self,
-        *,
-        scholar_id: str,
-        start_cstart: int,
-        bounded_page_size: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-    ) -> tuple[FetchResult, ParsedProfilePage, str | None, list[dict[str, Any]], list[dict[str, Any]]]:
-        fetch_result, parsed_page, first_attempt_log = await self._fetch_and_parse_page_with_retry(
-            scholar_id=scholar_id,
-            cstart=start_cstart,
-            page_size=bounded_page_size,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-        )
-        first_page_fingerprint_sha256 = build_initial_page_fingerprint(parsed_page)
-        attempt_log = list(first_attempt_log)
-        page_logs = [
-            self._page_log_entry(
-                page_number=1,
-                cstart=start_cstart,
-                fetch_result=fetch_result,
-                parsed_page=parsed_page,
-                attempt_count=len(first_attempt_log),
-            )
-        ]
-        return fetch_result, parsed_page, first_page_fingerprint_sha256, attempt_log, page_logs
-
-    async def _paginate_loop(
-        self,
-        *,
-        scholar: ScholarProfile,
-        run: CrawlRun,
-        db_session: AsyncSession,
-        state: PagedLoopState,
-        bounded_max_pages: int,
-        request_delay_seconds: int,
-        bounded_page_size: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-    ) -> None:
-        if state.parsed_page.publications:
-            discovered_count = await self._upsert_profile_publications(
-                db_session, run=run, scholar=scholar, publications=list(state.parsed_page.publications)
-            )
-            state.discovered_publication_count += discovered_count
-            await db_session.commit()
-            
-        while state.parsed_page.has_show_more_button:
-            from app.db.models import RunStatus
-            await db_session.refresh(run)
-            if run.status == RunStatus.CANCELED:
-                logger.info(
-                    "ingestion.pagination_canceled",
-                    extra={"event": "ingestion.pagination_canceled", "run_id": run.id},
-                )
-                self._set_truncated_state(
-                    state=state,
-                    reason="run_canceled",
-                    continuation_cstart=state.current_cstart,
-                )
-                return
-
-            if self._should_stop_pagination(state=state, bounded_max_pages=bounded_max_pages):
-                return
-            next_fetch_result, next_parsed_page, next_attempt_log = await self._fetch_next_page(
-                scholar_id=scholar.scholar_id,
-                state=state,
-                request_delay_seconds=request_delay_seconds,
-                bounded_page_size=bounded_page_size,
-                network_error_retries=network_error_retries,
-                retry_backoff_seconds=retry_backoff_seconds,
-                rate_limit_retries=rate_limit_retries,
-                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-            )
-            self._record_next_page(
-                state=state,
-                fetch_result=next_fetch_result,
-                parsed_page=next_parsed_page,
-                page_attempt_log=next_attempt_log,
-            )
-            
-            # Immediately commit the new page's publications to the DB
-            if next_parsed_page.publications:
-                discovered_count = await self._upsert_profile_publications(
-                    db_session, run=run, scholar=scholar, publications=list(next_parsed_page.publications)
-                )
-                state.discovered_publication_count += discovered_count
-                await db_session.commit()
-
-            if self._handle_page_state_transition(state=state):
-                return
-
-    @staticmethod
-    def _result_from_pagination_state(
-        *,
-        state: PagedLoopState,
-        first_page_fetch_result: FetchResult,
-        first_page_parsed_page: ParsedProfilePage,
-        first_page_fingerprint_sha256: str | None,
-    ) -> PagedParseResult:
-        return PagedParseResult(
-            fetch_result=state.fetch_result,
-            parsed_page=state.parsed_page,
-            first_page_fetch_result=first_page_fetch_result,
-            first_page_parsed_page=first_page_parsed_page,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-            publications=_dedupe_publication_candidates(state.publications),
-            attempt_log=state.attempt_log,
-            page_logs=state.page_logs,
-            pages_fetched=state.pages_fetched,
-            pages_attempted=state.pages_attempted,
-            has_more_remaining=state.has_more_remaining,
-            pagination_truncated_reason=state.pagination_truncated_reason,
-            continuation_cstart=state.continuation_cstart,
-            skipped_no_change=False,
-            discovered_publication_count=state.discovered_publication_count,
-        )
-
-    def _short_circuit_initial_page(
-        self,
-        *,
-        start_cstart: int,
-        previous_initial_page_fingerprint_sha256: str | None,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        first_page_fingerprint_sha256: str | None,
-        attempt_log: list[dict[str, Any]],
-        page_logs: list[dict[str, Any]],
-    ) -> PagedParseResult | None:
-        if self._should_skip_no_change(
-            start_cstart=start_cstart,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-            previous_initial_page_fingerprint_sha256=previous_initial_page_fingerprint_sha256,
-            parsed_page=parsed_page,
-        ):
-            return self._skip_no_change_result(
-                fetch_result=fetch_result,
-                parsed_page=parsed_page,
-                first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-                attempt_log=attempt_log,
-                page_logs=page_logs,
-            )
-        if parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}:
-            return self._initial_failure_result(
-                fetch_result=fetch_result,
-                parsed_page=parsed_page,
-                first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-                start_cstart=start_cstart,
-                attempt_log=attempt_log,
-                page_logs=page_logs,
-            )
-        return None
-
-    async def _fetch_and_parse_all_pages_with_retry(
-        self,
-        *,
-        scholar: ScholarProfile,
-        run: CrawlRun,
-        db_session: AsyncSession,
-        start_cstart: int,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages: int,
-        page_size: int,
-        previous_initial_page_fingerprint_sha256: str | None = None
-    ) -> PagedParseResult:
-        bounded_max_pages = max(1, int(max_pages))
-        bounded_page_size = max(1, int(page_size))
-        fetch_result, parsed_page, first_page_fingerprint_sha256, attempt_log, page_logs = (
-            await self._fetch_initial_page_context(
-            scholar_id=scholar.scholar_id,
-            start_cstart=start_cstart,
-            bounded_page_size=bounded_page_size,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-        ))
-        shortcut_result = self._short_circuit_initial_page(
-            start_cstart=start_cstart,
-            previous_initial_page_fingerprint_sha256=previous_initial_page_fingerprint_sha256,
-            fetch_result=fetch_result,
-            parsed_page=parsed_page,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-            attempt_log=attempt_log,
-            page_logs=page_logs,
-        )
-        if shortcut_result is not None:
-            return shortcut_result
-        state = self._build_loop_state(
-            start_cstart=start_cstart,
-            fetch_result=fetch_result,
-            parsed_page=parsed_page,
-            attempt_log=attempt_log,
-            page_logs=page_logs,
-        )
-        await self._paginate_loop(
-            scholar=scholar,
-            run=run,
-            db_session=db_session,
-            state=state,
-            bounded_max_pages=bounded_max_pages,
-            request_delay_seconds=request_delay_seconds,
-            bounded_page_size=bounded_page_size,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-        )
-        return self._result_from_pagination_state(
-            state=state,
-            first_page_fetch_result=fetch_result,
-            first_page_parsed_page=parsed_page,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-        )
-
-    async def _enrich_publications_with_openalex(
-        self,
-        scholar: ScholarProfile,
-        publications: list[PublicationCandidate],
-    ) -> list[PublicationCandidate]:
-        if not publications:
-            return publications
-
-        from app.services.domains.openalex.client import OpenAlexClient
-        from app.services.domains.openalex.matching import find_best_match
-        
-        client = OpenAlexClient(api_key=settings.openalex_api_key, mailto=settings.crossref_api_mailto)
-        
-        # Batch requests by 25 to stay within URL length limits
-        batch_size = 25
-        enriched: list[PublicationCandidate] = []
-        
-        import re
-        for i in range(0, len(publications), batch_size):
-            batch = publications[i:i + batch_size]
-            
-            titles = []
-            for p in batch:
-                if not p.title:
-                    continue
-                # Strip all non-alphanumeric words to prevent OpenAlex API injection crashes
-                # and minimize punctuation-based duplicate misses.
-                safe_title = re.sub(r"[^\w\s]", " ", p.title)
-                safe_title = " ".join(safe_title.split())
-                if safe_title:
-                    titles.append(safe_title)
-            
-            if not titles:
-                enriched.extend(batch)
-                continue
-            
-            query = "|".join(t for t in titles)
-            try:
-                openalex_works = await client.get_works_by_filter(
-                    {"title.search": query}, limit=batch_size * 3
-                )
-            except Exception as e:
-                logger.warning(
-                    "ingestion.openalex_enrichment_failed",
-                    extra={"error": str(e), "batch_size": len(batch), "scholar_id": scholar.id}
-                )
-                openalex_works = []
-                
-            for p in batch:
-                match = find_best_match(
-                    target_title=p.title,
-                    target_year=p.year,
-                    target_authors=p.authors_text or scholar.name,
-                    candidates=openalex_works
-                )
-                if match:
-                    new_p = PublicationCandidate(
-                        title=p.title,
-                        title_url=p.title_url,
-                        cluster_id=p.cluster_id,
-                        year=match.publication_year or p.year,
-                        citation_count=match.cited_by_count,
-                        authors_text=p.authors_text,
-                        venue_text=p.venue_text,
-                        pdf_url=match.oa_url or p.pdf_url,
-                    )
-                    enriched.append(new_p)
-                else:
-                    enriched.append(p)
-
-        return enriched
-
-    async def _upsert_profile_publications(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        publications: list[PublicationCandidate],
-    ) -> int:
-        publications = await self._enrich_publications_with_openalex(scholar, publications)
-        
-        seen_publication_ids: set[int] = set()
-        discovered_count = 0
-
-        for candidate in publications:
-            publication = await self._resolve_publication(db_session, candidate)
-            if publication.id in seen_publication_ids:
-                continue
-            seen_publication_ids.add(publication.id)
-
-            link_result = await db_session.execute(
-                select(ScholarPublication).where(
-                    ScholarPublication.scholar_profile_id == scholar.id,
-                    ScholarPublication.publication_id == publication.id,
-                )
-            )
-            link = link_result.scalar_one_or_none()
-            if link is not None:
-                continue
-
-            link = ScholarPublication(
-                scholar_profile_id=scholar.id,
-                publication_id=publication.id,
-                is_read=False,
-                first_seen_run_id=run.id,
-            )
-            db_session.add(link)
-            discovered_count += 1
-
-            logger.debug(
-                "ingestion.publication_discovered",
-                extra={
-                    "event": "ingestion.publication_discovered",
-                    "scholar_profile_id": scholar.id,
-                    "publication_id": publication.id,
-                    "crawl_run_id": run.id,
-                },
-            )
-            
-            # Commit immediately to ensure the row becomes visible to the UI immediately
-            await db_session.commit()
-            
-            # Emit Server-Sent Event for live UI progress updates
-            await run_events.publish(
-                run_id=run.id,
-                event_type="publication_discovered",
-                data={
-                    "publication_id": publication.id,
-                    "title": publication.title_raw,
-                    "pub_url": publication.pub_url,
-                    "scholar_profile_id": scholar.id,
-                    "scholar_label": scholar.display_name or scholar.scholar_id,
-                    "first_seen_at": datetime.now(timezone.utc).isoformat(),
-                }
-            )
-
-        if not scholar.baseline_completed:
-            scholar.baseline_completed = True
-
-        return discovered_count
-
-    @staticmethod
-    def _validate_publication_candidate(candidate: PublicationCandidate) -> None:
-        if not candidate.title.strip():
-            raise RuntimeError("Publication candidate is missing title.")
-        if candidate.citation_count is not None and int(candidate.citation_count) < 0:
-            raise RuntimeError("Publication candidate has negative citation_count.")
-
-    async def _find_publication_by_cluster(
-        self,
-        db_session: AsyncSession,
-        *,
-        cluster_id: str | None,
-    ) -> Publication | None:
-        if not cluster_id:
-            return None
-        result = await db_session.execute(
-            select(Publication).where(Publication.cluster_id == cluster_id)
-        )
-        return result.scalar_one_or_none()
-
-    async def _find_publication_by_fingerprint(
-        self,
-        db_session: AsyncSession,
-        *,
-        fingerprint: str,
-    ) -> Publication | None:
-        result = await db_session.execute(
-            select(Publication).where(Publication.fingerprint_sha256 == fingerprint)
-        )
-        return result.scalar_one_or_none()
-
-    @staticmethod
-    def _select_existing_publication(
-        *,
-        cluster_publication: Publication | None,
-        fingerprint_publication: Publication | None,
-    ) -> Publication | None:
-        if cluster_publication is not None:
-            return cluster_publication
-        return fingerprint_publication
-
-    async def _create_publication(
-        self,
-        db_session: AsyncSession,
-        *,
-        candidate: PublicationCandidate,
-        fingerprint: str,
-    ) -> Publication:
-        publication = Publication(
-            cluster_id=candidate.cluster_id,
-            fingerprint_sha256=fingerprint,
-            title_raw=candidate.title,
-            title_normalized=normalize_title(candidate.title),
-            year=candidate.year,
-            citation_count=int(candidate.citation_count or 0),
-            author_text=candidate.authors_text,
-            venue_text=candidate.venue_text,
-            pub_url=build_publication_url(candidate.title_url),
-            pdf_url=None,
-        )
-        db_session.add(publication)
-        await db_session.flush()
-        logger.debug(
-            "ingestion.publication_created",
-            extra={
-                "event": "ingestion.publication_created",
-                "publication_id": publication.id,
-                "cluster_id": publication.cluster_id,
-            },
-        )
-        return publication
-
-    @staticmethod
-    def _update_existing_publication(
-        *,
-        publication: Publication,
-        candidate: PublicationCandidate,
-    ) -> None:
-        if candidate.cluster_id and publication.cluster_id is None:
-            publication.cluster_id = candidate.cluster_id
-        publication.title_raw = candidate.title
-        publication.title_normalized = normalize_title(candidate.title)
-        if candidate.year is not None:
-            publication.year = candidate.year
-        if candidate.citation_count is not None:
-            publication.citation_count = int(candidate.citation_count)
-        if candidate.authors_text:
-            publication.author_text = candidate.authors_text
-        if candidate.venue_text:
-            publication.venue_text = candidate.venue_text
-        if candidate.title_url:
-            publication.pub_url = build_publication_url(candidate.title_url)
-        local_doi = first_doi_from_texts(candidate.title_url, candidate.venue_text, candidate.title)
-
-    async def _resolve_publication(
-        self,
-        db_session: AsyncSession,
-        candidate: PublicationCandidate,
-    ) -> Publication:
-        self._validate_publication_candidate(candidate)
-        fingerprint = build_publication_fingerprint(candidate)
-        cluster_publication = await self._find_publication_by_cluster(
-            db_session,
-            cluster_id=candidate.cluster_id,
-        )
-        fingerprint_publication = await self._find_publication_by_fingerprint(
-            db_session,
-            fingerprint=fingerprint,
-        )
-        publication = self._select_existing_publication(
-            cluster_publication=cluster_publication,
-            fingerprint_publication=fingerprint_publication,
-        )
-        if publication is None:
-            created = await self._create_publication(
-                db_session,
-                candidate=candidate,
-                fingerprint=fingerprint,
-            )
-            await identifier_service.discover_and_sync_identifiers_for_publication(
-                db_session,
-                publication=created,
-                scholar_label=candidate.authors_text or "",
-            )
-            return created
-        self._update_existing_publication(
-            publication=publication,
-            candidate=candidate,
-        )
-        await identifier_service.discover_and_sync_identifiers_for_publication(
-            db_session,
-            publication=publication,
-            scholar_label=candidate.authors_text or "",
-        )
-        return publication
-
-    def _resolve_run_status(
-        self,
-        *,
-        scholar_count: int,
-        succeeded_count: int,
-        failed_count: int,
-        partial_count: int,
-    ) -> RunStatus:
-        if scholar_count == 0:
-            return RunStatus.SUCCESS
-        if failed_count == scholar_count:
-            return RunStatus.FAILED
-        if failed_count > 0 or partial_count > 0:
-            return RunStatus.PARTIAL_FAILURE
-        if succeeded_count > 0:
-            return RunStatus.SUCCESS
-        return RunStatus.FAILED
-
-    def _resolve_continuation_queue_target(
-        self,
-        *,
-        outcome: str,
-        state: str,
-        pagination_truncated_reason: str | None,
-        continuation_cstart: int | None,
-        fallback_cstart: int,
-    ) -> tuple[str | None, int]:
-        if outcome == "partial":
-            reason = (pagination_truncated_reason or "").strip()
-            if reason in RESUMABLE_PARTIAL_REASONS or reason.startswith(
-                RESUMABLE_PARTIAL_REASON_PREFIXES
-            ):
-                return reason, queue_service.normalize_cstart(
-                    continuation_cstart if continuation_cstart is not None else fallback_cstart
-                )
-            return None, queue_service.normalize_cstart(fallback_cstart)
-
-        if outcome == "failed" and state == ParseState.NETWORK_ERROR.value:
-            return "network_error_retry", queue_service.normalize_cstart(
-                continuation_cstart if continuation_cstart is not None else fallback_cstart
-            )
-
-        return None, queue_service.normalize_cstart(fallback_cstart)
-
-    def _build_failure_debug_context(
-        self,
-        *,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        attempt_log: list[dict[str, Any]],
-        page_logs: list[dict[str, Any]] | None = None,
-        exception: Exception | None = None,
-    ) -> dict[str, Any]:
-        context: dict[str, Any] = {
-            "requested_url": fetch_result.requested_url,
-            "final_url": fetch_result.final_url,
-            "status_code": fetch_result.status_code,
-            "fetch_error": fetch_result.error,
-            "state_reason": parsed_page.state_reason,
-            "profile_name": parsed_page.profile_name,
-            "profile_image_url": parsed_page.profile_image_url,
-            "articles_range": parsed_page.articles_range,
-            "has_show_more_button": parsed_page.has_show_more_button,
-            "has_operation_error_banner": parsed_page.has_operation_error_banner,
-            "warning_codes": parsed_page.warnings,
-            "marker_counts_nonzero": {
-                key: value for key, value in parsed_page.marker_counts.items() if value > 0
-            },
-            "body_length": len(fetch_result.body),
-            "body_sha256": hashlib.sha256(fetch_result.body.encode("utf-8")).hexdigest()
-            if fetch_result.body
-            else None,
-            "body_excerpt": _build_body_excerpt(fetch_result.body),
-            "attempt_log": attempt_log,
-        }
-        if page_logs:
-            context["page_logs"] = page_logs
-        if exception is not None:
-            context["exception_type"] = type(exception).__name__
-            context["exception_message"] = str(exception)
-        return context
-
-    async def _try_acquire_user_lock(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_id: int,
-    ) -> bool:
-        result = await db_session.execute(
-            text(
-                "SELECT pg_try_advisory_xact_lock(:namespace, :user_key)"
-            ),
-            {
-                "namespace": RUN_LOCK_NAMESPACE,
-                "user_key": int(user_id),
-            },
-        )
-        return bool(result.scalar_one())
diff --git a/build/lib/app/services/domains/ingestion/constants.py b/build/lib/app/services/domains/ingestion/constants.py
deleted file mode 100644
index cfe2ba0..0000000
--- a/build/lib/app/services/domains/ingestion/constants.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-import re
-
-from app.services.domains.scholar.parser import ParseState
-
-TITLE_ALNUM_RE = re.compile(r"[^a-z0-9]+")
-WORD_RE = re.compile(r"[a-z0-9]+")
-HTML_TAG_RE = re.compile(r"<[^>]+>", re.S)
-SPACE_RE = re.compile(r"\s+")
-
-FAILED_STATES = {
-    ParseState.BLOCKED_OR_CAPTCHA.value,
-    ParseState.LAYOUT_CHANGED.value,
-    ParseState.NETWORK_ERROR.value,
-    "ingestion_error",
-}
-
-FAILURE_BUCKET_BLOCKED = "blocked_or_captcha"
-FAILURE_BUCKET_NETWORK = "network_error"
-FAILURE_BUCKET_LAYOUT = "layout_changed"
-FAILURE_BUCKET_INGESTION = "ingestion_error"
-FAILURE_BUCKET_OTHER = "other_failure"
-
-RUN_LOCK_NAMESPACE = 8217
-RESUMABLE_PARTIAL_REASONS = {
-    "max_pages_reached",
-    "pagination_cursor_stalled",
-}
-RESUMABLE_PARTIAL_REASON_PREFIXES = ("page_state_network_error",)
-INITIAL_PAGE_FINGERPRINT_MAX_PUBLICATIONS = 30
diff --git a/build/lib/app/services/domains/ingestion/fingerprints.py b/build/lib/app/services/domains/ingestion/fingerprints.py
deleted file mode 100644
index b59710e..0000000
--- a/build/lib/app/services/domains/ingestion/fingerprints.py
+++ /dev/null
@@ -1,175 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import json
-import re
-from typing import Any
-from urllib.parse import urljoin
-
-from app.services.domains.ingestion.constants import (
-    HTML_TAG_RE,
-    INITIAL_PAGE_FINGERPRINT_MAX_PUBLICATIONS,
-    SPACE_RE,
-    TITLE_ALNUM_RE,
-    WORD_RE,
-)
-from app.services.domains.scholar.parser import ParseState, ParsedProfilePage, PublicationCandidate
-
-
-def normalize_title(value: str) -> str:
-    lowered = value.lower()
-    return TITLE_ALNUM_RE.sub("", lowered)
-
-
-def _first_author_last_name(authors_text: str | None) -> str:
-    if not authors_text:
-        return ""
-    first_author = authors_text.split(",", maxsplit=1)[0].strip().lower()
-    words = WORD_RE.findall(first_author)
-    if not words:
-        return ""
-    return words[-1]
-
-
-def _first_venue_word(venue_text: str | None) -> str:
-    if not venue_text:
-        return ""
-    words = WORD_RE.findall(venue_text.lower())
-    if not words:
-        return ""
-    return words[0]
-
-
-def build_publication_fingerprint(candidate: PublicationCandidate) -> str:
-    canonical = "|".join(
-        [
-            normalize_title(candidate.title),
-            str(candidate.year) if candidate.year is not None else "",
-            _first_author_last_name(candidate.authors_text),
-            _first_venue_word(candidate.venue_text),
-        ]
-    )
-    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
-
-
-def build_initial_page_fingerprint(parsed_page: ParsedProfilePage) -> str | None:
-    if parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}:
-        return None
-
-    normalized_rows: list[dict[str, Any]] = []
-    for publication in parsed_page.publications[:INITIAL_PAGE_FINGERPRINT_MAX_PUBLICATIONS]:
-        normalized_rows.append(
-            {
-                "cluster_id": publication.cluster_id or "",
-                "title_normalized": normalize_title(publication.title),
-                "year": publication.year,
-                "citation_count": publication.citation_count,
-            }
-        )
-
-    payload = {
-        "state": parsed_page.state.value,
-        "articles_range": parsed_page.articles_range or "",
-        "has_show_more_button": parsed_page.has_show_more_button,
-        "profile_name": parsed_page.profile_name or "",
-        "publications": normalized_rows,
-    }
-    canonical = json.dumps(
-        payload,
-        sort_keys=True,
-        separators=(",", ":"),
-        ensure_ascii=True,
-    )
-    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
-
-
-def build_publication_url(path_or_url: str | None) -> str | None:
-    if not path_or_url:
-        return None
-    return urljoin("https://scholar.google.com", path_or_url)
-
-
-def _next_cstart_value(*, articles_range: str | None, fallback: int) -> int:
-    if articles_range:
-        numbers = re.findall(r"\d+", articles_range)
-        if len(numbers) >= 2:
-            try:
-                return int(numbers[1])
-            except ValueError:
-                pass
-    return int(fallback)
-
-
-def _title_tokens(value: str) -> set[str]:
-    """Extract normalized word tokens for fuzzy title comparison."""
-    return set(WORD_RE.findall(value.lower()))
-
-
-def fuzzy_titles_match(
-    title_a: str,
-    title_b: str,
-    *,
-    threshold: float = 0.85,
-) -> bool:
-    """Return True if two titles are near-duplicates by token-level Jaccard similarity.
-
-    A threshold of 0.85 catches common academic duplicate patterns:
-    differences in punctuation, minor word variations, subtitle changes.
-    """
-    tokens_a = _title_tokens(title_a)
-    tokens_b = _title_tokens(title_b)
-    if not tokens_a or not tokens_b:
-        return False
-    intersection = tokens_a & tokens_b
-    union = tokens_a | tokens_b
-    return (len(intersection) / len(union)) >= threshold
-
-
-def _dedupe_publication_candidates(
-    publications: list[PublicationCandidate],
-) -> list[PublicationCandidate]:
-    deduped: list[PublicationCandidate] = []
-    seen: set[str] = set()
-    seen_titles: list[tuple[str, int]] = []  # (normalized_title, index into deduped)
-
-    for publication in publications:
-        if publication.cluster_id:
-            identity = f"cluster:{publication.cluster_id}"
-        else:
-            identity = "|".join(
-                [
-                    "fallback",
-                    normalize_title(publication.title),
-                    str(publication.year) if publication.year is not None else "",
-                    _first_author_last_name(publication.authors_text),
-                    _first_venue_word(publication.venue_text),
-                ]
-            )
-        if identity in seen:
-            continue
-
-        # Fuzzy title check — catch near-identical titles not caught by exact fingerprint
-        norm_title = normalize_title(publication.title)
-        is_fuzzy_dup = False
-        for existing_title, _idx in seen_titles:
-            if fuzzy_titles_match(norm_title, existing_title):
-                is_fuzzy_dup = True
-                break
-        if is_fuzzy_dup:
-            continue
-
-        seen.add(identity)
-        seen_titles.append((norm_title, len(deduped)))
-        deduped.append(publication)
-    return deduped
-
-
-def _build_body_excerpt(body: str, *, max_chars: int = 220) -> str | None:
-    if not body:
-        return None
-    flattened = SPACE_RE.sub(" ", HTML_TAG_RE.sub(" ", body)).strip()
-    if not flattened:
-        return None
-    if len(flattened) <= max_chars:
-        return flattened
-    return f"{flattened[:max_chars - 1]}..."
diff --git a/build/lib/app/services/domains/ingestion/queue.py b/build/lib/app/services/domains/ingestion/queue.py
deleted file mode 100644
index 7494420..0000000
--- a/build/lib/app/services/domains/ingestion/queue.py
+++ /dev/null
@@ -1,348 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import IngestionQueueItem, QueueItemStatus
-
-
-@dataclass(frozen=True)
-class ContinuationQueueJob:
-    id: int
-    user_id: int
-    scholar_profile_id: int
-    resume_cstart: int
-    reason: str
-    status: str
-    attempt_count: int
-    next_attempt_dt: datetime
-
-
-ACTIVE_QUEUE_STATUSES: tuple[str, ...] = (
-    QueueItemStatus.QUEUED.value,
-    QueueItemStatus.RETRYING.value,
-)
-
-
-def normalize_cstart(value: int | None) -> int:
-    if value is None:
-        return 0
-    return max(0, int(value))
-
-
-def compute_backoff_seconds(*, base_seconds: int, attempt_count: int, max_seconds: int) -> int:
-    base = max(1, int(base_seconds))
-    attempts = max(1, int(attempt_count))
-    maximum = max(base, int(max_seconds))
-    seconds = base * (2 ** max(0, attempts - 1))
-    return min(seconds, maximum)
-
-
-async def _get_item_for_user_scholar(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int,
-) -> IngestionQueueItem | None:
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(
-            IngestionQueueItem.user_id == user_id,
-            IngestionQueueItem.scholar_profile_id == scholar_profile_id,
-        )
-    )
-    return result.scalar_one_or_none()
-
-
-def _build_queue_item(
-    *,
-    now: datetime,
-    user_id: int,
-    scholar_profile_id: int,
-    normalized_cstart: int,
-    reason: str,
-    run_id: int | None,
-    next_attempt_dt: datetime,
-) -> IngestionQueueItem:
-    return IngestionQueueItem(
-        user_id=user_id,
-        scholar_profile_id=scholar_profile_id,
-        resume_cstart=normalized_cstart,
-        reason=reason,
-        status=QueueItemStatus.QUEUED.value,
-        attempt_count=0,
-        next_attempt_dt=next_attempt_dt,
-        last_run_id=run_id,
-        last_error=None,
-        dropped_reason=None,
-        dropped_at=None,
-        created_at=now,
-        updated_at=now,
-    )
-
-
-def _update_existing_queue_item(
-    *,
-    item: IngestionQueueItem,
-    now: datetime,
-    normalized_cstart: int,
-    reason: str,
-    run_id: int | None,
-    next_attempt_dt: datetime,
-) -> None:
-    item.resume_cstart = normalized_cstart
-    item.reason = reason
-    if item.status == QueueItemStatus.DROPPED.value:
-        item.attempt_count = 0
-    item.status = QueueItemStatus.QUEUED.value
-    item.next_attempt_dt = next_attempt_dt
-    item.last_run_id = run_id
-    item.last_error = None
-    item.dropped_reason = None
-    item.dropped_at = None
-    item.updated_at = now
-
-
-async def upsert_job(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int,
-    resume_cstart: int,
-    reason: str,
-    run_id: int | None,
-    delay_seconds: int,
-) -> IngestionQueueItem:
-    now = datetime.now(timezone.utc)
-    next_attempt_dt = now + timedelta(seconds=max(0, int(delay_seconds)))
-    item = await _get_item_for_user_scholar(
-        db_session,
-        user_id=user_id,
-        scholar_profile_id=scholar_profile_id,
-    )
-    normalized_cstart = normalize_cstart(resume_cstart)
-    if item is None:
-        item = _build_queue_item(
-            now=now,
-            user_id=user_id,
-            scholar_profile_id=scholar_profile_id,
-            normalized_cstart=normalized_cstart,
-            reason=reason,
-            run_id=run_id,
-            next_attempt_dt=next_attempt_dt,
-        )
-        db_session.add(item)
-        return item
-
-    _update_existing_queue_item(
-        item=item,
-        now=now,
-        normalized_cstart=normalized_cstart,
-        reason=reason,
-        run_id=run_id,
-        next_attempt_dt=next_attempt_dt,
-    )
-    return item
-
-
-async def clear_job_for_scholar(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int,
-) -> bool:
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(
-            IngestionQueueItem.user_id == user_id,
-            IngestionQueueItem.scholar_profile_id == scholar_profile_id,
-        )
-    )
-    item = result.scalar_one_or_none()
-    if item is None:
-        return False
-    await db_session.delete(item)
-    return True
-
-
-async def delete_job_by_id(
-    db_session: AsyncSession,
-    *,
-    job_id: int,
-) -> bool:
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
-    item = result.scalar_one_or_none()
-    if item is None:
-        return False
-    await db_session.delete(item)
-    return True
-
-
-async def list_due_jobs(
-    db_session: AsyncSession,
-    *,
-    now: datetime,
-    limit: int,
-) -> list[ContinuationQueueJob]:
-    result = await db_session.execute(
-        select(IngestionQueueItem)
-        .where(
-            IngestionQueueItem.next_attempt_dt <= now,
-            IngestionQueueItem.status.in_(ACTIVE_QUEUE_STATUSES),
-        )
-        .order_by(
-            IngestionQueueItem.next_attempt_dt.asc(),
-            IngestionQueueItem.id.asc(),
-        )
-        .limit(limit)
-    )
-    rows = list(result.scalars().all())
-    jobs: list[ContinuationQueueJob] = []
-    for row in rows:
-        jobs.append(
-            ContinuationQueueJob(
-                id=int(row.id),
-                user_id=int(row.user_id),
-                scholar_profile_id=int(row.scholar_profile_id),
-                resume_cstart=normalize_cstart(row.resume_cstart),
-                reason=row.reason,
-                status=row.status,
-                attempt_count=int(row.attempt_count),
-                next_attempt_dt=row.next_attempt_dt,
-            )
-        )
-    return jobs
-
-
-async def increment_attempt_count(
-    db_session: AsyncSession,
-    *,
-    job_id: int,
-) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
-    item = result.scalar_one_or_none()
-    if item is None:
-        return None
-    item.attempt_count = int(item.attempt_count or 0) + 1
-    item.updated_at = now
-    return item
-
-
-async def reset_attempt_count(
-    db_session: AsyncSession,
-    *,
-    job_id: int,
-) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
-    item = result.scalar_one_or_none()
-    if item is None:
-        return None
-    item.attempt_count = 0
-    item.updated_at = now
-    return item
-
-
-async def reschedule_job(
-    db_session: AsyncSession,
-    *,
-    job_id: int,
-    delay_seconds: int,
-    reason: str,
-    error: str | None = None,
-) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
-    item = result.scalar_one_or_none()
-    if item is None:
-        return None
-    item.next_attempt_dt = now + timedelta(seconds=max(1, int(delay_seconds)))
-    item.status = QueueItemStatus.QUEUED.value
-    item.reason = reason
-    item.last_error = error
-    item.dropped_reason = None
-    item.dropped_at = None
-    item.updated_at = now
-    return item
-
-
-async def mark_retrying(
-    db_session: AsyncSession,
-    *,
-    job_id: int,
-    reason: str | None = None,
-) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
-    item = result.scalar_one_or_none()
-    if item is None:
-        return None
-    if item.status == QueueItemStatus.DROPPED.value:
-        return item
-    item.status = QueueItemStatus.RETRYING.value
-    if reason:
-        item.reason = reason
-    item.updated_at = now
-    return item
-
-
-async def mark_dropped(
-    db_session: AsyncSession,
-    *,
-    job_id: int,
-    reason: str,
-    error: str | None = None,
-) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
-    item = result.scalar_one_or_none()
-    if item is None:
-        return None
-    item.status = QueueItemStatus.DROPPED.value
-    item.reason = "dropped"
-    item.dropped_reason = reason
-    item.dropped_at = now
-    if error is not None:
-        item.last_error = error
-    item.updated_at = now
-    return item
-
-
-async def mark_queued_now(
-    db_session: AsyncSession,
-    *,
-    job_id: int,
-    reason: str,
-    reset_attempt_count: bool = False,
-) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
-    item = result.scalar_one_or_none()
-    if item is None:
-        return None
-    item.status = QueueItemStatus.QUEUED.value
-    item.reason = reason
-    item.next_attempt_dt = now
-    if reset_attempt_count:
-        item.attempt_count = 0
-    item.last_error = None
-    item.dropped_reason = None
-    item.dropped_at = None
-    item.updated_at = now
-    return item
diff --git a/build/lib/app/services/domains/ingestion/safety.py b/build/lib/app/services/domains/ingestion/safety.py
deleted file mode 100644
index debb8c5..0000000
--- a/build/lib/app/services/domains/ingestion/safety.py
+++ /dev/null
@@ -1,282 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timedelta, timezone
-from typing import Any
-
-from app.db.models import UserSetting
-
-COOLDOWN_REASON_BLOCKED_FAILURE_THRESHOLD = "blocked_failure_threshold_exceeded"
-COOLDOWN_REASON_NETWORK_FAILURE_THRESHOLD = "network_failure_threshold_exceeded"
-
-_COUNTER_CONSECUTIVE_BLOCKED_RUNS = "consecutive_blocked_runs"
-_COUNTER_CONSECUTIVE_NETWORK_RUNS = "consecutive_network_runs"
-_COUNTER_COOLDOWN_ENTRY_COUNT = "cooldown_entry_count"
-_COUNTER_BLOCKED_START_COUNT = "blocked_start_count"
-_COUNTER_LAST_BLOCKED_FAILURE_COUNT = "last_blocked_failure_count"
-_COUNTER_LAST_NETWORK_FAILURE_COUNT = "last_network_failure_count"
-_COUNTER_LAST_EVALUATED_RUN_ID = "last_evaluated_run_id"
-
-
-def _utcnow() -> datetime:
-    return datetime.now(timezone.utc)
-
-
-def _safe_int(value: Any, default: int = 0) -> int:
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        return default
-
-
-def _safe_optional_int(value: Any) -> int | None:
-    if value is None:
-        return None
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        return None
-
-
-def _normalize_datetime(value: datetime | None) -> datetime | None:
-    if value is None:
-        return None
-    if value.tzinfo is None:
-        return value.replace(tzinfo=timezone.utc)
-    return value.astimezone(timezone.utc)
-
-
-def _state_dict(settings: UserSetting) -> dict[str, Any]:
-    state = settings.scrape_safety_state
-    if isinstance(state, dict):
-        return state
-    return {}
-
-
-def _counters_from_state(settings: UserSetting) -> dict[str, Any]:
-    state = _state_dict(settings)
-    return {
-        _COUNTER_CONSECUTIVE_BLOCKED_RUNS: max(
-            0,
-            _safe_int(state.get(_COUNTER_CONSECUTIVE_BLOCKED_RUNS), 0),
-        ),
-        _COUNTER_CONSECUTIVE_NETWORK_RUNS: max(
-            0,
-            _safe_int(state.get(_COUNTER_CONSECUTIVE_NETWORK_RUNS), 0),
-        ),
-        _COUNTER_COOLDOWN_ENTRY_COUNT: max(
-            0,
-            _safe_int(state.get(_COUNTER_COOLDOWN_ENTRY_COUNT), 0),
-        ),
-        _COUNTER_BLOCKED_START_COUNT: max(
-            0,
-            _safe_int(state.get(_COUNTER_BLOCKED_START_COUNT), 0),
-        ),
-        _COUNTER_LAST_BLOCKED_FAILURE_COUNT: max(
-            0,
-            _safe_int(state.get(_COUNTER_LAST_BLOCKED_FAILURE_COUNT), 0),
-        ),
-        _COUNTER_LAST_NETWORK_FAILURE_COUNT: max(
-            0,
-            _safe_int(state.get(_COUNTER_LAST_NETWORK_FAILURE_COUNT), 0),
-        ),
-        _COUNTER_LAST_EVALUATED_RUN_ID: _safe_optional_int(
-            state.get(_COUNTER_LAST_EVALUATED_RUN_ID),
-        ),
-    }
-
-
-def _cooldown_reason_label(reason: str | None) -> str | None:
-    if reason == COOLDOWN_REASON_BLOCKED_FAILURE_THRESHOLD:
-        return "Blocked responses exceeded safety threshold"
-    if reason == COOLDOWN_REASON_NETWORK_FAILURE_THRESHOLD:
-        return "Network failures exceeded safety threshold"
-    return None
-
-
-def _recommended_action(reason: str | None) -> str | None:
-    if reason == COOLDOWN_REASON_BLOCKED_FAILURE_THRESHOLD:
-        return (
-            "Google Scholar appears to be blocking requests. Wait for cooldown to expire, "
-            "increase request delay, and avoid repeated manual retries."
-        )
-    if reason == COOLDOWN_REASON_NETWORK_FAILURE_THRESHOLD:
-        return (
-            "Network failures crossed the threshold. Verify connectivity and retry after cooldown."
-        )
-    return None
-
-
-def is_cooldown_active(
-    settings: UserSetting,
-    *,
-    now_utc: datetime | None = None,
-) -> bool:
-    now = now_utc or _utcnow()
-    cooldown_until = _normalize_datetime(settings.scrape_cooldown_until)
-    if cooldown_until is None:
-        return False
-    return cooldown_until > now
-
-
-def clear_expired_cooldown(
-    settings: UserSetting,
-    *,
-    now_utc: datetime | None = None,
-) -> bool:
-    now = now_utc or _utcnow()
-    cooldown_until = _normalize_datetime(settings.scrape_cooldown_until)
-    if cooldown_until is None:
-        return False
-    if cooldown_until > now:
-        return False
-    settings.scrape_cooldown_until = None
-    settings.scrape_cooldown_reason = None
-    return True
-
-
-def register_cooldown_blocked_start(
-    settings: UserSetting,
-    *,
-    now_utc: datetime | None = None,
-) -> dict[str, Any]:
-    now = now_utc or _utcnow()
-    counters = _counters_from_state(settings)
-    counters[_COUNTER_BLOCKED_START_COUNT] = int(counters[_COUNTER_BLOCKED_START_COUNT]) + 1
-    settings.scrape_safety_state = counters
-    return get_safety_state_payload(settings, now_utc=now)
-
-
-def _update_run_counters(
-    *,
-    counters: dict[str, Any],
-    run_id: int,
-    blocked_failure_count: int,
-    network_failure_count: int,
-) -> tuple[int, int]:
-    bounded_blocked_failures = max(0, int(blocked_failure_count))
-    bounded_network_failures = max(0, int(network_failure_count))
-    counters[_COUNTER_LAST_BLOCKED_FAILURE_COUNT] = bounded_blocked_failures
-    counters[_COUNTER_LAST_NETWORK_FAILURE_COUNT] = bounded_network_failures
-    counters[_COUNTER_LAST_EVALUATED_RUN_ID] = int(run_id)
-    counters[_COUNTER_CONSECUTIVE_BLOCKED_RUNS] = (
-        int(counters[_COUNTER_CONSECUTIVE_BLOCKED_RUNS]) + 1
-        if bounded_blocked_failures > 0
-        else 0
-    )
-    counters[_COUNTER_CONSECUTIVE_NETWORK_RUNS] = (
-        int(counters[_COUNTER_CONSECUTIVE_NETWORK_RUNS]) + 1
-        if bounded_network_failures > 0
-        else 0
-    )
-    return bounded_blocked_failures, bounded_network_failures
-
-
-def _resolve_cooldown_trigger(
-    *,
-    blocked_failures: int,
-    network_failures: int,
-    blocked_failure_threshold: int,
-    network_failure_threshold: int,
-    blocked_cooldown_seconds: int,
-    network_cooldown_seconds: int,
-) -> tuple[str | None, int]:
-    if blocked_failures >= max(1, int(blocked_failure_threshold)):
-        return COOLDOWN_REASON_BLOCKED_FAILURE_THRESHOLD, max(60, int(blocked_cooldown_seconds))
-    if network_failures >= max(1, int(network_failure_threshold)):
-        return COOLDOWN_REASON_NETWORK_FAILURE_THRESHOLD, max(60, int(network_cooldown_seconds))
-    return None, 0
-
-
-def _apply_cooldown_decision(
-    *,
-    settings: UserSetting,
-    counters: dict[str, Any],
-    now: datetime,
-    reason: str | None,
-    cooldown_seconds: int,
-) -> None:
-    if reason is None:
-        clear_expired_cooldown(settings, now_utc=now)
-        return
-    settings.scrape_cooldown_reason = reason
-    settings.scrape_cooldown_until = now + timedelta(seconds=max(60, int(cooldown_seconds)))
-    counters[_COUNTER_COOLDOWN_ENTRY_COUNT] = int(counters[_COUNTER_COOLDOWN_ENTRY_COUNT]) + 1
-
-
-def apply_run_safety_outcome(
-    settings: UserSetting,
-    *,
-    run_id: int,
-    blocked_failure_count: int,
-    network_failure_count: int,
-    blocked_failure_threshold: int,
-    network_failure_threshold: int,
-    blocked_cooldown_seconds: int,
-    network_cooldown_seconds: int,
-    now_utc: datetime | None = None,
-) -> tuple[dict[str, Any], str | None]:
-    now = now_utc or _utcnow()
-    counters = _counters_from_state(settings)
-    blocked_failures, network_failures = _update_run_counters(
-        counters=counters,
-        run_id=run_id,
-        blocked_failure_count=blocked_failure_count,
-        network_failure_count=network_failure_count,
-    )
-    reason, cooldown_seconds = _resolve_cooldown_trigger(
-        blocked_failures=blocked_failures,
-        network_failures=network_failures,
-        blocked_failure_threshold=blocked_failure_threshold,
-        network_failure_threshold=network_failure_threshold,
-        blocked_cooldown_seconds=blocked_cooldown_seconds,
-        network_cooldown_seconds=network_cooldown_seconds,
-    )
-    _apply_cooldown_decision(
-        settings=settings,
-        counters=counters,
-        now=now,
-        reason=reason,
-        cooldown_seconds=cooldown_seconds,
-    )
-    settings.scrape_safety_state = counters
-    return get_safety_state_payload(settings, now_utc=now), reason
-
-
-def get_safety_state_payload(
-    settings: UserSetting,
-    *,
-    now_utc: datetime | None = None,
-) -> dict[str, Any]:
-    now = now_utc or _utcnow()
-    cooldown_until = _normalize_datetime(settings.scrape_cooldown_until)
-    cooldown_active = bool(cooldown_until is not None and cooldown_until > now)
-    cooldown_remaining_seconds = 0
-    if cooldown_active and cooldown_until is not None:
-        cooldown_remaining_seconds = max(0, int((cooldown_until - now).total_seconds()))
-
-    reason = settings.scrape_cooldown_reason if cooldown_active else None
-
-    return {
-        "cooldown_active": cooldown_active,
-        "cooldown_reason": reason,
-        "cooldown_reason_label": _cooldown_reason_label(reason),
-        "cooldown_until": cooldown_until,
-        "cooldown_remaining_seconds": cooldown_remaining_seconds,
-        "recommended_action": _recommended_action(reason),
-        "counters": _counters_from_state(settings),
-    }
-
-
-def get_safety_event_context(
-    settings: UserSetting,
-    *,
-    now_utc: datetime | None = None,
-) -> dict[str, Any]:
-    payload = get_safety_state_payload(settings, now_utc=now_utc)
-    return {
-        "cooldown_active": bool(payload.get("cooldown_active")),
-        "cooldown_reason": payload.get("cooldown_reason"),
-        "cooldown_until": payload.get("cooldown_until"),
-        "cooldown_remaining_seconds": int(payload.get("cooldown_remaining_seconds") or 0),
-        "safety_counters": payload.get("counters", {}),
-    }
diff --git a/build/lib/app/services/domains/ingestion/scheduler.py b/build/lib/app/services/domains/ingestion/scheduler.py
deleted file mode 100644
index b05e84d..0000000
--- a/build/lib/app/services/domains/ingestion/scheduler.py
+++ /dev/null
@@ -1,622 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-import logging
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import (
-    CrawlRun,
-    QueueItemStatus,
-    RunTriggerType,
-    ScholarProfile,
-    User,
-    UserSetting,
-)
-from app.db.session import get_session_factory
-from app.services.domains.ingestion import queue as queue_service
-from app.services.domains.ingestion.application import (
-    RunAlreadyInProgressError,
-    RunBlockedBySafetyPolicyError,
-    ScholarIngestionService,
-)
-from app.services.domains.settings import application as user_settings_service
-from app.services.domains.scholar.source import LiveScholarSource
-from app.settings import settings
-
-logger = logging.getLogger(__name__)
-
-
-def _request_delay_floor_seconds() -> int:
-    return user_settings_service.resolve_request_delay_minimum(
-        settings.ingestion_min_request_delay_seconds
-    )
-
-
-def _effective_request_delay_seconds(value: int | None) -> int:
-    floor = _request_delay_floor_seconds()
-    try:
-        parsed = int(value) if value is not None else floor
-    except (TypeError, ValueError):
-        parsed = floor
-    return max(floor, parsed)
-
-
-@dataclass(frozen=True)
-class _AutoRunCandidate:
-    user_id: int
-    run_interval_minutes: int
-    request_delay_seconds: int
-    cooldown_until: datetime | None
-    cooldown_reason: str | None
-
-
-class SchedulerService:
-    def __init__(
-        self,
-        *,
-        enabled: bool,
-        tick_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-        continuation_queue_enabled: bool,
-        continuation_base_delay_seconds: int,
-        continuation_max_delay_seconds: int,
-        continuation_max_attempts: int,
-        queue_batch_size: int,
-    ) -> None:
-        self._enabled = enabled
-        self._tick_seconds = max(5, int(tick_seconds))
-        self._network_error_retries = max(0, int(network_error_retries))
-        self._retry_backoff_seconds = max(0.0, float(retry_backoff_seconds))
-        self._max_pages_per_scholar = max(1, int(max_pages_per_scholar))
-        self._page_size = max(1, int(page_size))
-        self._continuation_queue_enabled = bool(continuation_queue_enabled)
-        self._continuation_base_delay_seconds = max(1, int(continuation_base_delay_seconds))
-        self._continuation_max_delay_seconds = max(
-            self._continuation_base_delay_seconds,
-            int(continuation_max_delay_seconds),
-        )
-        self._continuation_max_attempts = max(1, int(continuation_max_attempts))
-        self._queue_batch_size = max(1, int(queue_batch_size))
-        self._task: asyncio.Task[None] | None = None
-        self._source = LiveScholarSource()
-
-    async def start(self) -> None:
-        if not self._enabled:
-            logger.info(
-                "scheduler.disabled",
-                extra={
-                    "event": "scheduler.disabled",
-                },
-            )
-            return
-        if self._task is not None:
-            return
-        self._task = asyncio.create_task(self._run_loop(), name="scholarr-scheduler")
-        logger.info(
-            "scheduler.started",
-            extra={
-                "event": "scheduler.started",
-                "tick_seconds": self._tick_seconds,
-                "network_error_retries": self._network_error_retries,
-                "retry_backoff_seconds": self._retry_backoff_seconds,
-                "max_pages_per_scholar": self._max_pages_per_scholar,
-                "page_size": self._page_size,
-                "continuation_queue_enabled": self._continuation_queue_enabled,
-                "continuation_base_delay_seconds": self._continuation_base_delay_seconds,
-                "continuation_max_delay_seconds": self._continuation_max_delay_seconds,
-                "continuation_max_attempts": self._continuation_max_attempts,
-                "queue_batch_size": self._queue_batch_size,
-            },
-        )
-
-    async def stop(self) -> None:
-        if self._task is None:
-            return
-        self._task.cancel()
-        try:
-            await self._task
-        except asyncio.CancelledError:
-            pass
-        finally:
-            self._task = None
-        logger.info("scheduler.stopped", extra={"event": "scheduler.stopped"})
-
-    async def _run_loop(self) -> None:
-        while True:
-            try:
-                await self._tick_once()
-            except asyncio.CancelledError:
-                raise
-            except Exception:
-                logger.exception(
-                    "scheduler.tick_failed",
-                    extra={
-                        "event": "scheduler.tick_failed",
-                    },
-                )
-            await asyncio.sleep(float(self._tick_seconds))
-
-    async def _tick_once(self) -> None:
-        if self._continuation_queue_enabled:
-            await self._drain_continuation_queue()
-        
-        await self._drain_pdf_queue()
-
-        candidates = await self._load_candidates()
-        if not candidates:
-            return
-        now = datetime.now(timezone.utc)
-        for candidate in candidates:
-            if not await self._is_due(candidate, now=now):
-                continue
-            await self._run_candidate(candidate)
-
-    async def _load_candidate_rows(self) -> list[tuple]:
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            result = await session.execute(
-                select(
-                    UserSetting.user_id,
-                    UserSetting.run_interval_minutes,
-                    UserSetting.request_delay_seconds,
-                    UserSetting.scrape_cooldown_until,
-                    UserSetting.scrape_cooldown_reason,
-                )
-                .join(User, User.id == UserSetting.user_id)
-                .where(User.is_active.is_(True), UserSetting.auto_run_enabled.is_(True))
-                .order_by(UserSetting.user_id.asc())
-            )
-            return result.all()
-
-    @staticmethod
-    def _candidate_from_row(row: tuple, *, now_utc: datetime) -> _AutoRunCandidate | None:
-        user_id, run_interval_minutes, request_delay_seconds, cooldown_until, cooldown_reason = row
-        if cooldown_until is not None and cooldown_until.tzinfo is None:
-            cooldown_until = cooldown_until.replace(tzinfo=timezone.utc)
-        if cooldown_until is not None and cooldown_until > now_utc:
-            logger.info(
-                "scheduler.run_skipped_safety_cooldown_precheck",
-                extra={
-                    "event": "scheduler.run_skipped_safety_cooldown_precheck",
-                    "user_id": int(user_id),
-                    "reason": cooldown_reason,
-                    "cooldown_until": cooldown_until,
-                    "cooldown_remaining_seconds": int((cooldown_until - now_utc).total_seconds()),
-                    "metric_name": "scheduler_run_skipped_safety_cooldown_total",
-                    "metric_value": 1,
-                },
-            )
-            return None
-        return _AutoRunCandidate(
-            user_id=int(user_id),
-            run_interval_minutes=int(run_interval_minutes),
-            request_delay_seconds=_effective_request_delay_seconds(request_delay_seconds),
-            cooldown_until=cooldown_until,
-            cooldown_reason=(str(cooldown_reason).strip() if cooldown_reason else None),
-        )
-
-    async def _load_candidates(self) -> list[_AutoRunCandidate]:
-        if not settings.ingestion_automation_allowed:
-            return []
-        rows = await self._load_candidate_rows()
-        now_utc = datetime.now(timezone.utc)
-        candidates: list[_AutoRunCandidate] = []
-        for row in rows:
-            candidate = self._candidate_from_row(row, now_utc=now_utc)
-            if candidate is not None:
-                candidates.append(candidate)
-        return candidates
-
-    async def _is_due(self, candidate: _AutoRunCandidate, *, now: datetime) -> bool:
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            result = await session.execute(
-                select(CrawlRun.start_dt)
-                .where(
-                    CrawlRun.user_id == candidate.user_id,
-                )
-                .order_by(CrawlRun.start_dt.desc(), CrawlRun.id.desc())
-                .limit(1)
-            )
-            last_run = result.scalar_one_or_none()
-
-        if last_run is None:
-            return True
-
-        next_due_dt = last_run + timedelta(
-            minutes=candidate.run_interval_minutes
-        )
-        return now >= next_due_dt
-
-    async def _run_candidate_ingestion(
-        self,
-        *,
-        candidate: _AutoRunCandidate,
-    ):
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            ingestion = ScholarIngestionService(source=self._source)
-            try:
-                return await ingestion.run_for_user(
-                    session,
-                    user_id=candidate.user_id,
-                    trigger_type=RunTriggerType.SCHEDULED,
-                    request_delay_seconds=candidate.request_delay_seconds,
-                    network_error_retries=self._network_error_retries,
-                    retry_backoff_seconds=self._retry_backoff_seconds,
-                    max_pages_per_scholar=self._max_pages_per_scholar,
-                    page_size=self._page_size,
-                    auto_queue_continuations=self._continuation_queue_enabled,
-                    queue_delay_seconds=self._continuation_base_delay_seconds,
-                    alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
-                    alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
-                    alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
-                )
-            except RunAlreadyInProgressError:
-                await session.rollback()
-                logger.info("scheduler.run_skipped_locked", extra={"event": "scheduler.run_skipped_locked", "user_id": candidate.user_id})
-                return None
-            except RunBlockedBySafetyPolicyError as exc:
-                await session.rollback()
-                logger.info(
-                    "scheduler.run_skipped_safety_cooldown",
-                    extra={
-                        "event": "scheduler.run_skipped_safety_cooldown",
-                        "user_id": candidate.user_id,
-                        "reason": exc.safety_state.get("cooldown_reason"),
-                        "cooldown_until": exc.safety_state.get("cooldown_until"),
-                        "cooldown_remaining_seconds": exc.safety_state.get("cooldown_remaining_seconds"),
-                        "metric_name": "scheduler_run_skipped_safety_cooldown_total",
-                        "metric_value": 1,
-                    },
-                )
-                return None
-            except Exception:
-                await session.rollback()
-                logger.exception("scheduler.run_failed", extra={"event": "scheduler.run_failed", "user_id": candidate.user_id})
-                return None
-
-    async def _run_candidate(self, candidate: _AutoRunCandidate) -> None:
-        run_summary = await self._run_candidate_ingestion(candidate=candidate)
-        if run_summary is None:
-            return
-        logger.info(
-            "scheduler.run_completed",
-            extra={
-                "event": "scheduler.run_completed",
-                "user_id": candidate.user_id,
-                "run_id": run_summary.crawl_run_id,
-                "status": run_summary.status.value,
-                "scholar_count": run_summary.scholar_count,
-                "new_publication_count": run_summary.new_publication_count,
-            },
-        )
-
-    async def _drain_continuation_queue(self) -> None:
-        now = datetime.now(timezone.utc)
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            jobs = await queue_service.list_due_jobs(
-                session,
-                now=now,
-                limit=self._queue_batch_size,
-            )
-        for job in jobs:
-            await self._run_queue_job(job)
-
-    async def _drop_queue_job_if_max_attempts(
-        self,
-        job: queue_service.ContinuationQueueJob,
-    ) -> bool:
-        if job.attempt_count < self._continuation_max_attempts:
-            return False
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            dropped = await queue_service.mark_dropped(
-                session,
-                job_id=job.id,
-                reason="max_attempts_reached",
-            )
-            await session.commit()
-        if dropped is not None:
-            logger.warning(
-                "scheduler.queue_item_dropped_max_attempts",
-                extra={
-                    "event": "scheduler.queue_item_dropped_max_attempts",
-                    "queue_item_id": job.id,
-                    "user_id": job.user_id,
-                    "scholar_profile_id": job.scholar_profile_id,
-                    "attempt_count": job.attempt_count,
-                    "max_attempts": self._continuation_max_attempts,
-                },
-            )
-        return True
-
-    async def _mark_queue_job_retrying(
-        self,
-        job: queue_service.ContinuationQueueJob,
-    ) -> bool:
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            queue_item = await queue_service.mark_retrying(session, job_id=job.id)
-            await session.commit()
-        if queue_item is None:
-            return False
-        if queue_item.status == QueueItemStatus.DROPPED.value:
-            return False
-        return True
-
-    async def _queue_job_has_available_scholar(
-        self,
-        job: queue_service.ContinuationQueueJob,
-    ) -> bool:
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            scholar_result = await session.execute(
-                select(ScholarProfile.id).where(
-                    ScholarProfile.user_id == job.user_id,
-                    ScholarProfile.id == job.scholar_profile_id,
-                    ScholarProfile.is_enabled.is_(True),
-                )
-            )
-            scholar_id = scholar_result.scalar_one_or_none()
-            if scholar_id is not None:
-                return True
-            dropped = await queue_service.mark_dropped(
-                session,
-                job_id=job.id,
-                reason="scholar_unavailable",
-            )
-            await session.commit()
-        if dropped is not None:
-            logger.info(
-                "scheduler.queue_item_dropped_scholar_unavailable",
-                extra={
-                    "event": "scheduler.queue_item_dropped_scholar_unavailable",
-                    "queue_item_id": job.id,
-                    "user_id": job.user_id,
-                    "scholar_profile_id": job.scholar_profile_id,
-                },
-            )
-        return False
-
-    async def _reschedule_queue_job_lock_active(self, job: queue_service.ContinuationQueueJob) -> None:
-        session_factory = get_session_factory()
-        async with session_factory() as recovery_session:
-            await queue_service.reschedule_job(
-                recovery_session,
-                job_id=job.id,
-                delay_seconds=max(self._tick_seconds, 15),
-                reason="user_run_lock_active",
-                error="run_already_in_progress",
-            )
-            await recovery_session.commit()
-        logger.info(
-            "scheduler.queue_item_deferred_lock",
-            extra={"event": "scheduler.queue_item_deferred_lock", "queue_item_id": job.id, "user_id": job.user_id},
-        )
-
-    async def _reschedule_queue_job_safety_cooldown(
-        self,
-        job: queue_service.ContinuationQueueJob,
-        exc: RunBlockedBySafetyPolicyError,
-    ) -> None:
-        cooldown_remaining_seconds = max(
-            self._tick_seconds,
-            int(exc.safety_state.get("cooldown_remaining_seconds") or 0),
-        )
-        session_factory = get_session_factory()
-        async with session_factory() as recovery_session:
-            await queue_service.reschedule_job(
-                recovery_session,
-                job_id=job.id,
-                delay_seconds=max(self._tick_seconds, cooldown_remaining_seconds),
-                reason="scrape_safety_cooldown",
-                error=str(exc.message),
-            )
-            await recovery_session.commit()
-        logger.info(
-            "scheduler.queue_item_deferred_safety_cooldown",
-            extra={
-                "event": "scheduler.queue_item_deferred_safety_cooldown",
-                "queue_item_id": job.id,
-                "user_id": job.user_id,
-                "reason": exc.safety_state.get("cooldown_reason"),
-                "cooldown_remaining_seconds": cooldown_remaining_seconds,
-                "metric_name": "scheduler_queue_item_deferred_safety_cooldown_total",
-                "metric_value": 1,
-            },
-        )
-
-    async def _reschedule_queue_job_after_exception(
-        self,
-        job: queue_service.ContinuationQueueJob,
-        *,
-        exc: Exception,
-    ) -> None:
-        session_factory = get_session_factory()
-        async with session_factory() as recovery_session:
-            queue_item = await queue_service.increment_attempt_count(recovery_session, job_id=job.id)
-            if queue_item is None:
-                await recovery_session.commit()
-                return
-            if int(queue_item.attempt_count) >= self._continuation_max_attempts:
-                await queue_service.mark_dropped(
-                    recovery_session,
-                    job_id=job.id,
-                    reason="scheduler_exception_max_attempts",
-                    error=str(exc),
-                )
-                await recovery_session.commit()
-                logger.warning(
-                    "scheduler.queue_item_dropped_after_exception",
-                    extra={"event": "scheduler.queue_item_dropped_after_exception", "queue_item_id": job.id, "user_id": job.user_id, "attempt_count": queue_item.attempt_count},
-                )
-                return
-            delay_seconds = queue_service.compute_backoff_seconds(
-                base_seconds=self._continuation_base_delay_seconds,
-                attempt_count=int(queue_item.attempt_count),
-                max_seconds=self._continuation_max_delay_seconds,
-            )
-            await queue_service.reschedule_job(
-                recovery_session,
-                job_id=job.id,
-                delay_seconds=delay_seconds,
-                reason="scheduler_exception",
-                error=str(exc),
-            )
-            await recovery_session.commit()
-        logger.exception("scheduler.queue_item_run_failed", extra={"event": "scheduler.queue_item_run_failed", "queue_item_id": job.id, "user_id": job.user_id})
-
-    async def _run_ingestion_for_queue_job(
-        self,
-        job: queue_service.ContinuationQueueJob,
-    ):
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            request_delay_seconds = await self._load_request_delay_for_user(session, user_id=job.user_id)
-            ingestion = ScholarIngestionService(source=self._source)
-            try:
-                return await ingestion.run_for_user(
-                    session,
-                    user_id=job.user_id,
-                    trigger_type=RunTriggerType.SCHEDULED,
-                    request_delay_seconds=request_delay_seconds,
-                    network_error_retries=self._network_error_retries,
-                    retry_backoff_seconds=self._retry_backoff_seconds,
-                    rate_limit_retries=settings.ingestion_rate_limit_retries,
-                    rate_limit_backoff_seconds=settings.ingestion_rate_limit_backoff_seconds,
-                    max_pages_per_scholar=self._max_pages_per_scholar,
-                    page_size=self._page_size,
-                    scholar_profile_ids={job.scholar_profile_id},
-                    start_cstart_by_scholar_id={job.scholar_profile_id: job.resume_cstart},
-                    auto_queue_continuations=self._continuation_queue_enabled,
-                    queue_delay_seconds=self._continuation_base_delay_seconds,
-                    alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
-                    alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
-                    alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
-                )
-            except RunAlreadyInProgressError:
-                await session.rollback()
-                await self._reschedule_queue_job_lock_active(job)
-            except RunBlockedBySafetyPolicyError as exc:
-                await session.rollback()
-                await self._reschedule_queue_job_safety_cooldown(job, exc)
-            except Exception as exc:
-                await session.rollback()
-                await self._reschedule_queue_job_after_exception(job, exc=exc)
-        return None
-
-    @staticmethod
-    def _log_queue_item_resolved(
-        *,
-        event_name: str,
-        job: queue_service.ContinuationQueueJob,
-        run_summary,
-        attempt_count: int | None = None,
-        delay_seconds: int | None = None,
-    ) -> None:
-        payload = {
-            "event": event_name,
-            "queue_item_id": job.id,
-            "user_id": job.user_id,
-            "run_id": run_summary.crawl_run_id,
-            "status": run_summary.status.value,
-        }
-        if attempt_count is not None:
-            payload["attempt_count"] = attempt_count
-        if delay_seconds is not None:
-            payload["delay_seconds"] = delay_seconds
-        logger.info(event_name, extra=payload)
-
-    async def _finalize_queue_job_after_run(self, job: queue_service.ContinuationQueueJob, run_summary) -> None:
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            if int(run_summary.failed_count) <= 0:
-                queue_item = await queue_service.reset_attempt_count(session, job_id=job.id)
-                await session.commit()
-                if queue_item is None:
-                    self._log_queue_item_resolved(event_name="scheduler.queue_item_resolved", job=job, run_summary=run_summary)
-                    return
-                self._log_queue_item_resolved(
-                    event_name="scheduler.queue_item_progressed",
-                    job=job,
-                    run_summary=run_summary,
-                    attempt_count=int(queue_item.attempt_count),
-                )
-                return
-            queue_item = await queue_service.increment_attempt_count(session, job_id=job.id)
-            if queue_item is None:
-                await session.commit()
-                self._log_queue_item_resolved(event_name="scheduler.queue_item_resolved", job=job, run_summary=run_summary)
-                return
-            if int(queue_item.attempt_count) >= self._continuation_max_attempts:
-                await queue_service.mark_dropped(session, job_id=job.id, reason="max_attempts_after_run")
-                await session.commit()
-                logger.warning(
-                    "scheduler.queue_item_dropped_max_attempts_after_run",
-                    extra={"event": "scheduler.queue_item_dropped_max_attempts_after_run", "queue_item_id": job.id, "user_id": job.user_id, "attempt_count": queue_item.attempt_count, "run_id": run_summary.crawl_run_id, "status": run_summary.status.value},
-                )
-                return
-            delay_seconds = queue_service.compute_backoff_seconds(base_seconds=self._continuation_base_delay_seconds, attempt_count=int(queue_item.attempt_count), max_seconds=self._continuation_max_delay_seconds)
-            await queue_service.reschedule_job(session, job_id=job.id, delay_seconds=delay_seconds, reason=queue_item.reason, error=queue_item.last_error)
-            await session.commit()
-        self._log_queue_item_resolved(
-            event_name="scheduler.queue_item_rescheduled_failed",
-            job=job,
-            run_summary=run_summary,
-            attempt_count=int(queue_item.attempt_count),
-            delay_seconds=delay_seconds,
-        )
-
-    async def _run_queue_job(self, job: queue_service.ContinuationQueueJob) -> None:
-        if await self._drop_queue_job_if_max_attempts(job):
-            return
-        if not await self._mark_queue_job_retrying(job):
-            return
-        if not await self._queue_job_has_available_scholar(job):
-            return
-        run_summary = await self._run_ingestion_for_queue_job(job)
-        if run_summary is None:
-            return
-        await self._finalize_queue_job_after_run(job, run_summary)
-
-    async def _drain_pdf_queue(self) -> None:
-        from app.services.domains.publications.pdf_queue import drain_ready_jobs
-        
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            try:
-                processed = await drain_ready_jobs(
-                    session,
-                    limit=settings.scheduler_pdf_queue_batch_size,
-                    max_attempts=settings.pdf_auto_retry_max_attempts,
-                )
-                if processed > 0:
-                    logger.info("scheduler.pdf_queue_drain_completed", extra={
-                        "event": "scheduler.pdf_queue_drain_completed",
-                        "processed_count": processed,
-                    })
-            except Exception:
-                logger.exception("scheduler.pdf_queue_drain_failed", extra={
-                    "event": "scheduler.pdf_queue_drain_failed",
-                })
-
-    async def _load_request_delay_for_user(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_id: int,
-    ) -> int:
-        result = await db_session.execute(
-            select(UserSetting.request_delay_seconds).where(UserSetting.user_id == user_id)
-        )
-        delay = result.scalar_one_or_none()
-        return _effective_request_delay_seconds(delay)
diff --git a/build/lib/app/services/domains/ingestion/types.py b/build/lib/app/services/domains/ingestion/types.py
deleted file mode 100644
index 09d87f1..0000000
--- a/build/lib/app/services/domains/ingestion/types.py
+++ /dev/null
@@ -1,110 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any
-
-from app.db.models import RunStatus
-from app.services.domains.scholar.parser import ParsedProfilePage, PublicationCandidate
-from app.services.domains.scholar.source import FetchResult
-
-
-@dataclass(frozen=True)
-class RunExecutionSummary:
-    crawl_run_id: int
-    status: RunStatus
-    scholar_count: int
-    succeeded_count: int
-    failed_count: int
-    partial_count: int
-    new_publication_count: int
-
-
-@dataclass(frozen=True)
-class PagedParseResult:
-    fetch_result: FetchResult
-    parsed_page: ParsedProfilePage
-    first_page_fetch_result: FetchResult
-    first_page_parsed_page: ParsedProfilePage
-    first_page_fingerprint_sha256: str | None
-    publications: list[PublicationCandidate]
-    attempt_log: list[dict[str, Any]]
-    page_logs: list[dict[str, Any]]
-    pages_fetched: int
-    pages_attempted: int
-    has_more_remaining: bool
-    pagination_truncated_reason: str | None
-    continuation_cstart: int | None
-    skipped_no_change: bool
-    discovered_publication_count: int
-
-
-@dataclass
-class RunProgress:
-    succeeded_count: int = 0
-    failed_count: int = 0
-    partial_count: int = 0
-    scholar_results: list[dict[str, Any]] = field(default_factory=list)
-
-
-@dataclass(frozen=True)
-class ScholarProcessingOutcome:
-    result_entry: dict[str, Any]
-    succeeded_count_delta: int
-    failed_count_delta: int
-    partial_count_delta: int
-    discovered_publication_count: int
-
-
-@dataclass(frozen=True)
-class RunFailureSummary:
-    failed_state_counts: dict[str, int]
-    failed_reason_counts: dict[str, int]
-    scrape_failure_counts: dict[str, int]
-    retries_scheduled_count: int
-    scholars_with_retries_count: int
-    retry_exhausted_count: int
-
-
-@dataclass(frozen=True)
-class RunAlertSummary:
-    blocked_failure_count: int
-    network_failure_count: int
-    blocked_failure_threshold: int
-    network_failure_threshold: int
-    retry_scheduled_threshold: int
-    alert_flags: dict[str, bool]
-
-
-@dataclass
-class PagedLoopState:
-    fetch_result: FetchResult
-    parsed_page: ParsedProfilePage
-    attempt_log: list[dict[str, Any]]
-    page_logs: list[dict[str, Any]]
-    publications: list[PublicationCandidate]
-    pages_fetched: int
-    pages_attempted: int
-    current_cstart: int
-    next_cstart: int
-    has_more_remaining: bool = False
-    pagination_truncated_reason: str | None = None
-    continuation_cstart: int | None = None
-    discovered_publication_count: int = 0
-
-
-class RunAlreadyInProgressError(RuntimeError):
-    """Raised when a run lock for a user is already held by another process."""
-
-
-class RunBlockedBySafetyPolicyError(RuntimeError):
-    def __init__(
-        self,
-        *,
-        code: str,
-        message: str,
-        safety_state: dict[str, Any],
-    ) -> None:
-        super().__init__(message)
-        self.code = code
-        self.message = message
-        self.safety_state = safety_state
diff --git a/build/lib/app/services/domains/openalex/__init__.py b/build/lib/app/services/domains/openalex/__init__.py
deleted file mode 100644
index a51555a..0000000
--- a/build/lib/app/services/domains/openalex/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-logger = logging.getLogger(__name__)
diff --git a/build/lib/app/services/domains/openalex/client.py b/build/lib/app/services/domains/openalex/client.py
deleted file mode 100644
index c62d876..0000000
--- a/build/lib/app/services/domains/openalex/client.py
+++ /dev/null
@@ -1,135 +0,0 @@
-import asyncio
-import logging
-from typing import Any, Mapping
-
-import httpx
-from tenacity import (
-    retry,
-    retry_if_exception_type,
-    stop_after_attempt,
-    wait_exponential,
-)
-
-from app.services.domains.openalex.types import OpenAlexWork
-
-logger = logging.getLogger(__name__)
-
-OPENALEX_BASE_URL = "https://api.openalex.org"
-
-
-class OpenAlexClientError(Exception):
-    pass
-
-
-class OpenAlexRateLimitError(OpenAlexClientError):
-    pass
-
-
-class OpenAlexClient:
-    def __init__(
-        self,
-        api_key: str | None = None,
-        mailto: str | None = None,
-        timeout: float = 10.0,
-    ) -> None:
-        self.api_key = api_key
-        self.mailto = mailto
-        self.timeout = timeout
-
-    @property
-    def _base_params(self) -> dict[str, str]:
-        params = {}
-        if self.mailto:
-            params["mailto"] = self.mailto
-        if self.api_key:
-            params["api_key"] = self.api_key
-        return params
-
-    @retry(
-        retry=retry_if_exception_type((httpx.NetworkError, httpx.TimeoutException, OpenAlexRateLimitError)),
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=1, min=2, max=10),
-        reraise=True,
-    )
-    async def get_work_by_doi(self, doi: str) -> OpenAlexWork | None:
-        """Fetch a single work by DOI directly."""
-        clean_doi = doi.replace("https://doi.org/", "")
-        if not clean_doi:
-            return None
-
-        url = f"{OPENALEX_BASE_URL}/works/{clean_doi}"
-        
-        headers = {}
-        if self.mailto:
-            headers["User-Agent"] = f"scholar-scraper/1.0 (mailto:{self.mailto})"
-        else:
-            headers["User-Agent"] = "scholar-scraper/1.0"
-
-        async with httpx.AsyncClient(timeout=self.timeout, follow_redirects=True, headers=headers) as client:
-            response = await client.get(url, params=self._base_params)
-
-        if response.status_code == 404:
-            return None
-        if response.status_code == 429:
-            raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex work by DOI")
-        if response.status_code >= 400:
-            logger.warning("OpenAlex API error: %s %s", response.status_code, response.text)
-            raise OpenAlexClientError(f"API Error {response.status_code}")
-
-        data = response.json()
-        return OpenAlexWork.from_api_dict(data)
-
-    @retry(
-        retry=retry_if_exception_type((httpx.NetworkError, httpx.TimeoutException, OpenAlexRateLimitError)),
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=1, min=2, max=10),
-        reraise=True,
-    )
-    async def get_works_by_filter(
-        self,
-        filters: dict[str, str],
-        limit: int = 50,
-    ) -> list[OpenAlexWork]:
-        """
-        Fetch works using the ?filter= query parameter.
-        Supports fetching multiple records by joining filters with | (OR logic).
-        """
-        if not filters:
-            return []
-
-        # Example: {"doi": "10.foo|10.bar", "title.search": "query"}
-        filter_str = ",".join(f"{k}:{v}" for k, v in filters.items())
-        
-        params = self._base_params.copy()
-        params["filter"] = filter_str
-        params["per-page"] = str(limit)
-
-        url = f"{OPENALEX_BASE_URL}/works"
-        
-        headers = {}
-        if self.mailto:
-            headers["User-Agent"] = f"scholar-scraper/1.0 (mailto:{self.mailto})"
-        else:
-            headers["User-Agent"] = "scholar-scraper/1.0"
-
-        async with httpx.AsyncClient(timeout=self.timeout, follow_redirects=True, headers=headers) as client:
-            response = await client.get(url, params=params)
-
-        if response.status_code == 429:
-            raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex works list")
-        if response.status_code >= 400:
-            logger.warning("OpenAlex API error (filters=%s): %s %s", filters, response.status_code, response.text)
-            raise OpenAlexClientError(f"API Error {response.status_code}")
-
-        data = response.json()
-        results = data.get("results") or []
-        
-        parsed_works = []
-        for raw_work in results:
-            try:
-                parsed_works.append(OpenAlexWork.from_api_dict(raw_work))
-            except Exception as e:
-                logger.warning("Failed to parse OpenAlex raw dict: %s", e)
-                continue
-
-        return parsed_works
diff --git a/build/lib/app/services/domains/openalex/matching.py b/build/lib/app/services/domains/openalex/matching.py
deleted file mode 100644
index cfa511c..0000000
--- a/build/lib/app/services/domains/openalex/matching.py
+++ /dev/null
@@ -1,108 +0,0 @@
-import logging
-import re
-
-from rapidfuzz import fuzz
-
-from app.services.domains.openalex.types import OpenAlexWork
-
-logger = logging.getLogger(__name__)
-
-# A minimum similarity score out of 100 for a title to be considered a match candidate.
-TITLE_MATCH_THRESHOLD = 90.0
-# The margin within the top score where a secondary tiebreaker (author/year) is necessary.
-TIEBREAKER_MARGIN = 5.0
-
-
-def _clean_string(s: str | None) -> str:
-    if not s:
-        return ""
-    # Strip non-alphanumeric (keep spaces), lowercase, and collapse whitespace
-    cleaned = re.sub(r"[^a-z0-9\s]", " ", s.lower())
-    return " ".join(cleaned.split())
-
-
-def _author_overlap_score(target_authors: str | None, candidate_authors: list[str]) -> bool:
-    if not target_authors or not candidate_authors:
-        return False
-    
-    target_clean = _clean_string(target_authors)
-    if not target_clean:
-        return False
-        
-    for candidate in candidate_authors:
-        cand_clean = _clean_string(candidate)
-        if cand_clean and (cand_clean in target_clean or target_clean in cand_clean):
-            return True
-        # Alternatively check rapidfuzz token_set_ratio
-        if cand_clean and fuzz.token_set_ratio(target_clean, cand_clean) > 80:
-            return True
-            
-    return False
-
-
-def find_best_match(
-    target_title: str,
-    target_year: int | None,
-    target_authors: str | None,
-    candidates: list[OpenAlexWork],
-) -> OpenAlexWork | None:
-    """
-    Finds the best matching OpenAlexWork from a list of candidates, prioritizing title similarity (>90%)
-    with year and author overlap as tiebreakers for close candidates.
-    """
-    if not target_title or not candidates:
-        return None
-
-    clean_target = _clean_string(target_title)
-    if not clean_target:
-        return None
-
-    scored_candidates: list[tuple[float, OpenAlexWork]] = []
-
-    for cand in candidates:
-        if not cand.title:
-            continue
-            
-        clean_cand = _clean_string(cand.title)
-        
-        # Primary sort: string similarity ratio
-        score = fuzz.ratio(clean_target, clean_cand)
-        
-        if score >= TITLE_MATCH_THRESHOLD:
-            scored_candidates.append((score, cand))
-
-    if not scored_candidates:
-        return None
-
-    # Sort descending by score
-    scored_candidates.sort(key=lambda x: x[0], reverse=True)
-    
-    best_score = scored_candidates[0][0]
-    
-    # Extract all candidates within the tiebreaker margin
-    top_scored_candidates = [
-        (score, cand) for score, cand in scored_candidates 
-        if best_score - score <= TIEBREAKER_MARGIN
-    ]
-
-    if len(top_scored_candidates) == 1:
-        return top_scored_candidates[0][1]
-
-    # We have a tie or near-tie. Use year and author overlap to break the tie.
-    # Score candidates: +1 for year match (within 1 year), +1 for author overlap
-    tiebreaker_scores: list[tuple[int, float, OpenAlexWork]] = []
-    
-    for original_score, cand in top_scored_candidates:
-        tb_score = 0
-        if target_year is not None and cand.publication_year is not None:
-            if abs(target_year - cand.publication_year) <= 1:
-                tb_score += 1
-                
-        candidate_author_names = [a.display_name for a in cand.authors if a.display_name]
-        if _author_overlap_score(target_authors, candidate_author_names):
-            tb_score += 1
-            
-        tiebreaker_scores.append((tb_score, original_score, cand))
-        
-    tiebreaker_scores.sort(key=lambda x: (x[0], x[1]), reverse=True)
-    return tiebreaker_scores[0][2]
diff --git a/build/lib/app/services/domains/openalex/types.py b/build/lib/app/services/domains/openalex/types.py
deleted file mode 100644
index 0d86754..0000000
--- a/build/lib/app/services/domains/openalex/types.py
+++ /dev/null
@@ -1,71 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Any, Mapping
-
-
-@dataclass(frozen=True)
-class OpenAlexAuthor:
-    openalex_id: str | None
-    display_name: str | None
-
-
-@dataclass(frozen=True)
-class OpenAlexWork:
-    openalex_id: str
-    doi: str | None
-    pmid: str | None
-    pmcid: str | None
-    title: str | None
-    publication_year: int | None
-    cited_by_count: int
-    is_oa: bool
-    oa_url: str | None
-    authors: list[OpenAlexAuthor] = field(default_factory=list)
-    raw_data: Mapping[str, Any] = field(default_factory=dict, repr=False)
-
-    @classmethod
-    def from_api_dict(cls, data: Mapping[str, Any]) -> OpenAlexWork:
-        ids = data.get("ids") or {}
-        
-        # Extract DOI without the https://doi.org/ prefix
-        doi = ids.get("doi")
-        if doi and doi.startswith("https://doi.org/"):
-            doi = doi[16:]
-            
-        # Extract PMID without the url prefix
-        pmid = ids.get("pmid")
-        if pmid and pmid.startswith("https://pubmed.ncbi.nlm.nih.gov/"):
-            pmid = pmid[32:]
-            
-        # Extract PMCID without the url prefix
-        pmcid = ids.get("pmcid")
-        if pmcid and pmcid.startswith("https://www.ncbi.nlm.nih.gov/pmc/articles/"):
-            pmcid = pmcid[42:]
-
-        open_access = data.get("open_access") or {}
-        
-        authors = []
-        for authorship in data.get("authorships") or []:
-            author_data = authorship.get("author") or {}
-            authors.append(
-                OpenAlexAuthor(
-                    openalex_id=author_data.get("id"),
-                    display_name=author_data.get("display_name"),
-                )
-            )
-
-        return cls(
-            openalex_id=data.get("id", ""),
-            doi=doi,
-            pmid=pmid,
-            pmcid=pmcid,
-            title=data.get("title"),
-            publication_year=data.get("publication_year"),
-            cited_by_count=data.get("cited_by_count", 0),
-            is_oa=bool(open_access.get("is_oa")),
-            oa_url=open_access.get("oa_url"),
-            authors=authors,
-            raw_data=dict(data),
-        )
diff --git a/build/lib/app/services/domains/portability/__init__.py b/build/lib/app/services/domains/portability/__init__.py
deleted file mode 100644
index 28aae8b..0000000
--- a/build/lib/app/services/domains/portability/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from app.services.domains.portability.application import *
diff --git a/build/lib/app/services/domains/portability/application.py b/build/lib/app/services/domains/portability/application.py
deleted file mode 100644
index 7e0b56e..0000000
--- a/build/lib/app/services/domains/portability/application.py
+++ /dev/null
@@ -1,67 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import Publication
-from app.services.domains.portability.constants import (
-    EXPORT_SCHEMA_VERSION,
-    MAX_IMPORT_PUBLICATIONS,
-    MAX_IMPORT_SCHOLARS,
-)
-from app.services.domains.portability.exporting import export_user_data
-from app.services.domains.portability.normalize import _validate_import_sizes
-from app.services.domains.portability.publication_import import (
-    _build_imported_publication_input,
-    _initialize_import_counters,
-    _upsert_imported_publication,
-)
-from app.services.domains.portability.scholar_import import _upsert_imported_scholars
-from app.services.domains.portability.types import ImportExportError, ImportedPublicationInput
-
-
-async def import_user_data(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholars: list[dict[str, Any]],
-    publications: list[dict[str, Any]],
-) -> dict[str, int]:
-    _validate_import_sizes(scholars=scholars, publications=publications)
-    scholar_map, counters = await _upsert_imported_scholars(
-        db_session,
-        user_id=user_id,
-        scholars=scholars,
-    )
-    cluster_cache: dict[str, Publication | None] = {}
-    fingerprint_cache: dict[str, Publication | None] = {}
-    _initialize_import_counters(counters)
-    for item in publications:
-        parsed_item = _build_imported_publication_input(
-            item=item,
-            scholar_map=scholar_map,
-        )
-        if parsed_item is None:
-            counters["skipped_records"] += 1
-            continue
-        await _upsert_imported_publication(
-            db_session,
-            payload=parsed_item,
-            cluster_cache=cluster_cache,
-            fingerprint_cache=fingerprint_cache,
-            counters=counters,
-        )
-    await db_session.commit()
-    return counters
-
-
-__all__ = [
-    "EXPORT_SCHEMA_VERSION",
-    "MAX_IMPORT_SCHOLARS",
-    "MAX_IMPORT_PUBLICATIONS",
-    "ImportExportError",
-    "ImportedPublicationInput",
-    "export_user_data",
-    "import_user_data",
-]
diff --git a/build/lib/app/services/domains/portability/constants.py b/build/lib/app/services/domains/portability/constants.py
deleted file mode 100644
index 6815347..0000000
--- a/build/lib/app/services/domains/portability/constants.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from __future__ import annotations
-
-import re
-
-EXPORT_SCHEMA_VERSION = 1
-MAX_IMPORT_SCHOLARS = 10_000
-MAX_IMPORT_PUBLICATIONS = 100_000
-WORD_RE = re.compile(r"[a-z0-9]+")
-SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
diff --git a/build/lib/app/services/domains/portability/exporting.py b/build/lib/app/services/domains/portability/exporting.py
deleted file mode 100644
index 5c89006..0000000
--- a/build/lib/app/services/domains/portability/exporting.py
+++ /dev/null
@@ -1,91 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timezone
-from typing import Any
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import Publication, ScholarProfile, ScholarPublication
-from app.services.domains.portability.constants import EXPORT_SCHEMA_VERSION
-
-
-def _exported_at_iso() -> str:
-    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
-
-
-def _serialize_export_scholar(profile: ScholarProfile) -> dict[str, Any]:
-    return {
-        "scholar_id": profile.scholar_id,
-        "display_name": profile.display_name,
-        "is_enabled": bool(profile.is_enabled),
-        "profile_image_override_url": profile.profile_image_override_url,
-    }
-
-
-def _serialize_export_publication(row: tuple[Any, ...]) -> dict[str, Any]:
-    (
-        scholar_id,
-        cluster_id,
-        fingerprint_sha256,
-        title_raw,
-        year,
-        citation_count,
-        author_text,
-        venue_text,
-        pub_url,
-        pdf_url,
-        is_read,
-    ) = row
-    return {
-        "scholar_id": scholar_id,
-        "cluster_id": cluster_id,
-        "fingerprint_sha256": fingerprint_sha256,
-        "title": title_raw,
-        "year": year,
-        "citation_count": int(citation_count or 0),
-        "author_text": author_text,
-        "venue_text": venue_text,
-        "pub_url": pub_url,
-        "pdf_url": pdf_url,
-        "is_read": bool(is_read),
-    }
-
-
-async def export_user_data(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-) -> dict[str, Any]:
-    scholars_result = await db_session.execute(
-        select(ScholarProfile)
-        .where(ScholarProfile.user_id == user_id)
-        .order_by(ScholarProfile.id.asc())
-    )
-    publication_result = await db_session.execute(
-        select(
-            ScholarProfile.scholar_id,
-            Publication.cluster_id,
-            Publication.fingerprint_sha256,
-            Publication.title_raw,
-            Publication.year,
-            Publication.citation_count,
-            Publication.author_text,
-            Publication.venue_text,
-            Publication.pub_url,
-            Publication.pdf_url,
-            ScholarPublication.is_read,
-        )
-        .join(ScholarPublication, ScholarPublication.scholar_profile_id == ScholarProfile.id)
-        .join(Publication, Publication.id == ScholarPublication.publication_id)
-        .where(ScholarProfile.user_id == user_id)
-        .order_by(ScholarPublication.created_at.desc(), Publication.id.desc())
-    )
-    scholars = [_serialize_export_scholar(profile) for profile in scholars_result.scalars().all()]
-    publications = [_serialize_export_publication(row) for row in publication_result.all()]
-    return {
-        "schema_version": EXPORT_SCHEMA_VERSION,
-        "exported_at": _exported_at_iso(),
-        "scholars": scholars,
-        "publications": publications,
-    }
diff --git a/build/lib/app/services/domains/portability/normalize.py b/build/lib/app/services/domains/portability/normalize.py
deleted file mode 100644
index 60dd619..0000000
--- a/build/lib/app/services/domains/portability/normalize.py
+++ /dev/null
@@ -1,109 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-from typing import Any
-
-from app.services.domains.ingestion.application import normalize_title
-from app.services.domains.portability.constants import (
-    MAX_IMPORT_PUBLICATIONS,
-    MAX_IMPORT_SCHOLARS,
-    SHA256_RE,
-    WORD_RE,
-)
-from app.services.domains.portability.types import ImportExportError
-
-
-def _normalize_optional_text(value: Any) -> str | None:
-    if value is None:
-        return None
-    normalized = str(value).strip()
-    return normalized or None
-
-
-def _normalize_optional_year(value: Any) -> int | None:
-    if value is None:
-        return None
-    try:
-        year = int(value)
-    except (TypeError, ValueError):
-        return None
-    if year < 1500 or year > 3000:
-        return None
-    return year
-
-
-def _normalize_citation_count(value: Any) -> int:
-    try:
-        parsed = int(value)
-    except (TypeError, ValueError):
-        return 0
-    return max(0, parsed)
-
-
-def _first_author_last_name(authors_text: str | None) -> str:
-    if not authors_text:
-        return ""
-    first_author = authors_text.split(",", maxsplit=1)[0].strip().lower()
-    words = WORD_RE.findall(first_author)
-    if not words:
-        return ""
-    return words[-1]
-
-
-def _first_venue_word(venue_text: str | None) -> str:
-    if not venue_text:
-        return ""
-    words = WORD_RE.findall(venue_text.lower())
-    if not words:
-        return ""
-    return words[0]
-
-
-def _build_fingerprint(
-    *,
-    title: str,
-    year: int | None,
-    author_text: str | None,
-    venue_text: str | None,
-) -> str:
-    canonical = "|".join(
-        [
-            normalize_title(title),
-            str(year) if year is not None else "",
-            _first_author_last_name(author_text),
-            _first_venue_word(venue_text),
-        ]
-    )
-    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
-
-
-def _resolve_fingerprint(
-    *,
-    title: str,
-    year: int | None,
-    author_text: str | None,
-    venue_text: str | None,
-    provided_fingerprint: Any,
-) -> str:
-    normalized = _normalize_optional_text(provided_fingerprint)
-    if normalized and SHA256_RE.fullmatch(normalized.lower()):
-        return normalized.lower()
-    return _build_fingerprint(
-        title=title,
-        year=year,
-        author_text=author_text,
-        venue_text=venue_text,
-    )
-
-
-def _validate_import_sizes(
-    *,
-    scholars: list[dict[str, Any]],
-    publications: list[dict[str, Any]],
-) -> None:
-    if len(scholars) > MAX_IMPORT_SCHOLARS:
-        raise ImportExportError(f"Import exceeds max scholars ({MAX_IMPORT_SCHOLARS}).")
-    if len(publications) > MAX_IMPORT_PUBLICATIONS:
-        raise ImportExportError(
-            f"Import exceeds max publications ({MAX_IMPORT_PUBLICATIONS})."
-        )
diff --git a/build/lib/app/services/domains/portability/publication_import.py b/build/lib/app/services/domains/portability/publication_import.py
deleted file mode 100644
index 7654586..0000000
--- a/build/lib/app/services/domains/portability/publication_import.py
+++ /dev/null
@@ -1,370 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import Publication, ScholarProfile, ScholarPublication
-from app.services.domains.ingestion.application import build_publication_url, normalize_title
-from app.services.domains.doi.normalize import normalize_doi
-from app.services.domains.portability.normalize import (
-    _normalize_citation_count,
-    _normalize_optional_text,
-    _normalize_optional_year,
-    _resolve_fingerprint,
-)
-from app.services.domains.portability.types import ImportedPublicationInput
-
-
-async def _find_publication_by_cluster(
-    db_session: AsyncSession,
-    *,
-    cluster_id: str,
-) -> Publication | None:
-    result = await db_session.execute(
-        select(Publication).where(Publication.cluster_id == cluster_id)
-    )
-    return result.scalar_one_or_none()
-
-
-async def _find_publication_by_fingerprint(
-    db_session: AsyncSession,
-    *,
-    fingerprint_sha256: str,
-) -> Publication | None:
-    result = await db_session.execute(
-        select(Publication).where(Publication.fingerprint_sha256 == fingerprint_sha256)
-    )
-    return result.scalar_one_or_none()
-
-
-async def _find_linked_publication_by_title(
-    db_session: AsyncSession,
-    *,
-    scholar_profile_id: int,
-    title: str,
-) -> Publication | None:
-    normalized_title = normalize_title(title)
-    result = await db_session.execute(
-        select(Publication)
-        .join(
-            ScholarPublication,
-            ScholarPublication.publication_id == Publication.id,
-        )
-        .where(
-            ScholarPublication.scholar_profile_id == scholar_profile_id,
-            Publication.title_normalized == normalized_title,
-        )
-        .order_by(Publication.id.asc())
-        .limit(1)
-    )
-    return result.scalar_one_or_none()
-
-
-def _apply_imported_publication_values(
-    *,
-    publication: Publication,
-    title: str,
-    year: int | None,
-    citation_count: int,
-    author_text: str | None,
-    venue_text: str | None,
-    pub_url: str | None,
-    pdf_url: str | None,
-    cluster_id: str | None,
-) -> bool:
-    updated = False
-    if cluster_id and publication.cluster_id != cluster_id:
-        publication.cluster_id = cluster_id
-        updated = True
-    if publication.title_raw != title:
-        publication.title_raw = title
-        publication.title_normalized = normalize_title(title)
-        updated = True
-    if publication.year != year:
-        publication.year = year
-        updated = True
-    if int(publication.citation_count or 0) != citation_count:
-        publication.citation_count = citation_count
-        updated = True
-    if publication.author_text != author_text:
-        publication.author_text = author_text
-        updated = True
-    if publication.venue_text != venue_text:
-        publication.venue_text = venue_text
-        updated = True
-    if pub_url and publication.pub_url != pub_url:
-        publication.pub_url = pub_url
-        updated = True
-    if pdf_url and publication.pdf_url != pdf_url:
-        publication.pdf_url = pdf_url
-        updated = True
-    return updated
-
-
-def _new_publication(
-    *,
-    cluster_id: str | None,
-    fingerprint_sha256: str,
-    title: str,
-    year: int | None,
-    citation_count: int,
-    author_text: str | None,
-    venue_text: str | None,
-    pub_url: str | None,
-    pdf_url: str | None,
-) -> Publication:
-    return Publication(
-        cluster_id=cluster_id,
-        fingerprint_sha256=fingerprint_sha256,
-        title_raw=title,
-        title_normalized=normalize_title(title),
-        year=year,
-        citation_count=citation_count,
-        author_text=author_text,
-        venue_text=venue_text,
-        pub_url=pub_url,
-        pdf_url=pdf_url,
-    )
-
-
-async def _resolve_publication_for_import(
-    db_session: AsyncSession,
-    *,
-    scholar_profile_id: int,
-    title: str,
-    cluster_id: str | None,
-    fingerprint_sha256: str,
-    cluster_cache: dict[str, Publication | None],
-    fingerprint_cache: dict[str, Publication | None],
-) -> Publication | None:
-    if cluster_id:
-        if cluster_id not in cluster_cache:
-            cluster_cache[cluster_id] = await _find_publication_by_cluster(
-                db_session,
-                cluster_id=cluster_id,
-            )
-        if cluster_cache[cluster_id] is not None:
-            return cluster_cache[cluster_id]
-    if fingerprint_sha256 not in fingerprint_cache:
-        fingerprint_cache[fingerprint_sha256] = await _find_publication_by_fingerprint(
-            db_session,
-            fingerprint_sha256=fingerprint_sha256,
-        )
-    if fingerprint_cache[fingerprint_sha256] is not None:
-        return fingerprint_cache[fingerprint_sha256]
-    return await _find_linked_publication_by_title(
-        db_session,
-        scholar_profile_id=scholar_profile_id,
-        title=title,
-    )
-
-
-async def _upsert_scholar_publication_link(
-    db_session: AsyncSession,
-    *,
-    scholar_profile_id: int,
-    publication_id: int,
-    is_read: bool,
-) -> tuple[bool, bool]:
-    result = await db_session.execute(
-        select(ScholarPublication).where(
-            ScholarPublication.scholar_profile_id == scholar_profile_id,
-            ScholarPublication.publication_id == publication_id,
-        )
-    )
-    link = result.scalar_one_or_none()
-    if link is None:
-        db_session.add(
-            ScholarPublication(
-                scholar_profile_id=scholar_profile_id,
-                publication_id=publication_id,
-                is_read=bool(is_read),
-            )
-        )
-        return True, False
-    if bool(link.is_read) == bool(is_read):
-        return False, False
-    link.is_read = bool(is_read)
-    return False, True
-
-
-def _initialize_import_counters(counters: dict[str, int]) -> None:
-    counters.update(
-        {
-            "publications_created": 0,
-            "publications_updated": 0,
-            "links_created": 0,
-            "links_updated": 0,
-        }
-    )
-
-
-def _build_imported_publication_input(
-    *,
-    item: dict[str, Any],
-    scholar_map: dict[str, ScholarProfile],
-) -> ImportedPublicationInput | None:
-    scholar_id = _normalize_optional_text(item.get("scholar_id"))
-    title = _normalize_optional_text(item.get("title"))
-    if not scholar_id or not title:
-        return None
-
-    profile = scholar_map.get(scholar_id)
-    if profile is None:
-        return None
-
-    year = _normalize_optional_year(item.get("year"))
-    author_text = _normalize_optional_text(item.get("author_text"))
-    venue_text = _normalize_optional_text(item.get("venue_text"))
-    return ImportedPublicationInput(
-        profile=profile,
-        title=title,
-        year=year,
-        citation_count=_normalize_citation_count(item.get("citation_count")),
-        author_text=author_text,
-        venue_text=venue_text,
-        cluster_id=_normalize_optional_text(item.get("cluster_id")),
-        pub_url=build_publication_url(_normalize_optional_text(item.get("pub_url"))),
-        doi=normalize_doi(_normalize_optional_text(item.get("doi"))),
-        pdf_url=build_publication_url(_normalize_optional_text(item.get("pdf_url"))),
-        fingerprint=_resolve_fingerprint(
-            title=title,
-            year=year,
-            author_text=author_text,
-            venue_text=venue_text,
-            provided_fingerprint=item.get("fingerprint_sha256"),
-        ),
-        is_read=bool(item.get("is_read", False)),
-    )
-
-
-def _update_link_counters(
-    *,
-    counters: dict[str, int],
-    link_created: bool,
-    link_updated: bool,
-) -> None:
-    if link_created:
-        counters["links_created"] += 1
-    if link_updated:
-        counters["links_updated"] += 1
-
-
-def _cache_resolved_publication(
-    *,
-    publication: Publication,
-    cluster_id: str | None,
-    fingerprint_sha256: str,
-    cluster_cache: dict[str, Publication | None],
-    fingerprint_cache: dict[str, Publication | None],
-) -> None:
-    if cluster_id:
-        cluster_cache[cluster_id] = publication
-    fingerprint_cache[fingerprint_sha256] = publication
-
-
-async def _create_import_publication(
-    db_session: AsyncSession,
-    *,
-    payload: ImportedPublicationInput,
-) -> Publication:
-    publication = _new_publication(
-        cluster_id=payload.cluster_id,
-        fingerprint_sha256=payload.fingerprint,
-        title=payload.title,
-        year=payload.year,
-        citation_count=payload.citation_count,
-        author_text=payload.author_text,
-        venue_text=payload.venue_text,
-        pub_url=payload.pub_url,
-        pdf_url=payload.pdf_url,
-    )
-    db_session.add(publication)
-    await db_session.flush()
-    return publication
-
-
-def _update_import_publication(
-    *,
-    publication: Publication,
-    payload: ImportedPublicationInput,
-) -> bool:
-    return _apply_imported_publication_values(
-        publication=publication,
-        title=payload.title,
-        year=payload.year,
-        citation_count=payload.citation_count,
-        author_text=payload.author_text,
-        venue_text=payload.venue_text,
-        pub_url=payload.pub_url,
-        pdf_url=payload.pdf_url,
-        cluster_id=payload.cluster_id,
-    )
-
-
-async def _upsert_publication_entity(
-    db_session: AsyncSession,
-    *,
-    payload: ImportedPublicationInput,
-    cluster_cache: dict[str, Publication | None],
-    fingerprint_cache: dict[str, Publication | None],
-) -> tuple[Publication, bool, bool]:
-    publication = await _resolve_publication_for_import(
-        db_session,
-        scholar_profile_id=int(payload.profile.id),
-        title=payload.title,
-        cluster_id=payload.cluster_id,
-        fingerprint_sha256=payload.fingerprint,
-        cluster_cache=cluster_cache,
-        fingerprint_cache=fingerprint_cache,
-    )
-    created = False
-    updated = False
-    if publication is None:
-        publication = await _create_import_publication(db_session, payload=payload)
-        created = True
-    else:
-        updated = _update_import_publication(publication=publication, payload=payload)
-
-    _cache_resolved_publication(
-        publication=publication,
-        cluster_id=payload.cluster_id,
-        fingerprint_sha256=payload.fingerprint,
-        cluster_cache=cluster_cache,
-        fingerprint_cache=fingerprint_cache,
-    )
-    return publication, created, updated
-
-
-async def _upsert_imported_publication(
-    db_session: AsyncSession,
-    *,
-    payload: ImportedPublicationInput,
-    cluster_cache: dict[str, Publication | None],
-    fingerprint_cache: dict[str, Publication | None],
-    counters: dict[str, int],
-) -> None:
-    publication, created, updated = await _upsert_publication_entity(
-        db_session,
-        payload=payload,
-        cluster_cache=cluster_cache,
-        fingerprint_cache=fingerprint_cache,
-    )
-    if created:
-        counters["publications_created"] += 1
-    if updated:
-        counters["publications_updated"] += 1
-
-    link_created, link_updated = await _upsert_scholar_publication_link(
-        db_session,
-        scholar_profile_id=int(payload.profile.id),
-        publication_id=int(publication.id),
-        is_read=payload.is_read,
-    )
-    _update_link_counters(
-        counters=counters,
-        link_created=link_created,
-        link_updated=link_updated,
-    )
diff --git a/build/lib/app/services/domains/portability/scholar_import.py b/build/lib/app/services/domains/portability/scholar_import.py
deleted file mode 100644
index 74e6ec1..0000000
--- a/build/lib/app/services/domains/portability/scholar_import.py
+++ /dev/null
@@ -1,107 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import ScholarProfile
-from app.services.domains.portability.normalize import _normalize_optional_text
-from app.services.domains.scholars import application as scholar_service
-
-
-async def _load_user_scholar_map(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-) -> dict[str, ScholarProfile]:
-    result = await db_session.execute(
-        select(ScholarProfile).where(ScholarProfile.user_id == user_id)
-    )
-    profiles = list(result.scalars().all())
-    return {profile.scholar_id: profile for profile in profiles}
-
-
-def _apply_imported_scholar_values(
-    *,
-    profile: ScholarProfile,
-    display_name: str | None,
-    profile_image_override_url: str | None,
-    is_enabled: bool,
-) -> bool:
-    updated = False
-    if display_name and profile.display_name != display_name:
-        profile.display_name = display_name
-        updated = True
-    if profile.profile_image_override_url != profile_image_override_url:
-        profile.profile_image_override_url = profile_image_override_url
-        updated = True
-    if bool(profile.is_enabled) != bool(is_enabled):
-        profile.is_enabled = bool(is_enabled)
-        updated = True
-    return updated
-
-
-def _new_scholar_profile(
-    *,
-    user_id: int,
-    scholar_id: str,
-    display_name: str | None,
-    profile_image_override_url: str | None,
-    is_enabled: bool,
-) -> ScholarProfile:
-    return ScholarProfile(
-        user_id=user_id,
-        scholar_id=scholar_id,
-        display_name=display_name,
-        profile_image_override_url=profile_image_override_url,
-        is_enabled=bool(is_enabled),
-    )
-
-
-async def _upsert_imported_scholars(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholars: list[dict[str, Any]],
-) -> tuple[dict[str, ScholarProfile], dict[str, int]]:
-    scholar_map = await _load_user_scholar_map(db_session, user_id=user_id)
-    counters = {"scholars_created": 0, "scholars_updated": 0, "skipped_records": 0}
-    for item in scholars:
-        try:
-            scholar_id = scholar_service.validate_scholar_id(str(item["scholar_id"]))
-            display_name = scholar_service.normalize_display_name(
-                str(item.get("display_name") or "")
-            )
-            override_url = scholar_service.normalize_profile_image_url(
-                _normalize_optional_text(item.get("profile_image_override_url"))
-            )
-        except (KeyError, scholar_service.ScholarServiceError):
-            counters["skipped_records"] += 1
-            continue
-
-        is_enabled = bool(item.get("is_enabled", True))
-        existing = scholar_map.get(scholar_id)
-        if existing is None:
-            profile = _new_scholar_profile(
-                user_id=user_id,
-                scholar_id=scholar_id,
-                display_name=display_name,
-                profile_image_override_url=override_url,
-                is_enabled=is_enabled,
-            )
-            db_session.add(profile)
-            scholar_map[scholar_id] = profile
-            counters["scholars_created"] += 1
-            continue
-
-        if _apply_imported_scholar_values(
-            profile=existing,
-            display_name=display_name,
-            profile_image_override_url=override_url,
-            is_enabled=is_enabled,
-        ):
-            counters["scholars_updated"] += 1
-
-    await db_session.flush()
-    return scholar_map, counters
diff --git a/build/lib/app/services/domains/portability/types.py b/build/lib/app/services/domains/portability/types.py
deleted file mode 100644
index 2a7f6e8..0000000
--- a/build/lib/app/services/domains/portability/types.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from app.db.models import ScholarProfile
-
-
-class ImportExportError(ValueError):
-    """Raised when import/export payload constraints are violated."""
-
-
-@dataclass(frozen=True)
-class ImportedPublicationInput:
-    profile: ScholarProfile
-    title: str
-    year: int | None
-    citation_count: int
-    author_text: str | None
-    venue_text: str | None
-    cluster_id: str | None
-    pub_url: str | None
-    doi: str | None
-    pdf_url: str | None
-    fingerprint: str
-    is_read: bool
diff --git a/build/lib/app/services/domains/publication_identifiers/__init__.py b/build/lib/app/services/domains/publication_identifiers/__init__.py
deleted file mode 100644
index 3a35c66..0000000
--- a/build/lib/app/services/domains/publication_identifiers/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from app.services.domains.publication_identifiers.application import (
-    DisplayIdentifier,
-    derive_display_identifier_from_values,
-    overlay_pdf_queue_items_with_display_identifiers,
-    overlay_publication_items_with_display_identifiers,
-    sync_identifiers_for_publication_fields,
-    sync_identifiers_for_publication_resolution,
-)
-
-__all__ = [
-    "DisplayIdentifier",
-    "derive_display_identifier_from_values",
-    "overlay_pdf_queue_items_with_display_identifiers",
-    "overlay_publication_items_with_display_identifiers",
-    "sync_identifiers_for_publication_fields",
-    "sync_identifiers_for_publication_resolution",
-]
diff --git a/build/lib/app/services/domains/publication_identifiers/application.py b/build/lib/app/services/domains/publication_identifiers/application.py
deleted file mode 100644
index ca57d57..0000000
--- a/build/lib/app/services/domains/publication_identifiers/application.py
+++ /dev/null
@@ -1,433 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import replace
-from typing import TYPE_CHECKING
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import Publication, PublicationIdentifier
-from app.services.domains.doi.normalize import normalize_doi
-from app.services.domains.publication_identifiers.normalize import (
-    normalize_arxiv_id,
-    normalize_pmcid,
-    normalize_pmid,
-)
-from app.services.domains.publication_identifiers.types import (
-    DisplayIdentifier,
-    IdentifierCandidate,
-    IdentifierKind,
-)
-
-if TYPE_CHECKING:
-    from app.services.domains.publications.pdf_queue import PdfQueueListItem
-    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
-
-CONFIDENCE_HIGH = 0.98
-CONFIDENCE_MEDIUM = 0.9
-CONFIDENCE_LOW = 0.6
-CONFIDENCE_FALLBACK = 0.4
-PRIORITY_DOI = 400
-PRIORITY_ARXIV = 300
-PRIORITY_PMCID = 200
-PRIORITY_PMID = 100
-
-
-def derive_display_identifier_from_values(
-    *,
-    doi: str | None,
-    pub_url: str | None = None,
-    pdf_url: str | None = None,
-) -> DisplayIdentifier | None:
-    candidates = _fallback_candidates_from_values(doi=doi, pub_url=pub_url, pdf_url=pdf_url)
-    return _best_display_identifier(candidates)
-
-
-def _fallback_candidates_from_values(
-    *,
-    doi: str | None,
-    pub_url: str | None,
-    pdf_url: str | None,
-) -> list[IdentifierCandidate]:
-    values = [value for value in [pub_url, pdf_url] if value]
-    candidates = []
-    if doi:
-        normalized_doi = normalize_doi(doi)
-        if normalized_doi:
-            candidates.append(_candidate(IdentifierKind.DOI, doi, normalized_doi, "legacy_doi", CONFIDENCE_HIGH, pub_url))
-    candidates.extend(_url_identifier_candidates(values=values, source="legacy_urls"))
-    return _dedup_candidates(candidates)
-
-
-def _url_identifier_candidates(*, values: list[str], source: str) -> list[IdentifierCandidate]:
-    candidates: list[IdentifierCandidate] = []
-    for value in values:
-        candidates.extend(_url_candidates_for_value(value=value, source=source))
-    return candidates
-
-
-def _url_candidates_for_value(*, value: str, source: str) -> list[IdentifierCandidate]:
-    candidates: list[IdentifierCandidate] = []
-    arxiv = normalize_arxiv_id(value)
-    if arxiv:
-        candidates.append(_candidate(IdentifierKind.ARXIV, value, arxiv, source, CONFIDENCE_MEDIUM, value))
-    pmcid = normalize_pmcid(value)
-    if pmcid:
-        candidates.append(_candidate(IdentifierKind.PMCID, value, pmcid, source, CONFIDENCE_LOW, value))
-    pmid = normalize_pmid(value)
-    if pmid:
-        candidates.append(_candidate(IdentifierKind.PMID, value, pmid, source, CONFIDENCE_FALLBACK, value))
-    return candidates
-
-
-def _candidate(
-    kind: IdentifierKind,
-    value_raw: str,
-    value_normalized: str,
-    source: str,
-    confidence_score: float,
-    evidence_url: str | None,
-) -> IdentifierCandidate:
-    return IdentifierCandidate(
-        kind=kind,
-        value_raw=value_raw,
-        value_normalized=value_normalized,
-        source=source,
-        confidence_score=float(confidence_score),
-        evidence_url=evidence_url,
-    )
-
-
-def _dedup_candidates(candidates: list[IdentifierCandidate]) -> list[IdentifierCandidate]:
-    deduped: dict[tuple[str, str], IdentifierCandidate] = {}
-    for candidate in candidates:
-        key = (candidate.kind.value, candidate.value_normalized)
-        current = deduped.get(key)
-        if current is None or candidate.confidence_score > current.confidence_score:
-            deduped[key] = candidate
-    return list(deduped.values())
-
-
-async def sync_identifiers_for_publication_fields(
-    db_session: AsyncSession,
-    *,
-    publication: Publication,
-) -> None:
-    candidates = _publication_field_candidates(publication)
-    await _upsert_publication_candidates(db_session, publication_id=int(publication.id), candidates=candidates)
-
-
-async def discover_and_sync_identifiers_for_publication(
-    db_session: AsyncSession,
-    *,
-    publication: Publication,
-    scholar_label: str,
-) -> None:
-    await sync_identifiers_for_publication_fields(db_session, publication=publication)
-    
-    existing_doi = await _existing_identifier_by_kind(
-        db_session,
-        publication_id=int(publication.id),
-        kind=IdentifierKind.DOI.value,
-    )
-    if existing_doi is not None:
-        return
-
-    from app.services.domains.crossref import application as crossref_service
-    from app.services.domains.publications.types import UnreadPublicationItem
-    
-    item = UnreadPublicationItem(
-        publication_id=int(publication.id),
-        scholar_profile_id=0,
-        scholar_label=scholar_label,
-        title=str(publication.title_raw or ""),
-        year=publication.year,
-        citation_count=publication.citation_count,
-        venue_text=publication.venue_text,
-        pub_url=publication.pub_url,
-        pdf_url=publication.pdf_url,
-    )
-    
-    discovered_doi = await crossref_service.discover_doi_for_publication(item=item)
-    if discovered_doi:
-        normalized_doi = normalize_doi(discovered_doi)
-        if normalized_doi:
-            candidate = _candidate(
-                IdentifierKind.DOI,
-                discovered_doi,
-                normalized_doi,
-                "crossref_api",
-                CONFIDENCE_MEDIUM,
-                None,
-            )
-            await _upsert_publication_candidate(db_session, publication_id=int(publication.id), candidate=candidate)
-
-    existing_arxiv = await _existing_identifier_by_kind(
-        db_session,
-        publication_id=int(publication.id),
-        kind=IdentifierKind.ARXIV.value,
-    )
-    if existing_arxiv is None:
-        from app.services.domains.arxiv import application as arxiv_service
-        discovered_arxiv = await arxiv_service.discover_arxiv_id_for_publication(item=item)
-        if discovered_arxiv:
-            normalized_arxiv = normalize_arxiv_id(discovered_arxiv)
-            if normalized_arxiv:
-                candidate = _candidate(
-                    IdentifierKind.ARXIV,
-                    discovered_arxiv,
-                    normalized_arxiv,
-                    "arxiv_api",
-                    CONFIDENCE_MEDIUM,
-                    None,
-                )
-                await _upsert_publication_candidate(db_session, publication_id=int(publication.id), candidate=candidate)
-
-
-def _publication_field_candidates(publication: Publication) -> list[IdentifierCandidate]:
-    return _fallback_candidates_from_values(
-        doi=None,
-        pub_url=publication.pub_url,
-        pdf_url=publication.pdf_url,
-    )
-
-
-async def sync_identifiers_for_publication_resolution(
-    db_session: AsyncSession,
-    *,
-    publication: Publication,
-    source: str | None,
-) -> None:
-    candidates = _publication_field_candidates(publication)
-    rewritten = [_candidate_with_source(candidate, source=source) for candidate in candidates]
-    await _upsert_publication_candidates(db_session, publication_id=int(publication.id), candidates=rewritten)
-
-
-def _candidate_with_source(candidate: IdentifierCandidate, *, source: str | None) -> IdentifierCandidate:
-    if not source:
-        return candidate
-    return IdentifierCandidate(
-        kind=candidate.kind,
-        value_raw=candidate.value_raw,
-        value_normalized=candidate.value_normalized,
-        source=source,
-        confidence_score=candidate.confidence_score,
-        evidence_url=candidate.evidence_url,
-    )
-
-
-async def _upsert_publication_candidates(
-    db_session: AsyncSession,
-    *,
-    publication_id: int,
-    candidates: list[IdentifierCandidate],
-) -> None:
-    for candidate in _dedup_candidates(candidates):
-        await _upsert_publication_candidate(db_session, publication_id=publication_id, candidate=candidate)
-
-
-async def _upsert_publication_candidate(
-    db_session: AsyncSession,
-    *,
-    publication_id: int,
-    candidate: IdentifierCandidate,
-) -> None:
-    existing = await _existing_identifier(
-        db_session,
-        publication_id=publication_id,
-        kind=candidate.kind.value,
-        value_normalized=candidate.value_normalized,
-    )
-    if existing is None:
-        db_session.add(_new_identifier_row(publication_id=publication_id, candidate=candidate))
-        return
-    _merge_identifier_row(existing, candidate=candidate)
-
-
-async def _existing_identifier(
-    db_session: AsyncSession,
-    *,
-    publication_id: int,
-    kind: str,
-    value_normalized: str,
-) -> PublicationIdentifier | None:
-    result = await db_session.execute(
-        select(PublicationIdentifier).where(
-            PublicationIdentifier.publication_id == publication_id,
-            PublicationIdentifier.kind == kind,
-            PublicationIdentifier.value_normalized == value_normalized,
-        )
-    )
-    return result.scalar_one_or_none()
-
-
-async def _existing_identifier_by_kind(
-    db_session: AsyncSession,
-    *,
-    publication_id: int,
-    kind: str,
-) -> PublicationIdentifier | None:
-    result = await db_session.execute(
-        select(PublicationIdentifier).where(
-            PublicationIdentifier.publication_id == publication_id,
-            PublicationIdentifier.kind == kind,
-        ).order_by(PublicationIdentifier.confidence_score.desc()).limit(1)
-    )
-    return result.scalar_one_or_none()
-
-
-def _new_identifier_row(
-    *,
-    publication_id: int,
-    candidate: IdentifierCandidate,
-) -> PublicationIdentifier:
-    return PublicationIdentifier(
-        publication_id=publication_id,
-        kind=candidate.kind.value,
-        value_raw=candidate.value_raw,
-        value_normalized=candidate.value_normalized,
-        source=candidate.source,
-        confidence_score=candidate.confidence_score,
-        evidence_url=candidate.evidence_url,
-    )
-
-
-def _merge_identifier_row(existing: PublicationIdentifier, *, candidate: IdentifierCandidate) -> None:
-    if candidate.confidence_score >= float(existing.confidence_score):
-        existing.value_raw = candidate.value_raw
-        existing.source = candidate.source
-        existing.confidence_score = candidate.confidence_score
-        if candidate.evidence_url:
-            existing.evidence_url = candidate.evidence_url
-
-
-async def overlay_publication_items_with_display_identifiers(
-    db_session: AsyncSession,
-    *,
-    items: list[PublicationListItem],
-) -> list[PublicationListItem]:
-    if not items:
-        return []
-    mapping = await _display_identifier_map(db_session, publication_ids=[item.publication_id for item in items])
-    return [_overlay_publication_item(item, mapping.get(item.publication_id)) for item in items]
-
-
-def _overlay_publication_item(
-    item: PublicationListItem,
-    display_identifier: DisplayIdentifier | None,
-) -> PublicationListItem:
-    fallback = display_identifier or derive_display_identifier_from_values(doi=None, pub_url=item.pub_url, pdf_url=item.pdf_url)
-    return replace(item, display_identifier=fallback)
-
-
-async def overlay_pdf_queue_items_with_display_identifiers(
-    db_session: AsyncSession,
-    *,
-    items: list[PdfQueueListItem],
-) -> list[PdfQueueListItem]:
-    if not items:
-        return []
-    mapping = await _display_identifier_map(db_session, publication_ids=[item.publication_id for item in items])
-    return [_overlay_queue_item(item, mapping.get(item.publication_id)) for item in items]
-
-
-def _overlay_queue_item(
-    item: PdfQueueListItem,
-    display_identifier: DisplayIdentifier | None,
-) -> PdfQueueListItem:
-    fallback = display_identifier or derive_display_identifier_from_values(doi=None, pdf_url=item.pdf_url)
-    return replace(item, display_identifier=fallback)
-
-
-async def _display_identifier_map(
-    db_session: AsyncSession,
-    *,
-    publication_ids: list[int],
-) -> dict[int, DisplayIdentifier]:
-    normalized_ids = sorted({int(value) for value in publication_ids if int(value) > 0})
-    if not normalized_ids:
-        return {}
-    result = await db_session.execute(
-        select(PublicationIdentifier).where(PublicationIdentifier.publication_id.in_(normalized_ids))
-    )
-    rows = list(result.scalars().all())
-    return _best_display_identifier_map(rows)
-
-
-def _best_display_identifier_map(rows: list[PublicationIdentifier]) -> dict[int, DisplayIdentifier]:
-    grouped: dict[int, list[IdentifierCandidate]] = {}
-    for row in rows:
-        grouped.setdefault(int(row.publication_id), []).append(_candidate_from_row(row))
-    return {
-        publication_id: display
-        for publication_id, display in (
-            (publication_id, _best_display_identifier(candidates))
-            for publication_id, candidates in grouped.items()
-        )
-        if display is not None
-    }
-
-
-def _candidate_from_row(row: PublicationIdentifier) -> IdentifierCandidate:
-    return IdentifierCandidate(
-        kind=IdentifierKind(str(row.kind)),
-        value_raw=str(row.value_raw),
-        value_normalized=str(row.value_normalized),
-        source=str(row.source),
-        confidence_score=float(row.confidence_score),
-        evidence_url=row.evidence_url,
-    )
-
-
-def _best_display_identifier(candidates: list[IdentifierCandidate]) -> DisplayIdentifier | None:
-    if not candidates:
-        return None
-    ordered = sorted(candidates, key=_display_sort_key, reverse=True)
-    return _display_identifier_from_candidate(ordered[0])
-
-
-def _display_sort_key(candidate: IdentifierCandidate) -> tuple[int, float]:
-    return (_kind_priority(candidate.kind), float(candidate.confidence_score))
-
-
-def _kind_priority(kind: IdentifierKind) -> int:
-    if kind == IdentifierKind.DOI:
-        return PRIORITY_DOI
-    if kind == IdentifierKind.ARXIV:
-        return PRIORITY_ARXIV
-    if kind == IdentifierKind.PMCID:
-        return PRIORITY_PMCID
-    return PRIORITY_PMID
-
-
-def _display_identifier_from_candidate(candidate: IdentifierCandidate) -> DisplayIdentifier:
-    value = candidate.value_normalized
-    return DisplayIdentifier(
-        kind=candidate.kind.value,
-        value=value,
-        label=_display_label(candidate.kind, value),
-        url=_identifier_url(candidate.kind, value),
-        confidence_score=float(candidate.confidence_score),
-    )
-
-
-def _display_label(kind: IdentifierKind, value: str) -> str:
-    if kind == IdentifierKind.DOI:
-        return f"DOI: {value}"
-    if kind == IdentifierKind.ARXIV:
-        return f"arXiv: {value}"
-    if kind == IdentifierKind.PMCID:
-        return f"PMCID: {value}"
-    return f"PMID: {value}"
-
-
-def _identifier_url(kind: IdentifierKind, value: str) -> str | None:
-    if kind == IdentifierKind.DOI:
-        return f"https://doi.org/{value}"
-    if kind == IdentifierKind.ARXIV:
-        return f"https://arxiv.org/abs/{value}"
-    if kind == IdentifierKind.PMCID:
-        return f"https://pmc.ncbi.nlm.nih.gov/articles/{value}/"
-    if kind == IdentifierKind.PMID:
-        return f"https://pubmed.ncbi.nlm.nih.gov/{value}/"
-    return None
diff --git a/build/lib/app/services/domains/publication_identifiers/normalize.py b/build/lib/app/services/domains/publication_identifiers/normalize.py
deleted file mode 100644
index 9f7484a..0000000
--- a/build/lib/app/services/domains/publication_identifiers/normalize.py
+++ /dev/null
@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import re
-from urllib.parse import urlparse
-
-from app.services.domains.doi.normalize import normalize_doi
-from app.services.domains.publication_identifiers.types import IdentifierKind
-
-ARXIV_ABS_RE = re.compile(r"\barxiv:\s*([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?\b", re.I)
-ARXIV_PATH_RE = re.compile(r"^/(?:abs|pdf|html|ps|format)/([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?(?:\.pdf)?/?$", re.I)
-PMCID_RE = re.compile(r"\b(PMC\d+)\b", re.I)
-PUBMED_PATH_RE = re.compile(r"^/(\d+)/?$")
-
-
-def normalize_identifier(kind: IdentifierKind, value: str | None) -> str | None:
-    if kind == IdentifierKind.DOI:
-        return normalize_doi(value)
-    if kind == IdentifierKind.ARXIV:
-        return normalize_arxiv_id(value)
-    if kind == IdentifierKind.PMCID:
-        return normalize_pmcid(value)
-    if kind == IdentifierKind.PMID:
-        return normalize_pmid(value)
-    return None
-
-
-def normalize_arxiv_id(value: str | None) -> str | None:
-    text = (value or "").strip()
-    if not text:
-        return None
-    parsed = urlparse(text)
-    if parsed.scheme in {"http", "https"} and "arxiv.org" in parsed.netloc.lower():
-        return _arxiv_from_path(parsed.path)
-    match = ARXIV_ABS_RE.search(text)
-    if not match:
-        return None
-    version = (match.group(2) or "").lower()
-    return f"{match.group(1).lower()}{version}"
-
-
-def _arxiv_from_path(path: str) -> str | None:
-    match = ARXIV_PATH_RE.match(path or "")
-    if not match:
-        return None
-    version = (match.group(2) or "").lower()
-    return f"{match.group(1).lower()}{version}"
-
-
-def normalize_pmcid(value: str | None) -> str | None:
-    text = (value or "").strip()
-    if not text:
-        return None
-    parsed = urlparse(text)
-    if parsed.scheme in {"http", "https"} and "ncbi.nlm.nih.gov" in parsed.netloc.lower():
-        return _first_match(PMCID_RE, parsed.path)
-    return _first_match(PMCID_RE, text)
-
-
-def normalize_pmid(value: str | None) -> str | None:
-    text = (value or "").strip()
-    if not text:
-        return None
-    parsed = urlparse(text)
-    if parsed.scheme in {"http", "https"} and "pubmed.ncbi.nlm.nih.gov" in parsed.netloc.lower():
-        match = PUBMED_PATH_RE.match(parsed.path or "")
-        if not match:
-            return None
-        return match.group(1)
-    return None
-
-
-def _first_match(pattern: re.Pattern[str], value: str) -> str | None:
-    match = pattern.search(value)
-    if not match:
-        return None
-    return match.group(1).upper()
diff --git a/build/lib/app/services/domains/publication_identifiers/types.py b/build/lib/app/services/domains/publication_identifiers/types.py
deleted file mode 100644
index 34b20d0..0000000
--- a/build/lib/app/services/domains/publication_identifiers/types.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from enum import StrEnum
-
-
-class IdentifierKind(StrEnum):
-    DOI = "doi"
-    ARXIV = "arxiv"
-    PMCID = "pmcid"
-    PMID = "pmid"
-
-
-@dataclass(frozen=True)
-class DisplayIdentifier:
-    kind: str
-    value: str
-    label: str
-    url: str | None
-    confidence_score: float
-
-
-@dataclass(frozen=True)
-class IdentifierCandidate:
-    kind: IdentifierKind
-    value_raw: str
-    value_normalized: str
-    source: str
-    confidence_score: float
-    evidence_url: str | None
diff --git a/build/lib/app/services/domains/publications/__init__.py b/build/lib/app/services/domains/publications/__init__.py
deleted file mode 100644
index 371b02c..0000000
--- a/build/lib/app/services/domains/publications/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from app.services.domains.publications.application import *
diff --git a/build/lib/app/services/domains/publications/application.py b/build/lib/app/services/domains/publications/application.py
deleted file mode 100644
index b1161fb..0000000
--- a/build/lib/app/services/domains/publications/application.py
+++ /dev/null
@@ -1,74 +0,0 @@
-from __future__ import annotations
-
-from app.services.domains.publications.counts import (
-    count_for_user,
-    count_favorite_for_user,
-    count_latest_for_user,
-    count_unread_for_user,
-)
-from app.services.domains.publications.listing import (
-    list_for_user,
-    retry_pdf_for_user,
-    list_unread_for_user,
-)
-from app.services.domains.publications.enrichment import (
-    hydrate_pdf_enrichment_state,
-    schedule_missing_pdf_enrichment_for_user,
-    schedule_retry_pdf_enrichment_for_row,
-)
-from app.services.domains.publications.modes import (
-    MODE_ALL,
-    MODE_LATEST,
-    MODE_NEW,
-    MODE_UNREAD,
-    resolve_publication_view_mode,
-)
-from app.services.domains.publications.queries import (
-    get_latest_completed_run_id_for_user,
-    get_publication_item_for_user,
-    publications_query,
-)
-from app.services.domains.publications.read_state import (
-    mark_all_unread_as_read_for_user,
-    mark_selected_as_read_for_user,
-    set_publication_favorite_for_user,
-)
-from app.services.domains.publications.pdf_queue import (
-    count_pdf_queue_items,
-    enqueue_all_missing_pdf_jobs,
-    enqueue_retry_pdf_job_for_publication_id,
-    list_pdf_queue_page,
-    list_pdf_queue_items,
-)
-from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
-
-__all__ = [
-    "MODE_ALL",
-    "MODE_UNREAD",
-    "MODE_LATEST",
-    "MODE_NEW",
-    "PublicationListItem",
-    "UnreadPublicationItem",
-    "resolve_publication_view_mode",
-    "get_latest_completed_run_id_for_user",
-    "publications_query",
-    "get_publication_item_for_user",
-    "list_for_user",
-    "list_unread_for_user",
-    "retry_pdf_for_user",
-    "hydrate_pdf_enrichment_state",
-    "schedule_retry_pdf_enrichment_for_row",
-    "list_pdf_queue_items",
-    "list_pdf_queue_page",
-    "count_pdf_queue_items",
-    "enqueue_all_missing_pdf_jobs",
-    "enqueue_retry_pdf_job_for_publication_id",
-    "schedule_missing_pdf_enrichment_for_user",
-    "count_for_user",
-    "count_favorite_for_user",
-    "count_unread_for_user",
-    "count_latest_for_user",
-    "mark_all_unread_as_read_for_user",
-    "mark_selected_as_read_for_user",
-    "set_publication_favorite_for_user",
-]
diff --git a/build/lib/app/services/domains/publications/counts.py b/build/lib/app/services/domains/publications/counts.py
deleted file mode 100644
index 8f65172..0000000
--- a/build/lib/app/services/domains/publications/counts.py
+++ /dev/null
@@ -1,90 +0,0 @@
-from __future__ import annotations
-
-from sqlalchemy import func, select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import ScholarProfile, ScholarPublication
-from app.services.domains.publications.modes import (
-    MODE_ALL,
-    MODE_LATEST,
-    MODE_UNREAD,
-    resolve_publication_view_mode,
-)
-from app.services.domains.publications.queries import get_latest_completed_run_id_for_user
-
-
-async def count_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    mode: str = MODE_ALL,
-    scholar_profile_id: int | None = None,
-    favorite_only: bool = False,
-) -> int:
-    resolved_mode = resolve_publication_view_mode(mode)
-    latest_run_id = await get_latest_completed_run_id_for_user(db_session, user_id=user_id)
-    stmt = (
-        select(func.count())
-        .select_from(ScholarPublication)
-        .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
-        .where(ScholarProfile.user_id == user_id)
-    )
-    if scholar_profile_id is not None:
-        stmt = stmt.where(ScholarProfile.id == scholar_profile_id)
-    if favorite_only:
-        stmt = stmt.where(ScholarPublication.is_favorite.is_(True))
-    if resolved_mode == MODE_UNREAD:
-        stmt = stmt.where(ScholarPublication.is_read.is_(False))
-    if resolved_mode == MODE_LATEST:
-        if latest_run_id is None:
-            return 0
-        stmt = stmt.where(ScholarPublication.first_seen_run_id == latest_run_id)
-    result = await db_session.execute(stmt)
-    return int(result.scalar_one() or 0)
-
-
-async def count_unread_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int | None = None,
-    favorite_only: bool = False,
-) -> int:
-    return await count_for_user(
-        db_session,
-        user_id=user_id,
-        mode=MODE_UNREAD,
-        scholar_profile_id=scholar_profile_id,
-        favorite_only=favorite_only,
-    )
-
-
-async def count_latest_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int | None = None,
-    favorite_only: bool = False,
-) -> int:
-    return await count_for_user(
-        db_session,
-        user_id=user_id,
-        mode=MODE_LATEST,
-        scholar_profile_id=scholar_profile_id,
-        favorite_only=favorite_only,
-    )
-
-
-async def count_favorite_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int | None = None,
-) -> int:
-    return await count_for_user(
-        db_session,
-        user_id=user_id,
-        mode=MODE_ALL,
-        scholar_profile_id=scholar_profile_id,
-        favorite_only=True,
-    )
diff --git a/build/lib/app/services/domains/publications/enrichment.py b/build/lib/app/services/domains/publications/enrichment.py
deleted file mode 100644
index 381107a..0000000
--- a/build/lib/app/services/domains/publications/enrichment.py
+++ /dev/null
@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.services.domains.publications.pdf_queue import (
-    enqueue_missing_pdf_jobs,
-    enqueue_retry_pdf_job,
-    overlay_pdf_job_state,
-)
-from app.services.domains.publications.types import PublicationListItem
-
-logger = logging.getLogger(__name__)
-
-
-async def schedule_missing_pdf_enrichment_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    request_email: str | None,
-    items: list[PublicationListItem],
-    max_items: int,
-) -> int:
-    queued_ids = await enqueue_missing_pdf_jobs(
-        db_session,
-        user_id=user_id,
-        request_email=request_email,
-        rows=items,
-        max_items=max_items,
-    )
-    logger.info(
-        "publications.enrichment.scheduled",
-        extra={
-            "event": "publications.enrichment.scheduled",
-            "user_id": user_id,
-            "publication_count": len(queued_ids),
-        },
-    )
-    return len(queued_ids)
-
-
-async def schedule_retry_pdf_enrichment_for_row(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    request_email: str | None,
-    item: PublicationListItem,
-) -> bool:
-    queued = await enqueue_retry_pdf_job(
-        db_session,
-        user_id=user_id,
-        request_email=request_email,
-        row=item,
-    )
-    logger.info(
-        "publications.enrichment.retry_scheduled",
-        extra={
-            "event": "publications.enrichment.retry_scheduled",
-            "user_id": user_id,
-            "publication_id": item.publication_id,
-            "queued": queued,
-        },
-    )
-    return queued
-
-
-async def hydrate_pdf_enrichment_state(
-    db_session: AsyncSession,
-    *,
-    items: list[PublicationListItem],
-) -> list[PublicationListItem]:
-    return await overlay_pdf_job_state(db_session, rows=items)
diff --git a/build/lib/app/services/domains/publications/listing.py b/build/lib/app/services/domains/publications/listing.py
deleted file mode 100644
index 0d09d4c..0000000
--- a/build/lib/app/services/domains/publications/listing.py
+++ /dev/null
@@ -1,93 +0,0 @@
-from __future__ import annotations
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.services.domains.publication_identifiers import application as identifier_service
-from app.services.domains.publications.modes import (
-    MODE_ALL,
-    MODE_UNREAD,
-    resolve_publication_view_mode,
-)
-from app.services.domains.publications.queries import (
-    get_latest_completed_run_id_for_user,
-    get_publication_item_for_user,
-    publication_list_item_from_row,
-    publications_query,
-    unread_item_from_row,
-)
-from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
-
-
-async def list_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    mode: str = MODE_ALL,
-    scholar_profile_id: int | None = None,
-    favorite_only: bool = False,
-    limit: int = 300,
-    offset: int = 0,
-) -> list[PublicationListItem]:
-    resolved_mode = resolve_publication_view_mode(mode)
-    latest_run_id = await get_latest_completed_run_id_for_user(db_session, user_id=user_id)
-    result = await db_session.execute(
-        publications_query(
-            user_id=user_id,
-            mode=resolved_mode,
-            latest_run_id=latest_run_id,
-            scholar_profile_id=scholar_profile_id,
-            favorite_only=favorite_only,
-            limit=limit,
-            offset=offset,
-        )
-    )
-    rows = [
-        publication_list_item_from_row(row, latest_run_id=latest_run_id)
-        for row in result.all()
-    ]
-    return await identifier_service.overlay_publication_items_with_display_identifiers(
-        db_session,
-        items=rows,
-    )
-
-
-async def retry_pdf_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int,
-    publication_id: int,
-) -> PublicationListItem | None:
-    item = await get_publication_item_for_user(
-        db_session,
-        user_id=user_id,
-        scholar_profile_id=scholar_profile_id,
-        publication_id=publication_id,
-    )
-    if item is None:
-        return None
-    hydrated = await identifier_service.overlay_publication_items_with_display_identifiers(
-        db_session,
-        items=[item],
-    )
-    return hydrated[0] if hydrated else item
-
-
-async def list_unread_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    limit: int = 100,
-) -> list[UnreadPublicationItem]:
-    result = await db_session.execute(
-        publications_query(
-            user_id=user_id,
-            mode=MODE_UNREAD,
-            latest_run_id=None,
-            scholar_profile_id=None,
-            favorite_only=False,
-            limit=limit,
-            offset=0,
-        )
-    )
-    return [unread_item_from_row(row) for row in result.all()]
diff --git a/build/lib/app/services/domains/publications/modes.py b/build/lib/app/services/domains/publications/modes.py
deleted file mode 100644
index 2975169..0000000
--- a/build/lib/app/services/domains/publications/modes.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from __future__ import annotations
-
-MODE_ALL = "all"
-MODE_UNREAD = "unread"
-MODE_LATEST = "latest"
-MODE_NEW = "new"  # compatibility alias for MODE_LATEST
-
-
-def resolve_publication_view_mode(value: str | None) -> str:
-    if value == MODE_UNREAD:
-        return MODE_UNREAD
-    if value in {MODE_LATEST, MODE_NEW}:
-        return MODE_LATEST
-    return MODE_ALL
diff --git a/build/lib/app/services/domains/publications/pdf_queue.py b/build/lib/app/services/domains/publications/pdf_queue.py
deleted file mode 100644
index 18ac8d9..0000000
--- a/build/lib/app/services/domains/publications/pdf_queue.py
+++ /dev/null
@@ -1,915 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from dataclasses import dataclass
-from datetime import datetime, timezone
-import logging
-
-from sqlalchemy import Select, func, literal, or_, select, union_all
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import (
-    Publication,
-    PublicationPdfJob,
-    PublicationPdfJobEvent,
-    ScholarProfile,
-    ScholarPublication,
-    User,
-)
-from app.db.session import get_session_factory
-from app.services.domains.publication_identifiers import application as identifier_service
-from app.services.domains.publication_identifiers.types import DisplayIdentifier
-from app.services.domains.publications.pdf_resolution_pipeline import (
-    resolve_publication_pdf_outcome_for_row,
-)
-from app.services.domains.publications.types import PublicationListItem
-from app.services.domains.unpaywall.application import (
-    FAILURE_RESOLUTION_EXCEPTION,
-    OaResolutionOutcome,
-)
-from app.settings import settings
-
-PDF_STATUS_UNTRACKED = "untracked"
-PDF_STATUS_QUEUED = "queued"
-PDF_STATUS_RUNNING = "running"
-PDF_STATUS_RESOLVED = "resolved"
-PDF_STATUS_FAILED = "failed"
-
-PDF_EVENT_QUEUED = "queued"
-PDF_EVENT_ATTEMPT_STARTED = "attempt_started"
-PDF_EVENT_RESOLVED = "resolved"
-PDF_EVENT_FAILED = "failed"
-
-logger = logging.getLogger(__name__)
-_scheduled_tasks: set[asyncio.Task[None]] = set()
-
-
-@dataclass(frozen=True)
-class PdfQueueListItem:
-    publication_id: int
-    title: str
-    pdf_url: str | None
-    status: str
-    attempt_count: int
-    last_failure_reason: str | None
-    last_failure_detail: str | None
-    last_source: str | None
-    requested_by_user_id: int | None
-    requested_by_email: str | None
-    queued_at: datetime | None
-    last_attempt_at: datetime | None
-    resolved_at: datetime | None
-    updated_at: datetime
-    display_identifier: DisplayIdentifier | None = None
-
-
-@dataclass(frozen=True)
-class PdfRequeueResult:
-    publication_exists: bool
-    queued: bool
-
-
-@dataclass(frozen=True)
-class PdfBulkQueueResult:
-    requested_count: int
-    queued_count: int
-
-
-@dataclass(frozen=True)
-class PdfQueuePage:
-    items: list[PdfQueueListItem]
-    total_count: int
-    limit: int
-    offset: int
-
-
-def _utcnow() -> datetime:
-    return datetime.now(timezone.utc)
-
-
-def _publication_ids(rows: list[PublicationListItem]) -> list[int]:
-    return sorted({row.publication_id for row in rows})
-
-
-def _status_from_job(row: PublicationListItem, job: PublicationPdfJob | None) -> str:
-    if row.pdf_url:
-        return PDF_STATUS_RESOLVED
-    if job is None:
-        return PDF_STATUS_UNTRACKED
-    return job.status
-
-
-def _item_from_row_and_job(
-    row: PublicationListItem,
-    job: PublicationPdfJob | None,
-) -> PublicationListItem:
-    return PublicationListItem(
-        publication_id=row.publication_id,
-        scholar_profile_id=row.scholar_profile_id,
-        scholar_label=row.scholar_label,
-        title=row.title,
-        year=row.year,
-        citation_count=row.citation_count,
-        venue_text=row.venue_text,
-        pub_url=row.pub_url,
-        pdf_url=row.pdf_url,
-        is_read=row.is_read,
-        is_favorite=row.is_favorite,
-        first_seen_at=row.first_seen_at,
-        is_new_in_latest_run=row.is_new_in_latest_run,
-        pdf_status=_status_from_job(row, job),
-        pdf_attempt_count=int(job.attempt_count) if job is not None else 0,
-        pdf_failure_reason=job.last_failure_reason if job is not None else None,
-        pdf_failure_detail=job.last_failure_detail if job is not None else None,
-        display_identifier=row.display_identifier,
-    )
-
-
-def _queueable_rows(
-    rows: list[PublicationListItem],
-    *,
-    max_items: int,
-) -> list[PublicationListItem]:
-    bounded = max(0, int(max_items))
-    if bounded == 0:
-        return []
-    candidates = [row for row in rows if not row.pdf_url]
-    return candidates[:bounded]
-
-
-def _bounded_limit(limit: int, *, max_value: int = 500) -> int:
-    return max(1, min(int(limit), max_value))
-
-
-def _bounded_offset(offset: int) -> int:
-    return max(int(offset), 0)
-
-
-def _auto_retry_interval_seconds() -> int:
-    return max(int(settings.pdf_auto_retry_interval_seconds), 1)
-
-
-def _auto_retry_first_interval_seconds() -> int:
-    return max(int(settings.pdf_auto_retry_first_interval_seconds), 1)
-
-
-def _auto_retry_max_attempts() -> int:
-    return max(int(settings.pdf_auto_retry_max_attempts), 1)
-
-
-def _retry_interval_seconds_for_attempt_count(attempt_count: int) -> int:
-    if int(attempt_count) <= 1:
-        return _auto_retry_first_interval_seconds()
-    return _auto_retry_interval_seconds()
-
-
-def _cooldown_active(
-    *,
-    last_attempt_at: datetime | None,
-    attempt_count: int,
-) -> bool:
-    if last_attempt_at is None:
-        return False
-    elapsed = (_utcnow() - last_attempt_at).total_seconds()
-    return elapsed < _retry_interval_seconds_for_attempt_count(int(attempt_count))
-
-
-def _can_enqueue_job(
-    job: PublicationPdfJob | None,
-    *,
-    force_retry: bool,
-) -> bool:
-    if job is None:
-        return True
-    if job.status in {PDF_STATUS_QUEUED, PDF_STATUS_RUNNING}:
-        return False
-    if force_retry:
-        return job.status in {PDF_STATUS_FAILED, PDF_STATUS_RESOLVED, PDF_STATUS_UNTRACKED}
-    if job.status == PDF_STATUS_RESOLVED:
-        return False
-    if int(job.attempt_count) >= _auto_retry_max_attempts():
-        return False
-    if _cooldown_active(
-        last_attempt_at=job.last_attempt_at,
-        attempt_count=int(job.attempt_count),
-    ):
-        return False
-    return True
-
-
-def _event_row(
-    *,
-    publication_id: int,
-    user_id: int | None,
-    event_type: str,
-    status: str | None,
-    source: str | None = None,
-    failure_reason: str | None = None,
-    message: str | None = None,
-) -> PublicationPdfJobEvent:
-    return PublicationPdfJobEvent(
-        publication_id=publication_id,
-        user_id=user_id,
-        event_type=event_type,
-        status=status,
-        source=source,
-        failure_reason=failure_reason,
-        message=message,
-    )
-
-
-def _queued_job(
-    *,
-    publication_id: int,
-    user_id: int,
-) -> PublicationPdfJob:
-    now = _utcnow()
-    return PublicationPdfJob(
-        publication_id=publication_id,
-        status=PDF_STATUS_QUEUED,
-        queued_at=now,
-        last_requested_by_user_id=user_id,
-    )
-
-
-def _mark_job_queued(job: PublicationPdfJob, *, user_id: int) -> None:
-    now = _utcnow()
-    job.status = PDF_STATUS_QUEUED
-    job.queued_at = now
-    job.last_requested_by_user_id = user_id
-    job.last_failure_reason = None
-    job.last_failure_detail = None
-    job.last_source = None
-
-
-def _state_map(jobs: list[PublicationPdfJob]) -> dict[int, PublicationPdfJob]:
-    return {int(job.publication_id): job for job in jobs}
-
-
-async def _jobs_for_publication_ids(
-    db_session: AsyncSession,
-    *,
-    publication_ids: list[int],
-) -> dict[int, PublicationPdfJob]:
-    if not publication_ids:
-        return {}
-    result = await db_session.execute(
-        select(PublicationPdfJob).where(PublicationPdfJob.publication_id.in_(publication_ids))
-    )
-    return _state_map(list(result.scalars()))
-
-
-async def overlay_pdf_job_state(
-    db_session: AsyncSession,
-    *,
-    rows: list[PublicationListItem],
-) -> list[PublicationListItem]:
-    if not rows:
-        return []
-    jobs = await _jobs_for_publication_ids(
-        db_session,
-        publication_ids=_publication_ids(rows),
-    )
-    return [_item_from_row_and_job(row, jobs.get(row.publication_id)) for row in rows]
-
-
-async def _enqueue_rows(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    rows: list[PublicationListItem],
-    force_retry: bool,
-) -> list[PublicationListItem]:
-    if not rows:
-        return []
-    queued: list[PublicationListItem] = []
-    jobs = await _jobs_for_publication_ids(
-        db_session,
-        publication_ids=_publication_ids(rows),
-    )
-    for row in rows:
-        job = jobs.get(row.publication_id)
-        if not _can_enqueue_job(job, force_retry=force_retry):
-            continue
-        if job is None:
-            job = _queued_job(publication_id=row.publication_id, user_id=user_id)
-            jobs[row.publication_id] = job
-            db_session.add(job)
-        else:
-            _mark_job_queued(job, user_id=user_id)
-        db_session.add(
-            _event_row(
-                publication_id=row.publication_id,
-                user_id=user_id,
-                event_type=PDF_EVENT_QUEUED,
-                status=PDF_STATUS_QUEUED,
-            )
-        )
-        queued.append(row)
-    if queued:
-        await db_session.commit()
-    return queued
-
-
-def _register_task(task: asyncio.Task[None]) -> None:
-    _scheduled_tasks.add(task)
-
-
-def _drop_finished_task(task: asyncio.Task[None]) -> None:
-    _scheduled_tasks.discard(task)
-    try:
-        task.result()
-    except Exception:
-        logger.exception(
-            "publications.pdf_queue.task_failed",
-            extra={"event": "publications.pdf_queue.task_failed"},
-        )
-
-
-async def _mark_attempt_started(
-    *,
-    publication_id: int,
-    user_id: int,
-) -> None:
-    session_factory = get_session_factory()
-    async with session_factory() as db_session:
-        job = await db_session.get(PublicationPdfJob, publication_id)
-        if job is None:
-            job = _queued_job(publication_id=publication_id, user_id=user_id)
-            db_session.add(job)
-        job.status = PDF_STATUS_RUNNING
-        job.last_attempt_at = _utcnow()
-        job.attempt_count = int(job.attempt_count) + 1
-        db_session.add(
-            _event_row(
-                publication_id=publication_id,
-                user_id=user_id,
-                event_type=PDF_EVENT_ATTEMPT_STARTED,
-                status=PDF_STATUS_RUNNING,
-            )
-        )
-        await db_session.commit()
-
-
-def _failed_outcome(
-    *,
-    row: PublicationListItem,
-) -> OaResolutionOutcome:
-    return OaResolutionOutcome(
-        publication_id=row.publication_id,
-        doi=None,
-        pdf_url=None,
-        failure_reason=FAILURE_RESOLUTION_EXCEPTION,
-        source=None,
-        used_crossref=False,
-    )
-
-
-async def _fetch_outcome_for_row(
-    *,
-    row: PublicationListItem,
-    request_email: str | None,
-) -> OaResolutionOutcome:
-    pipeline_result = await resolve_publication_pdf_outcome_for_row(
-        row=row,
-        request_email=request_email,
-    )
-    outcome = pipeline_result.outcome
-    if outcome is not None:
-        return outcome
-    return _failed_outcome(row=row)
-
-
-def _apply_publication_update(
-    publication: Publication,
-    *,
-    pdf_url: str | None,
-) -> None:
-    if pdf_url and publication.pdf_url != pdf_url:
-        publication.pdf_url = pdf_url
-
-
-def _apply_job_outcome(job: PublicationPdfJob, *, outcome: OaResolutionOutcome) -> None:
-    job.last_source = outcome.source
-    if outcome.pdf_url:
-        job.status = PDF_STATUS_RESOLVED
-        job.resolved_at = _utcnow()
-        job.last_failure_reason = None
-        job.last_failure_detail = None
-        return
-    job.status = PDF_STATUS_FAILED
-    job.last_failure_reason = outcome.failure_reason
-    job.last_failure_detail = outcome.failure_reason
-
-
-def _result_event(outcome: OaResolutionOutcome) -> tuple[str, str]:
-    if outcome.pdf_url:
-        return PDF_EVENT_RESOLVED, PDF_STATUS_RESOLVED
-    return PDF_EVENT_FAILED, PDF_STATUS_FAILED
-
-
-async def _persist_outcome(
-    *,
-    publication_id: int,
-    user_id: int,
-    outcome: OaResolutionOutcome,
-) -> None:
-    session_factory = get_session_factory()
-    async with session_factory() as db_session:
-        publication = await db_session.get(Publication, publication_id)
-        job = await db_session.get(PublicationPdfJob, publication_id)
-        if publication is None or job is None:
-            return
-        _apply_publication_update(publication, pdf_url=outcome.pdf_url)
-        await identifier_service.sync_identifiers_for_publication_resolution(
-            db_session,
-            publication=publication,
-            source=outcome.source,
-        )
-        _apply_job_outcome(job, outcome=outcome)
-        event_type, status = _result_event(outcome)
-        db_session.add(
-            _event_row(
-                publication_id=publication_id,
-                user_id=user_id,
-                event_type=event_type,
-                status=status,
-                source=outcome.source,
-                failure_reason=outcome.failure_reason,
-                message=outcome.failure_reason,
-            )
-        )
-        await db_session.commit()
-
-
-async def _resolve_publication_row(
-    *,
-    user_id: int,
-    request_email: str | None,
-    row: PublicationListItem,
-) -> None:
-    await _mark_attempt_started(publication_id=row.publication_id, user_id=user_id)
-    try:
-        outcome = await _fetch_outcome_for_row(row=row, request_email=request_email)
-    except Exception as exc:  # pragma: no cover - defensive network boundary
-        logger.warning(
-            "publications.pdf_queue.resolve_failed",
-            extra={
-                "event": "publications.pdf_queue.resolve_failed",
-                "publication_id": row.publication_id,
-                "error": str(exc),
-            },
-        )
-        outcome = _failed_outcome(row=row)
-    await _persist_outcome(
-        publication_id=row.publication_id,
-        user_id=user_id,
-        outcome=outcome,
-    )
-
-
-async def _run_resolution_task(
-    *,
-    user_id: int,
-    request_email: str | None,
-    rows: list[PublicationListItem],
-) -> None:
-    for row in rows:
-        await _resolve_publication_row(
-            user_id=user_id,
-            request_email=request_email,
-            row=row,
-        )
-
-
-def _schedule_rows(
-    *,
-    user_id: int,
-    request_email: str | None,
-    rows: list[PublicationListItem],
-) -> None:
-    if not rows:
-        return
-    task = asyncio.create_task(
-        _run_resolution_task(
-            user_id=user_id,
-            request_email=request_email,
-            rows=rows,
-        )
-    )
-    _register_task(task)
-    task.add_done_callback(_drop_finished_task)
-
-
-async def enqueue_missing_pdf_jobs(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    request_email: str | None,
-    rows: list[PublicationListItem],
-    max_items: int,
-) -> list[int]:
-    queueable = _queueable_rows(rows, max_items=max_items)
-    queued_rows = await _enqueue_rows(
-        db_session,
-        user_id=user_id,
-        rows=queueable,
-        force_retry=False,
-    )
-    _schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
-    return [row.publication_id for row in queued_rows]
-
-
-async def enqueue_retry_pdf_job(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    request_email: str | None,
-    row: PublicationListItem,
-) -> bool:
-    queued_rows = await _enqueue_rows(
-        db_session,
-        user_id=user_id,
-        rows=[row],
-        force_retry=True,
-    )
-    _schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
-    return bool(queued_rows)
-
-
-def _retry_item_label(display_name: str | None, scholar_id: str | None) -> str:
-    return str(display_name or scholar_id or "unknown")
-
-
-def _retry_item_from_publication(
-    publication: Publication,
-    *,
-    link_row: tuple | None,
-) -> PublicationListItem:
-    if link_row is None:
-        scholar_profile_id = 0
-        scholar_label = "unknown"
-        is_read = True
-        first_seen_at = publication.created_at or _utcnow()
-    else:
-        scholar_profile_id = int(link_row[0])
-        scholar_label = _retry_item_label(link_row[1], link_row[2])
-        is_read = bool(link_row[3])
-        first_seen_at = link_row[4] or publication.created_at or _utcnow()
-    return PublicationListItem(
-        publication_id=int(publication.id),
-        scholar_profile_id=scholar_profile_id,
-        scholar_label=scholar_label,
-        title=publication.title_raw,
-        year=publication.year,
-        citation_count=int(publication.citation_count or 0),
-        venue_text=publication.venue_text,
-        pub_url=publication.pub_url,
-        pdf_url=publication.pdf_url,
-        is_read=is_read,
-        first_seen_at=first_seen_at,
-        is_new_in_latest_run=False,
-    )
-
-
-async def _retry_item_for_publication_id(
-    db_session: AsyncSession,
-    *,
-    publication_id: int,
-) -> PublicationListItem | None:
-    publication = await db_session.get(Publication, publication_id)
-    if publication is None:
-        return None
-    result = await db_session.execute(
-        select(
-            ScholarProfile.id,
-            ScholarProfile.display_name,
-            ScholarProfile.scholar_id,
-            ScholarPublication.is_read,
-            ScholarPublication.created_at,
-        )
-        .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
-        .where(ScholarPublication.publication_id == publication_id)
-        .order_by(ScholarPublication.created_at.asc())
-        .limit(1)
-    )
-    return _retry_item_from_publication(publication, link_row=result.one_or_none())
-
-
-async def enqueue_retry_pdf_job_for_publication_id(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    request_email: str | None,
-    publication_id: int,
-) -> PdfRequeueResult:
-    row = await _retry_item_for_publication_id(
-        db_session,
-        publication_id=publication_id,
-    )
-    if row is None:
-        return PdfRequeueResult(publication_exists=False, queued=False)
-    queued = await enqueue_retry_pdf_job(
-        db_session,
-        user_id=user_id,
-        request_email=request_email,
-        row=row,
-    )
-    return PdfRequeueResult(publication_exists=True, queued=queued)
-
-
-def _queue_candidate_from_publication(publication: Publication) -> PublicationListItem:
-    return PublicationListItem(
-        publication_id=int(publication.id),
-        scholar_profile_id=0,
-        scholar_label="admin",
-        title=publication.title_raw,
-        year=publication.year,
-        citation_count=int(publication.citation_count or 0),
-        venue_text=publication.venue_text,
-        pub_url=publication.pub_url,
-        pdf_url=publication.pdf_url,
-        is_read=True,
-        first_seen_at=publication.created_at or _utcnow(),
-        is_new_in_latest_run=False,
-    )
-
-
-async def _missing_pdf_candidates(
-    db_session: AsyncSession,
-    *,
-    limit: int,
-) -> list[PublicationListItem]:
-    bounded_limit = max(1, min(int(limit), 5000))
-    result = await db_session.execute(
-        select(Publication)
-        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
-        .where(Publication.pdf_url.is_(None))
-        .where(
-            or_(
-                PublicationPdfJob.publication_id.is_(None),
-                PublicationPdfJob.status.notin_([PDF_STATUS_QUEUED, PDF_STATUS_RUNNING]),
-            )
-        )
-        .order_by(Publication.updated_at.desc(), Publication.id.desc())
-        .limit(bounded_limit)
-    )
-    return [
-        _queue_candidate_from_publication(publication)
-        for publication in result.scalars()
-    ]
-
-
-async def enqueue_all_missing_pdf_jobs(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    request_email: str | None,
-    limit: int = 1000,
-) -> PdfBulkQueueResult:
-    candidates = await _missing_pdf_candidates(db_session, limit=limit)
-    queued_rows = await _enqueue_rows(
-        db_session,
-        user_id=user_id,
-        rows=candidates,
-        force_retry=True,
-    )
-    _schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
-    return PdfBulkQueueResult(
-        requested_count=len(candidates),
-        queued_count=len(queued_rows),
-    )
-
-
-def _tracked_queue_select_base(*, status: str | None) -> Select[tuple]:
-    stmt = (
-        select(
-            PublicationPdfJob.publication_id,
-            Publication.title_raw,
-            Publication.pdf_url,
-            PublicationPdfJob.status,
-            PublicationPdfJob.attempt_count,
-            PublicationPdfJob.last_failure_reason,
-            PublicationPdfJob.last_failure_detail,
-            PublicationPdfJob.last_source,
-            PublicationPdfJob.last_requested_by_user_id,
-            User.email,
-            PublicationPdfJob.queued_at,
-            PublicationPdfJob.last_attempt_at,
-            PublicationPdfJob.resolved_at,
-            PublicationPdfJob.updated_at,
-        )
-        .join(Publication, Publication.id == PublicationPdfJob.publication_id)
-        .outerjoin(User, User.id == PublicationPdfJob.last_requested_by_user_id)
-    )
-    if status:
-        stmt = stmt.where(PublicationPdfJob.status == status)
-    return stmt
-
-
-def _tracked_queue_select(*, limit: int, offset: int, status: str | None) -> Select[tuple]:
-    return (
-        _tracked_queue_select_base(status=status)
-        .order_by(PublicationPdfJob.updated_at.desc())
-        .limit(_bounded_limit(limit))
-        .offset(_bounded_offset(offset))
-    )
-
-
-def _untracked_queue_select_base() -> Select[tuple]:
-    return (
-        select(
-            Publication.id,
-            Publication.title_raw,
-            Publication.pdf_url,
-            literal(PDF_STATUS_UNTRACKED),
-            literal(0),
-            literal(None),
-            literal(None),
-            literal(None),
-            literal(None),
-            literal(None),
-            literal(None),
-            literal(None),
-            literal(None),
-            Publication.updated_at,
-        )
-        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
-        .where(Publication.pdf_url.is_(None))
-        .where(PublicationPdfJob.publication_id.is_(None))
-    )
-
-
-def _untracked_queue_select(*, limit: int, offset: int) -> Select[tuple]:
-    return (
-        _untracked_queue_select_base()
-        .order_by(Publication.updated_at.desc(), Publication.id.desc())
-        .limit(_bounded_limit(limit))
-        .offset(_bounded_offset(offset))
-    )
-
-
-def _all_queue_select(*, limit: int, offset: int) -> Select[tuple]:
-    union_stmt = union_all(
-        _tracked_queue_select_base(status=None),
-        _untracked_queue_select_base(),
-    ).subquery()
-    return (
-        select(union_stmt)
-        .order_by(union_stmt.c.updated_at.desc())
-        .limit(_bounded_limit(limit))
-        .offset(_bounded_offset(offset))
-    )
-
-
-def _tracked_queue_count_select(*, status: str | None) -> Select[tuple]:
-    stmt = select(func.count()).select_from(PublicationPdfJob)
-    if status:
-        stmt = stmt.where(PublicationPdfJob.status == status)
-    return stmt
-
-
-def _untracked_queue_count_select() -> Select[tuple]:
-    return (
-        select(func.count())
-        .select_from(Publication)
-        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
-        .where(Publication.pdf_url.is_(None))
-        .where(PublicationPdfJob.publication_id.is_(None))
-    )
-
-
-def _queue_item_from_row(row: tuple) -> PdfQueueListItem:
-    return PdfQueueListItem(
-        publication_id=int(row[0]),
-        title=str(row[1] or ""),
-        pdf_url=row[2],
-        status=str(row[3] or PDF_STATUS_UNTRACKED),
-        attempt_count=int(row[4] or 0),
-        last_failure_reason=row[5],
-        last_failure_detail=row[6],
-        last_source=row[7],
-        requested_by_user_id=int(row[8]) if row[8] is not None else None,
-        requested_by_email=row[9],
-        queued_at=row[10],
-        last_attempt_at=row[11],
-        resolved_at=row[12],
-        updated_at=row[13],
-    )
-
-
-async def _hydrated_queue_items(
-    db_session: AsyncSession,
-    *,
-    rows: list[tuple],
-) -> list[PdfQueueListItem]:
-    items = [_queue_item_from_row(row) for row in rows]
-    return await identifier_service.overlay_pdf_queue_items_with_display_identifiers(
-        db_session,
-        items=items,
-    )
-
-
-async def list_pdf_queue_items(
-    db_session: AsyncSession,
-    *,
-    limit: int = 100,
-    offset: int = 0,
-    status: str | None = None,
-) -> list[PdfQueueListItem]:
-    bounded_limit = _bounded_limit(limit)
-    bounded_offset = _bounded_offset(offset)
-    normalized_status = (status or "").strip().lower() or None
-    if normalized_status == PDF_STATUS_UNTRACKED:
-        result = await db_session.execute(
-            _untracked_queue_select(
-                limit=bounded_limit,
-                offset=bounded_offset,
-            )
-        )
-        return await _hydrated_queue_items(db_session, rows=list(result.all()))
-    if normalized_status is None:
-        result = await db_session.execute(
-            _all_queue_select(
-                limit=bounded_limit,
-                offset=bounded_offset,
-            )
-        )
-        return await _hydrated_queue_items(db_session, rows=list(result.all()))
-    result = await db_session.execute(
-        _tracked_queue_select(
-            limit=bounded_limit,
-            offset=bounded_offset,
-            status=normalized_status,
-        )
-    )
-    return await _hydrated_queue_items(db_session, rows=list(result.all()))
-
-
-async def count_pdf_queue_items(
-    db_session: AsyncSession,
-    *,
-    status: str | None = None,
-) -> int:
-    normalized_status = (status or "").strip().lower() or None
-    if normalized_status == PDF_STATUS_UNTRACKED:
-        result = await db_session.execute(_untracked_queue_count_select())
-        return int(result.scalar_one() or 0)
-    tracked_result = await db_session.execute(
-        _tracked_queue_count_select(status=normalized_status)
-    )
-    tracked_count = int(tracked_result.scalar_one() or 0)
-    if normalized_status is not None:
-        return tracked_count
-    untracked_result = await db_session.execute(_untracked_queue_count_select())
-    untracked_count = int(untracked_result.scalar_one() or 0)
-    return tracked_count + untracked_count
-
-
-async def list_pdf_queue_page(
-    db_session: AsyncSession,
-    *,
-    limit: int = 100,
-    offset: int = 0,
-    status: str | None = None,
-) -> PdfQueuePage:
-    bounded_limit = _bounded_limit(limit)
-    bounded_offset = _bounded_offset(offset)
-    items = await list_pdf_queue_items(
-        db_session,
-        limit=bounded_limit,
-        offset=bounded_offset,
-        status=status,
-    )
-    total_count = await count_pdf_queue_items(
-        db_session,
-        status=status,
-    )
-    return PdfQueuePage(
-        items=items,
-        total_count=total_count,
-        limit=bounded_limit,
-        offset=bounded_offset,
-    )
-
-
-async def drain_ready_jobs(
-    db_session: AsyncSession,
-    *,
-    limit: int,
-    max_attempts: int,
-) -> int:
-    result = await db_session.execute(
-        select(User.id).where(User.is_active.is_(True)).order_by(User.id.asc()).limit(1)
-    )
-    system_user_id = result.scalar_one_or_none()
-    if system_user_id is None:
-        return 0
-
-    bulk_result = await enqueue_all_missing_pdf_jobs(
-        db_session,
-        user_id=system_user_id,
-        request_email=settings.unpaywall_email,
-        limit=limit,
-    )
-    return bulk_result.queued_count
diff --git a/build/lib/app/services/domains/publications/pdf_resolution_pipeline.py b/build/lib/app/services/domains/publications/pdf_resolution_pipeline.py
deleted file mode 100644
index 9e07c0b..0000000
--- a/build/lib/app/services/domains/publications/pdf_resolution_pipeline.py
+++ /dev/null
@@ -1,108 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-import logging
-from typing import Any
-
-from app.services.domains.publications.types import PublicationListItem
-from app.services.domains.unpaywall.application import OaResolutionOutcome, resolve_publication_oa_outcomes
-from app.settings import settings
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class PipelineOutcome:
-    outcome: OaResolutionOutcome | None
-    scholar_candidates: Any | None  # Kept for backward compatibility with calling signatures
-
-
-async def resolve_publication_pdf_outcome_for_row(
-    *,
-    row: PublicationListItem,
-    request_email: str | None,
-) -> PipelineOutcome:
-    # 1. OpenAlex OA
-    openalex_outcome = await _openalex_outcome(row, request_email=request_email)
-    if openalex_outcome and openalex_outcome.pdf_url:
-        return PipelineOutcome(openalex_outcome, None)
-
-    # 2. arXiv
-    arxiv_outcome = await _arxiv_outcome(row, request_email=request_email)
-    if arxiv_outcome and arxiv_outcome.pdf_url:
-        return PipelineOutcome(arxiv_outcome, None)
-
-    # 3. Unpaywall (which falls back to Crossref)
-    oa_outcome = await _oa_outcome(row=row, request_email=request_email)
-    return PipelineOutcome(oa_outcome, None)
-
-
-async def _openalex_outcome(row: PublicationListItem, request_email: str | None) -> OaResolutionOutcome | None:
-    from app.services.domains.openalex.client import OpenAlexClient
-    from app.services.domains.openalex.matching import find_best_match
-
-    if not row.title:
-        return None
-
-    import re
-    safe_title = re.sub(r"[^\w\s]", " ", row.title)
-    safe_title = " ".join(safe_title.split())
-    if not safe_title:
-        return None
-
-    client = OpenAlexClient(api_key=settings.openalex_api_key, mailto=request_email or settings.crossref_api_mailto)
-    try:
-        openalex_works = await client.get_works_by_filter({"title.search": safe_title}, limit=5)
-        match = find_best_match(
-            target_title=row.title,
-            target_year=row.year,
-            target_authors=row.scholar_label,
-            candidates=openalex_works,
-        )
-        if match and match.oa_url:
-            return OaResolutionOutcome(
-                publication_id=row.publication_id,
-                doi=match.doi,
-                pdf_url=match.oa_url,
-                failure_reason=None,
-                source="openalex",
-                used_crossref=False,
-            )
-    except Exception as exc:
-        logger.warning(
-            "publications.pdf_resolution.openalex_failed",
-            extra={"event": "publications.pdf_resolution.openalex_failed", "error": str(exc)},
-        )
-    return None
-
-
-async def _arxiv_outcome(row: PublicationListItem, request_email: str | None) -> OaResolutionOutcome | None:
-    from app.services.domains.arxiv.application import discover_arxiv_id_for_publication
-
-    try:
-        arxiv_id = await discover_arxiv_id_for_publication(item=row, request_email=request_email)
-        if arxiv_id:
-            pdf_url = f"https://arxiv.org/pdf/{arxiv_id}.pdf"
-            return OaResolutionOutcome(
-                publication_id=row.publication_id,
-                doi=None,
-                pdf_url=pdf_url,
-                failure_reason=None,
-                source="arxiv",
-                used_crossref=False,
-            )
-    except Exception as exc:
-        logger.warning(
-            "publications.pdf_resolution.arxiv_failed",
-            extra={"event": "publications.pdf_resolution.arxiv_failed", "error": str(exc)},
-        )
-    return None
-
-
-async def _oa_outcome(
-    *,
-    row: PublicationListItem,
-    request_email: str | None,
-) -> OaResolutionOutcome | None:
-    outcomes = await resolve_publication_oa_outcomes([row], request_email=request_email)
-    return outcomes.get(row.publication_id)
diff --git a/build/lib/app/services/domains/publications/queries.py b/build/lib/app/services/domains/publications/queries.py
deleted file mode 100644
index e7356f4..0000000
--- a/build/lib/app/services/domains/publications/queries.py
+++ /dev/null
@@ -1,203 +0,0 @@
-from __future__ import annotations
-
-from sqlalchemy import Select, func, select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import CrawlRun, Publication, RunStatus, ScholarProfile, ScholarPublication
-from app.services.domains.publications.modes import MODE_LATEST, MODE_UNREAD
-from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
-
-
-def _normalized_citation_count(value: object) -> int:
-    try:
-        return int(value or 0)
-    except (TypeError, ValueError):
-        return 0
-
-
-async def get_latest_completed_run_id_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-) -> int | None:
-    result = await db_session.execute(
-        select(func.max(CrawlRun.id)).where(
-            CrawlRun.user_id == user_id,
-            CrawlRun.status != RunStatus.RUNNING,
-        )
-    )
-    latest_run_id = result.scalar_one_or_none()
-    return int(latest_run_id) if latest_run_id is not None else None
-
-
-def publications_query(
-    *,
-    user_id: int,
-    mode: str,
-    latest_run_id: int | None,
-    scholar_profile_id: int | None,
-    favorite_only: bool,
-    limit: int,
-    offset: int = 0,
-) -> Select[tuple]:
-    scholar_label = ScholarProfile.display_name
-    stmt = (
-        select(
-            Publication.id,
-            ScholarProfile.id,
-            scholar_label,
-            ScholarProfile.scholar_id,
-            Publication.title_raw,
-            Publication.year,
-            Publication.citation_count,
-            Publication.venue_text,
-            Publication.pub_url,
-            Publication.pdf_url,
-            ScholarPublication.is_read,
-            ScholarPublication.is_favorite,
-            ScholarPublication.first_seen_run_id,
-            ScholarPublication.created_at,
-        )
-        .join(ScholarPublication, ScholarPublication.publication_id == Publication.id)
-        .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
-        .where(ScholarProfile.user_id == user_id)
-        .order_by(ScholarPublication.created_at.desc(), Publication.id.desc())
-        .offset(max(int(offset), 0))
-        .limit(limit)
-    )
-    if scholar_profile_id is not None:
-        stmt = stmt.where(ScholarProfile.id == scholar_profile_id)
-    if favorite_only:
-        stmt = stmt.where(ScholarPublication.is_favorite.is_(True))
-    if mode == MODE_UNREAD:
-        stmt = stmt.where(ScholarPublication.is_read.is_(False))
-    if mode == MODE_LATEST:
-        if latest_run_id is None:
-            return stmt.where(False)
-        stmt = stmt.where(ScholarPublication.first_seen_run_id == latest_run_id)
-    return stmt
-
-
-def publication_query_for_user(
-    *,
-    user_id: int,
-    scholar_profile_id: int,
-    publication_id: int,
-) -> Select[tuple]:
-    return (
-        select(
-            Publication.id,
-            ScholarProfile.id,
-            ScholarProfile.display_name,
-            ScholarProfile.scholar_id,
-            Publication.title_raw,
-            Publication.year,
-            Publication.citation_count,
-            Publication.venue_text,
-            Publication.pub_url,
-            Publication.pdf_url,
-            ScholarPublication.is_read,
-            ScholarPublication.is_favorite,
-            ScholarPublication.first_seen_run_id,
-            ScholarPublication.created_at,
-        )
-        .join(ScholarPublication, ScholarPublication.publication_id == Publication.id)
-        .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
-        .where(
-            ScholarProfile.user_id == user_id,
-            ScholarProfile.id == scholar_profile_id,
-            Publication.id == publication_id,
-        )
-        .limit(1)
-    )
-
-
-async def get_publication_item_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int,
-    publication_id: int,
-) -> PublicationListItem | None:
-    latest_run_id = await get_latest_completed_run_id_for_user(db_session, user_id=user_id)
-    result = await db_session.execute(
-        publication_query_for_user(
-            user_id=user_id,
-            scholar_profile_id=scholar_profile_id,
-            publication_id=publication_id,
-        )
-    )
-    row = result.one_or_none()
-    if row is None:
-        return None
-    return publication_list_item_from_row(row, latest_run_id=latest_run_id)
-
-
-def publication_list_item_from_row(
-    row: tuple,
-    *,
-    latest_run_id: int | None,
-) -> PublicationListItem:
-    (
-        publication_id,
-        scholar_profile_id,
-        display_name,
-        scholar_id,
-        title_raw,
-        year,
-        citation_count,
-        venue_text,
-        pub_url,
-        pdf_url,
-        is_read,
-        is_favorite,
-        first_seen_run_id,
-        created_at,
-    ) = row
-    return PublicationListItem(
-        publication_id=int(publication_id),
-        scholar_profile_id=int(scholar_profile_id),
-        scholar_label=(display_name or scholar_id),
-        title=title_raw,
-        year=year,
-        citation_count=_normalized_citation_count(citation_count),
-        venue_text=venue_text,
-        pub_url=pub_url,
-        pdf_url=pdf_url,
-        is_read=bool(is_read),
-        is_favorite=bool(is_favorite),
-        first_seen_at=created_at,
-        is_new_in_latest_run=(
-            latest_run_id is not None and int(first_seen_run_id or 0) == latest_run_id
-        ),
-    )
-
-
-def unread_item_from_row(row: tuple) -> UnreadPublicationItem:
-    (
-        publication_id,
-        scholar_profile_id,
-        display_name,
-        scholar_id,
-        title_raw,
-        year,
-        citation_count,
-        venue_text,
-        pub_url,
-        pdf_url,
-        _is_read,
-        _is_favorite,
-        _first_seen_run_id,
-        _created_at,
-    ) = row
-    return UnreadPublicationItem(
-        publication_id=int(publication_id),
-        scholar_profile_id=int(scholar_profile_id),
-        scholar_label=(display_name or scholar_id),
-        title=title_raw,
-        year=year,
-        citation_count=_normalized_citation_count(citation_count),
-        venue_text=venue_text,
-        pub_url=pub_url,
-        pdf_url=pdf_url,
-    )
diff --git a/build/lib/app/services/domains/publications/read_state.py b/build/lib/app/services/domains/publications/read_state.py
deleted file mode 100644
index 41fc31a..0000000
--- a/build/lib/app/services/domains/publications/read_state.py
+++ /dev/null
@@ -1,94 +0,0 @@
-from __future__ import annotations
-
-from sqlalchemy import select, tuple_, update
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import ScholarProfile, ScholarPublication
-
-
-def _normalized_selection_pairs(selections: list[tuple[int, int]]) -> set[tuple[int, int]]:
-    pairs: set[tuple[int, int]] = set()
-    for scholar_profile_id, publication_id in selections:
-        normalized = (int(scholar_profile_id), int(publication_id))
-        if normalized[0] <= 0 or normalized[1] <= 0:
-            continue
-        pairs.add(normalized)
-    return pairs
-
-
-def _scoped_scholar_ids_query(*, user_id: int):
-    return (
-        select(ScholarProfile.id)
-        .where(ScholarProfile.user_id == user_id)
-        .scalar_subquery()
-    )
-
-
-async def mark_all_unread_as_read_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-) -> int:
-    scholar_ids = _scoped_scholar_ids_query(user_id=user_id)
-    stmt = (
-        update(ScholarPublication)
-        .where(
-            ScholarPublication.scholar_profile_id.in_(scholar_ids),
-            ScholarPublication.is_read.is_(False),
-        )
-        .values(is_read=True)
-    )
-    result = await db_session.execute(stmt)
-    await db_session.commit()
-    return int(result.rowcount or 0)
-
-
-async def mark_selected_as_read_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    selections: list[tuple[int, int]],
-) -> int:
-    normalized_pairs = _normalized_selection_pairs(selections)
-    if not normalized_pairs:
-        return 0
-
-    scholar_ids = _scoped_scholar_ids_query(user_id=user_id)
-    stmt = (
-        update(ScholarPublication)
-        .where(
-            ScholarPublication.scholar_profile_id.in_(scholar_ids),
-            tuple_(
-                ScholarPublication.scholar_profile_id,
-                ScholarPublication.publication_id,
-            ).in_(list(normalized_pairs)),
-            ScholarPublication.is_read.is_(False),
-        )
-        .values(is_read=True)
-    )
-    result = await db_session.execute(stmt)
-    await db_session.commit()
-    return int(result.rowcount or 0)
-
-
-async def set_publication_favorite_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int,
-    publication_id: int,
-    is_favorite: bool,
-) -> int:
-    scholar_ids = _scoped_scholar_ids_query(user_id=user_id)
-    stmt = (
-        update(ScholarPublication)
-        .where(
-            ScholarPublication.scholar_profile_id.in_(scholar_ids),
-            ScholarPublication.scholar_profile_id == int(scholar_profile_id),
-            ScholarPublication.publication_id == int(publication_id),
-        )
-        .values(is_favorite=bool(is_favorite))
-    )
-    result = await db_session.execute(stmt)
-    await db_session.commit()
-    return int(result.rowcount or 0)
diff --git a/build/lib/app/services/domains/publications/types.py b/build/lib/app/services/domains/publications/types.py
deleted file mode 100644
index 62d038b..0000000
--- a/build/lib/app/services/domains/publications/types.py
+++ /dev/null
@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from datetime import datetime
-
-from app.services.domains.publication_identifiers.types import DisplayIdentifier
-
-
-@dataclass(frozen=True)
-class PublicationListItem:
-    publication_id: int
-    scholar_profile_id: int
-    scholar_label: str
-    title: str
-    year: int | None
-    citation_count: int
-    venue_text: str | None
-    pub_url: str | None
-    pdf_url: str | None
-    is_read: bool
-    first_seen_at: datetime
-    is_new_in_latest_run: bool
-    is_favorite: bool = False
-    pdf_status: str = "untracked"
-    pdf_attempt_count: int = 0
-    pdf_failure_reason: str | None = None
-    pdf_failure_detail: str | None = None
-    display_identifier: DisplayIdentifier | None = None
-
-
-@dataclass(frozen=True)
-class UnreadPublicationItem:
-    publication_id: int
-    scholar_profile_id: int
-    scholar_label: str
-    title: str
-    year: int | None
-    citation_count: int
-    venue_text: str | None
-    pub_url: str | None
-    pdf_url: str | None
diff --git a/build/lib/app/services/domains/runs/__init__.py b/build/lib/app/services/domains/runs/__init__.py
deleted file mode 100644
index 848f6e0..0000000
--- a/build/lib/app/services/domains/runs/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from app.services.domains.runs.application import *
diff --git a/build/lib/app/services/domains/runs/application.py b/build/lib/app/services/domains/runs/application.py
deleted file mode 100644
index 0019446..0000000
--- a/build/lib/app/services/domains/runs/application.py
+++ /dev/null
@@ -1,45 +0,0 @@
-from __future__ import annotations
-
-from app.services.domains.runs.queue_service import (
-    clear_queue_item_for_user,
-    drop_queue_item_for_user,
-    get_queue_item_for_user,
-    list_queue_items_for_user,
-    queue_status_counts_for_user,
-    retry_queue_item_for_user,
-)
-from app.services.domains.runs.runs_service import (
-    get_manual_run_by_idempotency_key,
-    get_run_for_user,
-    list_recent_runs_for_user,
-    list_runs_for_user,
-)
-from app.services.domains.runs.summary import extract_run_summary
-from app.services.domains.runs.types import (
-    QUEUE_STATUS_DROPPED,
-    QUEUE_STATUS_QUEUED,
-    QUEUE_STATUS_RETRYING,
-    QueueClearResult,
-    QueueListItem,
-    QueueTransitionError,
-)
-
-__all__ = [
-    "QUEUE_STATUS_QUEUED",
-    "QUEUE_STATUS_RETRYING",
-    "QUEUE_STATUS_DROPPED",
-    "QueueListItem",
-    "QueueClearResult",
-    "QueueTransitionError",
-    "extract_run_summary",
-    "list_recent_runs_for_user",
-    "list_runs_for_user",
-    "get_run_for_user",
-    "get_manual_run_by_idempotency_key",
-    "list_queue_items_for_user",
-    "get_queue_item_for_user",
-    "retry_queue_item_for_user",
-    "drop_queue_item_for_user",
-    "clear_queue_item_for_user",
-    "queue_status_counts_for_user",
-]
diff --git a/build/lib/app/services/domains/runs/events.py b/build/lib/app/services/domains/runs/events.py
deleted file mode 100644
index ef28069..0000000
--- a/build/lib/app/services/domains/runs/events.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import asyncio
-import json
-import logging
-from typing import Any, AsyncGenerator, Dict, Set
-
-logger = logging.getLogger(__name__)
-
-class RunEventPublisher:
-    def __init__(self) -> None:
-        # Maps run_id to a set of subscriber queues
-        self._subscribers: Dict[int, Set[asyncio.Queue]] = {}
-
-    def subscribe(self, run_id: int) -> asyncio.Queue:
-        if run_id not in self._subscribers:
-            self._subscribers[run_id] = set()
-        queue: asyncio.Queue[Any] = asyncio.Queue()
-        self._subscribers[run_id].add(queue)
-        logger.debug(f"New subscriber for run {run_id}. Total: {len(self._subscribers[run_id])}")
-        return queue
-
-    def unsubscribe(self, run_id: int, queue: asyncio.Queue) -> None:
-        if run_id in self._subscribers:
-            self._subscribers[run_id].discard(queue)
-            if not self._subscribers[run_id]:
-                self._subscribers.pop(run_id, None)
-
-    async def publish(self, run_id: int, event_type: str, data: dict[str, Any]) -> None:
-        if run_id not in self._subscribers:
-            return
-        
-        message = {
-            "type": event_type,
-            "data": data
-        }
-        
-        # Fan-out to all active subscribers for this run
-        for queue in list(self._subscribers[run_id]):
-            try:
-                queue.put_nowait(message)
-            except asyncio.QueueFull:
-                logger.warning(f"Subscriber queue full for run {run_id}, dropping message")
-
-run_events = RunEventPublisher()
-
-async def event_generator(run_id: int) -> AsyncGenerator[str, None]:
-    queue = run_events.subscribe(run_id)
-    try:
-        while True:
-            # Wait for a new event
-            message = await queue.get()
-            # Server-Sent Events format: "event: <type>\ndata: <json>\n\n"
-            event_type = message["type"]
-            data_str = json.dumps(message["data"])
-            yield f"event: {event_type}\ndata: {data_str}\n\n"
-    except asyncio.CancelledError:
-        logger.debug(f"Client disconnected from SSE stream for run {run_id}")
-        raise
-    finally:
-        run_events.unsubscribe(run_id, queue)
diff --git a/build/lib/app/services/domains/runs/queue_queries.py b/build/lib/app/services/domains/runs/queue_queries.py
deleted file mode 100644
index 7d2e501..0000000
--- a/build/lib/app/services/domains/runs/queue_queries.py
+++ /dev/null
@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-from sqlalchemy import and_, select
-
-from app.db.models import IngestionQueueItem, ScholarProfile
-from app.services.domains.runs.types import QueueListItem
-
-
-def queue_item_columns() -> tuple:
-    return (
-        IngestionQueueItem.id,
-        IngestionQueueItem.scholar_profile_id,
-        ScholarProfile.display_name,
-        ScholarProfile.scholar_id,
-        IngestionQueueItem.status,
-        IngestionQueueItem.reason,
-        IngestionQueueItem.dropped_reason,
-        IngestionQueueItem.attempt_count,
-        IngestionQueueItem.resume_cstart,
-        IngestionQueueItem.next_attempt_dt,
-        IngestionQueueItem.updated_at,
-        IngestionQueueItem.last_error,
-        IngestionQueueItem.last_run_id,
-    )
-
-
-def queue_item_select(*, user_id: int):
-    return (
-        select(*queue_item_columns())
-        .join(
-            ScholarProfile,
-            and_(
-                ScholarProfile.id == IngestionQueueItem.scholar_profile_id,
-                ScholarProfile.user_id == IngestionQueueItem.user_id,
-            ),
-        )
-        .where(IngestionQueueItem.user_id == user_id)
-    )
-
-
-def queue_list_item_from_row(row: tuple) -> QueueListItem:
-    (
-        item_id,
-        scholar_profile_id,
-        display_name,
-        scholar_id,
-        status,
-        reason,
-        dropped_reason,
-        attempt_count,
-        resume_cstart,
-        next_attempt_dt,
-        updated_at,
-        last_error,
-        last_run_id,
-    ) = row
-    return QueueListItem(
-        id=int(item_id),
-        scholar_profile_id=int(scholar_profile_id),
-        scholar_label=(display_name or scholar_id),
-        status=str(status),
-        reason=str(reason),
-        dropped_reason=dropped_reason,
-        attempt_count=int(attempt_count or 0),
-        resume_cstart=int(resume_cstart or 0),
-        next_attempt_dt=next_attempt_dt,
-        updated_at=updated_at,
-        last_error=last_error,
-        last_run_id=int(last_run_id) if last_run_id is not None else None,
-    )
diff --git a/build/lib/app/services/domains/runs/queue_service.py b/build/lib/app/services/domains/runs/queue_service.py
deleted file mode 100644
index d69ce21..0000000
--- a/build/lib/app/services/domains/runs/queue_service.py
+++ /dev/null
@@ -1,182 +0,0 @@
-from __future__ import annotations
-
-from sqlalchemy import case, func, select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import IngestionQueueItem
-from app.services.domains.ingestion import queue as queue_mutations
-from app.services.domains.runs.queue_queries import queue_item_select, queue_list_item_from_row
-from app.services.domains.runs.types import (
-    QUEUE_STATUS_DROPPED,
-    QUEUE_STATUS_QUEUED,
-    QUEUE_STATUS_RETRYING,
-    QueueClearResult,
-    QueueListItem,
-    QueueTransitionError,
-)
-
-
-async def list_queue_items_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    limit: int = 200,
-) -> list[QueueListItem]:
-    result = await db_session.execute(
-        queue_item_select(user_id=user_id)
-        .order_by(
-            case((IngestionQueueItem.status == QUEUE_STATUS_DROPPED, 1), else_=0).asc(),
-            IngestionQueueItem.next_attempt_dt.asc(),
-            IngestionQueueItem.id.asc(),
-        )
-        .limit(limit)
-    )
-    return [queue_list_item_from_row(row) for row in result.all()]
-
-
-async def get_queue_item_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    queue_item_id: int,
-) -> QueueListItem | None:
-    result = await db_session.execute(
-        queue_item_select(user_id=user_id)
-        .where(IngestionQueueItem.id == queue_item_id)
-        .limit(1)
-    )
-    row = result.one_or_none()
-    if row is None:
-        return None
-    return queue_list_item_from_row(row)
-
-
-async def retry_queue_item_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    queue_item_id: int,
-) -> QueueListItem | None:
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(
-            IngestionQueueItem.id == queue_item_id,
-            IngestionQueueItem.user_id == user_id,
-        )
-    )
-    item = result.scalar_one_or_none()
-    if item is None:
-        return None
-    if item.status == QUEUE_STATUS_QUEUED:
-        raise QueueTransitionError(
-            code="queue_item_already_queued",
-            message="Queue item is already queued.",
-            current_status=item.status,
-        )
-    if item.status == QUEUE_STATUS_RETRYING:
-        raise QueueTransitionError(
-            code="queue_item_retrying",
-            message="Queue item is currently retrying.",
-            current_status=item.status,
-        )
-
-    await queue_mutations.mark_queued_now(
-        db_session,
-        job_id=item.id,
-        reason="manual_retry",
-        reset_attempt_count=(item.status == QUEUE_STATUS_DROPPED),
-    )
-    await db_session.commit()
-    return await get_queue_item_for_user(
-        db_session,
-        user_id=user_id,
-        queue_item_id=queue_item_id,
-    )
-
-
-async def drop_queue_item_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    queue_item_id: int,
-) -> QueueListItem | None:
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(
-            IngestionQueueItem.id == queue_item_id,
-            IngestionQueueItem.user_id == user_id,
-        )
-    )
-    item = result.scalar_one_or_none()
-    if item is None:
-        return None
-    if item.status == QUEUE_STATUS_DROPPED:
-        raise QueueTransitionError(
-            code="queue_item_already_dropped",
-            message="Queue item is already dropped.",
-            current_status=item.status,
-        )
-
-    await queue_mutations.mark_dropped(
-        db_session,
-        job_id=int(item.id),
-        reason="manual_drop",
-    )
-    await db_session.commit()
-    return await get_queue_item_for_user(
-        db_session,
-        user_id=user_id,
-        queue_item_id=queue_item_id,
-    )
-
-
-async def clear_queue_item_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    queue_item_id: int,
-) -> QueueClearResult | None:
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(
-            IngestionQueueItem.id == queue_item_id,
-            IngestionQueueItem.user_id == user_id,
-        )
-    )
-    item = result.scalar_one_or_none()
-    if item is None:
-        return None
-    if item.status != QUEUE_STATUS_DROPPED:
-        raise QueueTransitionError(
-            code="queue_item_not_dropped",
-            message="Queue item can only be cleared after it is dropped.",
-            current_status=item.status,
-        )
-
-    item_id = int(item.id)
-    previous_status = str(item.status)
-    deleted = await queue_mutations.delete_job_by_id(db_session, job_id=item_id)
-    await db_session.commit()
-    if not deleted:
-        return None
-    return QueueClearResult(queue_item_id=item_id, previous_status=previous_status)
-
-
-async def queue_status_counts_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-) -> dict[str, int]:
-    result = await db_session.execute(
-        select(
-            IngestionQueueItem.status,
-            func.count(IngestionQueueItem.id),
-        )
-        .where(IngestionQueueItem.user_id == user_id)
-        .group_by(IngestionQueueItem.status)
-    )
-    counts: dict[str, int] = {
-        QUEUE_STATUS_QUEUED: 0,
-        QUEUE_STATUS_RETRYING: 0,
-        QUEUE_STATUS_DROPPED: 0,
-    }
-    for status, count in result.all():
-        counts[str(status)] = int(count or 0)
-    return counts
diff --git a/build/lib/app/services/domains/runs/runs_service.py b/build/lib/app/services/domains/runs/runs_service.py
deleted file mode 100644
index 1cb9aa2..0000000
--- a/build/lib/app/services/domains/runs/runs_service.py
+++ /dev/null
@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-from sqlalchemy import or_, select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import CrawlRun, RunStatus, RunTriggerType
-
-
-async def list_recent_runs_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    limit: int = 20,
-) -> list[CrawlRun]:
-    result = await db_session.execute(
-        select(CrawlRun)
-        .where(CrawlRun.user_id == user_id)
-        .order_by(CrawlRun.start_dt.desc(), CrawlRun.id.desc())
-        .limit(limit)
-    )
-    return list(result.scalars().all())
-
-
-async def list_runs_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    limit: int = 100,
-    failed_only: bool = False,
-) -> list[CrawlRun]:
-    stmt = (
-        select(CrawlRun)
-        .where(CrawlRun.user_id == user_id)
-        .order_by(CrawlRun.start_dt.desc(), CrawlRun.id.desc())
-        .limit(limit)
-    )
-    if failed_only:
-        stmt = stmt.where(
-            CrawlRun.status.in_([RunStatus.FAILED, RunStatus.PARTIAL_FAILURE])
-        )
-    result = await db_session.execute(stmt)
-    return list(result.scalars().all())
-
-
-async def get_run_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    run_id: int,
-) -> CrawlRun | None:
-    result = await db_session.execute(
-        select(CrawlRun).where(
-            CrawlRun.user_id == user_id,
-            CrawlRun.id == run_id,
-        )
-    )
-    return result.scalar_one_or_none()
-
-
-async def get_manual_run_by_idempotency_key(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    idempotency_key: str,
-) -> CrawlRun | None:
-    result = await db_session.execute(
-        select(CrawlRun)
-        .where(
-            CrawlRun.user_id == user_id,
-            CrawlRun.trigger_type == RunTriggerType.MANUAL,
-            or_(
-                CrawlRun.idempotency_key == idempotency_key,
-                CrawlRun.error_log["meta"]["idempotency_key"].astext == idempotency_key,
-            ),
-        )
-        .order_by(CrawlRun.start_dt.desc(), CrawlRun.id.desc())
-        .limit(1)
-    )
-    return result.scalar_one_or_none()
diff --git a/build/lib/app/services/domains/runs/summary.py b/build/lib/app/services/domains/runs/summary.py
deleted file mode 100644
index 9555558..0000000
--- a/build/lib/app/services/domains/runs/summary.py
+++ /dev/null
@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-
-def _safe_int(value: object, default: int = 0) -> int:
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        return default
-
-
-def _summary_dict(error_log: object) -> dict[str, Any]:
-    if not isinstance(error_log, dict):
-        return {}
-    summary = error_log.get("summary")
-    if not isinstance(summary, dict):
-        return {}
-    return summary
-
-
-def _summary_int_dict(summary: dict[str, Any], key: str) -> dict[str, int]:
-    value = summary.get(key)
-    if not isinstance(value, dict):
-        return {}
-    return {
-        str(item_key): _safe_int(item_value, 0)
-        for item_key, item_value in value.items()
-        if isinstance(item_key, str)
-    }
-
-
-def _summary_bool_dict(summary: dict[str, Any], key: str) -> dict[str, bool]:
-    value = summary.get(key)
-    if not isinstance(value, dict):
-        return {}
-    return {
-        str(item_key): bool(item_value)
-        for item_key, item_value in value.items()
-        if isinstance(item_key, str)
-    }
-
-
-def _retry_counts(summary: dict[str, Any]) -> dict[str, int]:
-    retry_counts = summary.get("retry_counts")
-    if not isinstance(retry_counts, dict):
-        retry_counts = {}
-    return {
-        "retries_scheduled_count": _safe_int(
-            retry_counts.get("retries_scheduled_count", 0),
-            0,
-        ),
-        "scholars_with_retries_count": _safe_int(
-            retry_counts.get("scholars_with_retries_count", 0),
-            0,
-        ),
-        "retry_exhausted_count": _safe_int(
-            retry_counts.get("retry_exhausted_count", 0),
-            0,
-        ),
-    }
-
-
-def extract_run_summary(error_log: object) -> dict[str, Any]:
-    summary = _summary_dict(error_log)
-    return {
-        "succeeded_count": _safe_int(summary.get("succeeded_count", 0)),
-        "failed_count": _safe_int(summary.get("failed_count", 0)),
-        "partial_count": _safe_int(summary.get("partial_count", 0)),
-        "failed_state_counts": _summary_int_dict(summary, "failed_state_counts"),
-        "failed_reason_counts": _summary_int_dict(summary, "failed_reason_counts"),
-        "scrape_failure_counts": _summary_int_dict(summary, "scrape_failure_counts"),
-        "retry_counts": _retry_counts(summary),
-        "alert_thresholds": _summary_int_dict(summary, "alert_thresholds"),
-        "alert_flags": _summary_bool_dict(summary, "alert_flags"),
-    }
diff --git a/build/lib/app/services/domains/runs/types.py b/build/lib/app/services/domains/runs/types.py
deleted file mode 100644
index 2524269..0000000
--- a/build/lib/app/services/domains/runs/types.py
+++ /dev/null
@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from datetime import datetime
-
-QUEUE_STATUS_QUEUED = "queued"
-QUEUE_STATUS_RETRYING = "retrying"
-QUEUE_STATUS_DROPPED = "dropped"
-
-
-@dataclass(frozen=True)
-class QueueListItem:
-    id: int
-    scholar_profile_id: int
-    scholar_label: str
-    status: str
-    reason: str
-    dropped_reason: str | None
-    attempt_count: int
-    resume_cstart: int
-    next_attempt_dt: datetime | None
-    updated_at: datetime
-    last_error: str | None
-    last_run_id: int | None
-
-
-@dataclass(frozen=True)
-class QueueClearResult:
-    queue_item_id: int
-    previous_status: str
-
-
-class QueueTransitionError(RuntimeError):
-    def __init__(self, *, code: str, message: str, current_status: str) -> None:
-        super().__init__(message)
-        self.code = code
-        self.message = message
-        self.current_status = current_status
diff --git a/build/lib/app/services/domains/scholar/__init__.py b/build/lib/app/services/domains/scholar/__init__.py
deleted file mode 100644
index 9d48db4..0000000
--- a/build/lib/app/services/domains/scholar/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from __future__ import annotations
diff --git a/build/lib/app/services/domains/scholar/author_rows.py b/build/lib/app/services/domains/scholar/author_rows.py
deleted file mode 100644
index 8acd783..0000000
--- a/build/lib/app/services/domains/scholar/author_rows.py
+++ /dev/null
@@ -1,202 +0,0 @@
-from __future__ import annotations
-
-import re
-from html.parser import HTMLParser
-from typing import Any
-from urllib.parse import parse_qs, urlparse
-
-from app.services.domains.scholar.parser_constants import AUTHOR_SEARCH_MARKER_KEYS
-from app.services.domains.scholar.parser_types import ScholarSearchCandidate
-from app.services.domains.scholar.parser_utils import (
-    attr_class,
-    attr_href,
-    attr_src,
-    build_absolute_scholar_url,
-    normalize_space,
-)
-
-
-def parse_scholar_id_from_href(href: str | None) -> str | None:
-    if not href:
-        return None
-    parsed = urlparse(href)
-    query = parse_qs(parsed.query)
-    user_values = query.get("user")
-    if not user_values:
-        return None
-    candidate = user_values[0].strip()
-    return candidate or None
-
-
-def _extract_verified_email_domain(value: str | None) -> str | None:
-    if not value:
-        return None
-    match = re.search(r"verified email at\s+(.+)$", value.strip(), re.I)
-    if not match:
-        return None
-    domain = normalize_space(match.group(1))
-    return domain or None
-
-
-class ScholarAuthorSearchParser(HTMLParser):
-    def __init__(self) -> None:
-        super().__init__(convert_charrefs=True)
-        self.candidates: list[ScholarSearchCandidate] = []
-        self._candidate: dict[str, Any] | None = None
-
-    def _begin_candidate(self) -> None:
-        self._candidate = {
-            "depth": 1,
-            "name_href": None,
-            "name_parts": [],
-            "aff_depth": 0,
-            "aff_parts": [],
-            "name_depth": 0,
-            "eml_depth": 0,
-            "eml_parts": [],
-            "cby_depth": 0,
-            "cby_parts": [],
-            "interest_depth": 0,
-            "interest_parts": [],
-            "interests": [],
-            "image_src": None,
-        }
-
-    def _increment_capture_depths(self) -> None:
-        if self._candidate is None:
-            return
-        for key in ("name_depth", "aff_depth", "eml_depth", "cby_depth", "interest_depth"):
-            if self._candidate[key] > 0:
-                self._candidate[key] += 1
-
-    def _finalize_candidate(self) -> None:
-        if self._candidate is None:
-            return
-
-        name = normalize_space("".join(self._candidate["name_parts"]))
-        scholar_id = parse_scholar_id_from_href(self._candidate["name_href"])
-        if not name or not scholar_id:
-            return
-
-        affiliation = normalize_space("".join(self._candidate["aff_parts"])) or None
-        email_domain = _extract_verified_email_domain(
-            normalize_space("".join(self._candidate["eml_parts"])) or None
-        )
-        cited_by_text = normalize_space("".join(self._candidate["cby_parts"]))
-        cited_by_match = re.search(r"\d+", cited_by_text)
-        cited_by_count = int(cited_by_match.group(0)) if cited_by_match else None
-
-        seen_interests: set[str] = set()
-        interests: list[str] = []
-        for interest in self._candidate["interests"]:
-            normalized = normalize_space(interest)
-            if not normalized or normalized in seen_interests:
-                continue
-            seen_interests.add(normalized)
-            interests.append(normalized)
-
-        profile_url = build_absolute_scholar_url(self._candidate["name_href"])
-        if not profile_url:
-            profile_url = (
-                "https://scholar.google.com/citations"
-                f"?hl=en&user={scholar_id}"
-            )
-
-        self.candidates.append(
-            ScholarSearchCandidate(
-                scholar_id=scholar_id,
-                display_name=name,
-                affiliation=affiliation,
-                email_domain=email_domain,
-                cited_by_count=cited_by_count,
-                interests=interests,
-                profile_url=profile_url,
-                profile_image_url=build_absolute_scholar_url(self._candidate["image_src"]),
-            )
-        )
-
-    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
-        classes = attr_class(attrs)
-
-        if self._candidate is None:
-            if tag == "div" and "gsc_1usr" in classes:
-                self._begin_candidate()
-            return
-
-        self._candidate["depth"] += 1
-        self._increment_capture_depths()
-
-        if tag == "a" and "gs_ai_name" in classes:
-            self._candidate["name_depth"] = 1
-            self._candidate["name_href"] = attr_href(attrs)
-            return
-
-        if tag == "div" and "gs_ai_aff" in classes:
-            self._candidate["aff_depth"] = 1
-            return
-
-        if tag == "div" and "gs_ai_eml" in classes:
-            self._candidate["eml_depth"] = 1
-            return
-
-        if tag == "div" and "gs_ai_cby" in classes:
-            self._candidate["cby_depth"] = 1
-            return
-
-        if tag == "a" and "gs_ai_one_int" in classes:
-            self._candidate["interest_depth"] = 1
-            self._candidate["interest_parts"] = []
-            return
-
-        if tag == "img" and self._candidate["image_src"] is None:
-            self._candidate["image_src"] = attr_src(attrs)
-
-    def handle_data(self, data: str) -> None:
-        if self._candidate is None:
-            return
-        if self._candidate["name_depth"] > 0:
-            self._candidate["name_parts"].append(data)
-        if self._candidate["aff_depth"] > 0:
-            self._candidate["aff_parts"].append(data)
-        if self._candidate["eml_depth"] > 0:
-            self._candidate["eml_parts"].append(data)
-        if self._candidate["cby_depth"] > 0:
-            self._candidate["cby_parts"].append(data)
-        if self._candidate["interest_depth"] > 0:
-            self._candidate["interest_parts"].append(data)
-
-    def _decrement_capture_depth(self, key: str) -> bool:
-        if self._candidate is None:
-            return False
-        if self._candidate[key] <= 0:
-            return False
-        self._candidate[key] -= 1
-        return self._candidate[key] == 0
-
-    def handle_endtag(self, _tag: str) -> None:
-        if self._candidate is None:
-            return
-
-        interest_closed = self._decrement_capture_depth("interest_depth")
-        self._decrement_capture_depth("name_depth")
-        self._decrement_capture_depth("aff_depth")
-        self._decrement_capture_depth("eml_depth")
-        self._decrement_capture_depth("cby_depth")
-
-        if interest_closed:
-            interest_text = normalize_space("".join(self._candidate["interest_parts"]))
-            if interest_text:
-                self._candidate["interests"].append(interest_text)
-            self._candidate["interest_parts"] = []
-
-        self._candidate["depth"] -= 1
-        if self._candidate["depth"] > 0:
-            return
-
-        self._finalize_candidate()
-        self._candidate = None
-
-
-def count_author_search_markers(html: str) -> dict[str, int]:
-    lowered = html.lower()
-    return {key: lowered.count(key.lower()) for key in AUTHOR_SEARCH_MARKER_KEYS}
diff --git a/build/lib/app/services/domains/scholar/parser.py b/build/lib/app/services/domains/scholar/parser.py
deleted file mode 100644
index 060e825..0000000
--- a/build/lib/app/services/domains/scholar/parser.py
+++ /dev/null
@@ -1,165 +0,0 @@
-from __future__ import annotations
-
-from app.services.domains.scholar.author_rows import (
-    ScholarAuthorSearchParser,
-    count_author_search_markers,
-    parse_scholar_id_from_href,
-)
-from app.services.domains.scholar.parser_constants import SCRIPT_STYLE_RE
-from app.services.domains.scholar.parser_types import (
-    ParseState,
-    ParsedAuthorSearchPage,
-    ParsedProfilePage,
-    PublicationCandidate,
-    ScholarDomInvariantError,
-    ScholarMalformedDataError,
-    ScholarParserError,
-    ScholarSearchCandidate,
-)
-from app.services.domains.scholar.parser_utils import (
-    strip_tags,
-)
-from app.services.domains.scholar.profile_rows import (
-    ScholarRowParser,
-    count_markers,
-    extract_articles_range,
-    extract_profile_image_url,
-    extract_profile_name,
-    extract_rows,
-    has_operation_error_banner,
-    has_show_more_button,
-    parse_citation_count,
-    parse_cluster_id_from_href,
-    parse_publications,
-    parse_year,
-)
-from app.services.domains.scholar.source import FetchResult
-from app.services.domains.scholar.state_detection import (
-    classify_block_or_captcha_reason,
-    classify_network_error_reason,
-    detect_author_search_state,
-    detect_state,
-)
-
-
-def _raise_dom_error(code: str, message: str) -> None:
-    raise ScholarDomInvariantError(code=code, message=message)
-
-
-def _assert_profile_dom_invariants(
-    *,
-    fetch_result: FetchResult,
-    marker_counts: dict[str, int],
-    publications: list[PublicationCandidate],
-    warnings: list[str],
-    has_show_more_button_flag: bool,
-    articles_range: str | None,
-) -> None:
-    if fetch_result.status_code is None:
-        return
-    final_url = (fetch_result.final_url or "").lower()
-    if "accounts.google.com" in final_url or "sorry/index" in final_url:
-        return
-    if any(code.startswith("layout_") for code in warnings):
-        reason = next(code for code in warnings if code.startswith("layout_"))
-        _raise_dom_error(reason, f"Detected layout warning: {reason}")
-    if has_show_more_button_flag and not articles_range:
-        _raise_dom_error(
-            "layout_show_more_without_articles_range",
-            "Show-more control exists without an articles range marker.",
-        )
-    if marker_counts.get("gsc_a_tr", 0) > 0 and marker_counts.get("gsc_a_at", 0) <= 0:
-        _raise_dom_error(
-            "layout_missing_publication_title_anchor",
-            "Publication rows were present but title anchors were absent.",
-        )
-    if not publications:
-        has_profile_markers = marker_counts.get("gsc_prf_in", 0) > 0
-        has_table_markers = marker_counts.get("gsc_a_tr", 0) > 0 or marker_counts.get("gsc_a_at", 0) > 0
-        if not has_profile_markers and not has_table_markers:
-            _raise_dom_error("layout_markers_missing", "Expected scholar profile markers were absent.")
-    for publication in publications:
-        if not publication.title.strip():
-            raise ScholarMalformedDataError(
-                code="malformed_publication_title",
-                message="Encountered a publication candidate with an empty title.",
-            )
-        if publication.citation_count is not None and int(publication.citation_count) < 0:
-            raise ScholarMalformedDataError(
-                code="malformed_publication_negative_citations",
-                message="Encountered a publication candidate with negative citations.",
-            )
-
-
-def parse_profile_page(fetch_result: FetchResult) -> ParsedProfilePage:
-    publications, warnings = parse_publications(fetch_result.body)
-    marker_counts = count_markers(fetch_result.body)
-    visible_text = strip_tags(SCRIPT_STYLE_RE.sub(" ", fetch_result.body)).lower()
-
-    show_more = has_show_more_button(fetch_result.body)
-    operation_error_banner = has_operation_error_banner(fetch_result.body)
-    articles_range = extract_articles_range(fetch_result.body)
-
-    if show_more:
-        warnings.append("possible_partial_page_show_more_present")
-    if operation_error_banner:
-        warnings.append("operation_error_banner_present")
-
-    warnings = sorted(set(warnings))
-    _assert_profile_dom_invariants(
-        fetch_result=fetch_result,
-        marker_counts=marker_counts,
-        publications=publications,
-        warnings=warnings,
-        has_show_more_button_flag=show_more,
-        articles_range=articles_range,
-    )
-
-    state, state_reason = detect_state(
-        fetch_result,
-        publications,
-        marker_counts,
-        warnings=warnings,
-        has_show_more_button_flag=show_more,
-        articles_range=articles_range,
-        visible_text=visible_text,
-    )
-
-    return ParsedProfilePage(
-        state=state,
-        state_reason=state_reason,
-        profile_name=extract_profile_name(fetch_result.body),
-        profile_image_url=extract_profile_image_url(fetch_result.body),
-        publications=publications,
-        marker_counts=marker_counts,
-        warnings=warnings,
-        has_show_more_button=show_more,
-        has_operation_error_banner=operation_error_banner,
-        articles_range=articles_range,
-    )
-
-
-def parse_author_search_page(fetch_result: FetchResult) -> ParsedAuthorSearchPage:
-    parser = ScholarAuthorSearchParser()
-    parser.feed(fetch_result.body)
-
-    marker_counts = count_author_search_markers(fetch_result.body)
-    visible_text = strip_tags(SCRIPT_STYLE_RE.sub(" ", fetch_result.body)).lower()
-    warnings: list[str] = []
-    if not parser.candidates:
-        warnings.append("no_author_candidates_detected")
-
-    state, state_reason = detect_author_search_state(
-        fetch_result,
-        parser.candidates,
-        marker_counts,
-        visible_text=visible_text,
-    )
-
-    return ParsedAuthorSearchPage(
-        state=state,
-        state_reason=state_reason,
-        candidates=parser.candidates,
-        marker_counts=marker_counts,
-        warnings=warnings,
-    )
diff --git a/build/lib/app/services/domains/scholar/parser_constants.py b/build/lib/app/services/domains/scholar/parser_constants.py
deleted file mode 100644
index c3c7a15..0000000
--- a/build/lib/app/services/domains/scholar/parser_constants.py
+++ /dev/null
@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-import re
-
-BLOCKED_KEYWORDS = [
-    "unusual traffic",
-    "sorry/index",
-    "not a robot",
-    "our systems have detected",
-    "automated queries",
-    "recaptcha",
-    "captcha",
-]
-
-NO_RESULTS_KEYWORDS = [
-    "didn't match any articles",
-    "did not match any articles",
-    "no articles",
-    "no documents",
-]
-
-NO_AUTHOR_RESULTS_KEYWORDS = [
-    "didn't match any user profiles",
-    "did not match any user profiles",
-    "didn't match any scholars",
-    "did not match any scholars",
-    "no user profiles",
-]
-
-MARKER_KEYS = [
-    "gsc_a_tr",
-    "gsc_a_at",
-    "gsc_a_ac",
-    "gsc_a_h",
-    "gsc_a_y",
-    "gs_gray",
-    "gsc_prf_in",
-    "gsc_rsb_st",
-]
-
-AUTHOR_SEARCH_MARKER_KEYS = [
-    "gsc_1usr",
-    "gs_ai_name",
-    "gs_ai_aff",
-    "gs_ai_eml",
-    "gs_ai_cby",
-    "gs_ai_one_int",
-]
-
-NETWORK_DNS_ERROR_KEYWORDS = [
-    "temporary failure in name resolution",
-    "name or service not known",
-    "nodename nor servname provided",
-    "getaddrinfo failed",
-]
-
-NETWORK_TIMEOUT_KEYWORDS = [
-    "timed out",
-    "timeout",
-]
-
-NETWORK_TLS_ERROR_KEYWORDS = [
-    "ssl",
-    "tls",
-    "certificate verify failed",
-]
-
-TAG_RE = re.compile(r"<[^>]+>", re.S)
-SCRIPT_STYLE_RE = re.compile(r"<(script|style)\b[^>]*>.*?</\1>", re.I | re.S)
-SHOW_MORE_BUTTON_RE = re.compile(
-    r"<button\b[^>]*\bid\s*=\s*['\"]gsc_bpf_more['\"][^>]*>",
-    re.I | re.S,
-)
-
-PROFILE_ROW_PARSER_DIRECT_MARKERS = (
-    "gs_ggs",
-    "gs_ggsd",
-    "gs_ggsa",
-    "gs_or_ggsm",
-)
-
-PROFILE_ROW_DIRECT_LABEL_TOKENS = (
-    "pdf",
-    "[pdf]",
-    "full text",
-    "download",
-)
diff --git a/build/lib/app/services/domains/scholar/parser_types.py b/build/lib/app/services/domains/scholar/parser_types.py
deleted file mode 100644
index 7b657d8..0000000
--- a/build/lib/app/services/domains/scholar/parser_types.py
+++ /dev/null
@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from enum import StrEnum
-
-
-class ParseState(StrEnum):
-    OK = "ok"
-    NO_RESULTS = "no_results"
-    BLOCKED_OR_CAPTCHA = "blocked_or_captcha"
-    LAYOUT_CHANGED = "layout_changed"
-    NETWORK_ERROR = "network_error"
-
-
-class ScholarParserError(RuntimeError):
-    code: str
-
-    def __init__(self, *, code: str, message: str) -> None:
-        super().__init__(message)
-        self.code = code
-
-
-class ScholarDomInvariantError(ScholarParserError):
-    pass
-
-
-class ScholarMalformedDataError(ScholarParserError):
-    pass
-
-
-@dataclass(frozen=True)
-class PublicationCandidate:
-    title: str
-    title_url: str | None
-    cluster_id: str | None
-    year: int | None
-    citation_count: int | None
-    authors_text: str | None
-    venue_text: str | None
-    pdf_url: str | None
-
-
-@dataclass(frozen=True)
-class ScholarSearchCandidate:
-    scholar_id: str
-    display_name: str
-    affiliation: str | None
-    email_domain: str | None
-    cited_by_count: int | None
-    interests: list[str]
-    profile_url: str
-    profile_image_url: str | None
-
-
-@dataclass(frozen=True)
-class ParsedProfilePage:
-    state: ParseState
-    state_reason: str
-    profile_name: str | None
-    profile_image_url: str | None
-    publications: list[PublicationCandidate]
-    marker_counts: dict[str, int]
-    warnings: list[str]
-    has_show_more_button: bool
-    has_operation_error_banner: bool
-    articles_range: str | None
-
-
-@dataclass(frozen=True)
-class ParsedAuthorSearchPage:
-    state: ParseState
-    state_reason: str
-    candidates: list[ScholarSearchCandidate]
-    marker_counts: dict[str, int]
-    warnings: list[str]
diff --git a/build/lib/app/services/domains/scholar/parser_utils.py b/build/lib/app/services/domains/scholar/parser_utils.py
deleted file mode 100644
index 1bf8687..0000000
--- a/build/lib/app/services/domains/scholar/parser_utils.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from __future__ import annotations
-
-from html import unescape
-
-from app.services.domains.scholar.parser_constants import TAG_RE
-
-
-def normalize_space(value: str) -> str:
-    return " ".join(unescape(value).split())
-
-
-def strip_tags(value: str) -> str:
-    return normalize_space(TAG_RE.sub(" ", value))
-
-
-def attr_class(attrs: list[tuple[str, str | None]]) -> str:
-    for name, raw_value in attrs:
-        if name.lower() == "class":
-            return raw_value or ""
-    return ""
-
-
-def attr_href(attrs: list[tuple[str, str | None]]) -> str | None:
-    for name, raw_value in attrs:
-        if name.lower() == "href":
-            return raw_value
-    return None
-
-
-def attr_src(attrs: list[tuple[str, str | None]]) -> str | None:
-    for name, raw_value in attrs:
-        if name.lower() == "src":
-            return raw_value
-    return None
-
-
-def build_absolute_scholar_url(path_or_url: str | None) -> str | None:
-    if not path_or_url:
-        return None
-    from urllib.parse import urljoin
-
-    return urljoin("https://scholar.google.com", path_or_url)
diff --git a/build/lib/app/services/domains/scholar/profile_rows.py b/build/lib/app/services/domains/scholar/profile_rows.py
deleted file mode 100644
index 6a63274..0000000
--- a/build/lib/app/services/domains/scholar/profile_rows.py
+++ /dev/null
@@ -1,270 +0,0 @@
-from __future__ import annotations
-
-import re
-from html.parser import HTMLParser
-from urllib.parse import parse_qs, urlparse
-
-from app.services.domains.scholar.parser_constants import (
-    MARKER_KEYS,
-    SHOW_MORE_BUTTON_RE,
-)
-from app.services.domains.scholar.parser_types import PublicationCandidate
-from app.services.domains.scholar.parser_utils import (
-    attr_class,
-    attr_href,
-    attr_src,
-    build_absolute_scholar_url,
-    normalize_space,
-    strip_tags,
-)
-
-
-class ScholarRowParser(HTMLParser):
-    def __init__(self) -> None:
-        super().__init__(convert_charrefs=True)
-        self.title_href: str | None = None
-        self.title_parts: list[str] = []
-        self.citation_parts: list[str] = []
-        self.year_parts: list[str] = []
-        self.gray_texts: list[str] = []
-
-        self._title_depth = 0
-        self._citation_depth = 0
-        self._year_depth = 0
-        self._gray_stack: list[dict[str, object]] = []
-
-    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
-        if self._title_depth > 0:
-            self._title_depth += 1
-        if self._citation_depth > 0:
-            self._citation_depth += 1
-        if self._year_depth > 0:
-            self._year_depth += 1
-        if self._gray_stack:
-            self._gray_stack[-1]["depth"] += 1
-
-        classes = attr_class(attrs)
-
-        if tag == "a" and "gsc_a_at" in classes:
-            self._title_depth = 1
-            self.title_href = attr_href(attrs)
-            return
-
-        if tag == "a" and "gsc_a_ac" in classes:
-            self._citation_depth = 1
-            return
-
-        if tag in {"span", "a"} and ("gsc_a_h" in classes or "gsc_a_y" in classes):
-            self._year_depth = 1
-            return
-
-        if tag == "div" and "gs_gray" in classes:
-            self._gray_stack.append({"depth": 1, "parts": []})
-            return
-
-    def handle_data(self, data: str) -> None:
-        if self._title_depth > 0:
-            self.title_parts.append(data)
-        if self._citation_depth > 0:
-            self.citation_parts.append(data)
-        if self._year_depth > 0:
-            self.year_parts.append(data)
-        if self._gray_stack:
-            self._gray_stack[-1]["parts"].append(data)
-
-    def handle_endtag(self, tag: str) -> None:
-        if self._title_depth > 0:
-            self._title_depth -= 1
-        if self._citation_depth > 0:
-            self._citation_depth -= 1
-        if self._year_depth > 0:
-            self._year_depth -= 1
-        if self._gray_stack:
-            self._gray_stack[-1]["depth"] -= 1
-            if self._gray_stack[-1]["depth"] == 0:
-                text_value = normalize_space("".join(self._gray_stack[-1]["parts"]))
-                if text_value:
-                    self.gray_texts.append(text_value)
-                self._gray_stack.pop()
-
-
-def extract_rows(html: str) -> list[str]:
-    pattern = re.compile(
-        r"<tr\b(?=[^>]*\bclass\s*=\s*['\"][^'\"]*\bgsc_a_tr\b[^'\"]*['\"])[^>]*>(.*?)</tr>",
-        re.I | re.S,
-    )
-    return [match.group(1) for match in pattern.finditer(html)]
-
-
-def parse_cluster_id_from_href(href: str | None) -> str | None:
-    if not href:
-        return None
-    parsed = urlparse(href)
-    query = parse_qs(parsed.query)
-
-    citation_for_view = query.get("citation_for_view")
-    if citation_for_view:
-        token = citation_for_view[0].strip()
-        if token:
-            return f"cfv:{token}"
-
-    cluster = query.get("cluster")
-    if cluster:
-        token = cluster[0].strip()
-        if token:
-            return f"cluster:{token}"
-    return None
-
-
-def parse_year(parts: list[str]) -> int | None:
-    text = normalize_space(" ".join(parts))
-    match = re.search(r"\b(19|20)\d{2}\b", text)
-    if not match:
-        return None
-    try:
-        return int(match.group(0))
-    except ValueError:
-        return None
-
-
-def parse_citation_count(parts: list[str]) -> int | None:
-    text = normalize_space(" ".join(parts))
-    if not text:
-        return 0
-    digits = re.sub(r"\D+", "", text)
-    if not digits:
-        return None
-    return int(digits)
-
-
-def _parse_publication_row(row_html: str) -> tuple[PublicationCandidate | None, list[str]]:
-    parser = ScholarRowParser()
-    parser.feed(row_html)
-    warnings: list[str] = []
-    title = normalize_space("".join(parser.title_parts))
-    if not title:
-        warnings.append("row_missing_title")
-        return None, warnings
-    if not parser.title_href:
-        warnings.append("row_missing_title_href")
-
-    citation_text = normalize_space(" ".join(parser.citation_parts))
-    citation_count = parse_citation_count(parser.citation_parts)
-    if citation_text and citation_count is None:
-        warnings.append("layout_row_citation_unparseable")
-
-    year_text = normalize_space(" ".join(parser.year_parts))
-    year = parse_year(parser.year_parts)
-    if year_text and year is None:
-        warnings.append("layout_row_year_unparseable")
-
-    authors_text = parser.gray_texts[0] if len(parser.gray_texts) > 0 else None
-    venue_text = parser.gray_texts[1] if len(parser.gray_texts) > 1 else None
-    return (
-        PublicationCandidate(
-            title=title,
-            title_url=parser.title_href,
-            cluster_id=parse_cluster_id_from_href(parser.title_href),
-            year=year,
-            citation_count=citation_count,
-            authors_text=authors_text,
-            venue_text=venue_text,
-            pdf_url=None,
-        ),
-        warnings,
-    )
-
-
-def parse_publications(html: str) -> tuple[list[PublicationCandidate], list[str]]:
-    rows = extract_rows(html)
-    warnings: list[str] = []
-    publications: list[PublicationCandidate] = []
-
-    for row_html in rows:
-        publication, row_warnings = _parse_publication_row(row_html)
-        warnings.extend(row_warnings)
-        if publication is None:
-            continue
-        publications.append(publication)
-
-    if not rows:
-        warnings.append("no_rows_detected")
-    if rows and not publications:
-        warnings.append("layout_all_rows_unparseable")
-
-    return publications, sorted(set(warnings))
-
-
-def extract_profile_name(html: str) -> str | None:
-    pattern = re.compile(
-        r"<[^>]*\bid\s*=\s*['\"]gsc_prf_in['\"][^>]*>(.*?)</[^>]+>",
-        re.I | re.S,
-    )
-    match = pattern.search(html)
-    if not match:
-        return None
-    value = strip_tags(match.group(1))
-    return value or None
-
-
-def extract_profile_image_url(html: str) -> str | None:
-    og_image_pattern = re.compile(
-        r"<meta[^>]+property=['\"]og:image['\"][^>]+content=['\"]([^'\"]+)['\"][^>]*>",
-        re.I | re.S,
-    )
-    og_match = og_image_pattern.search(html)
-    if og_match:
-        value = normalize_space(og_match.group(1))
-        absolute = build_absolute_scholar_url(value)
-        if absolute:
-            return absolute
-
-    image_pattern = re.compile(
-        r"<img[^>]*\bid=['\"]gsc_prf_pup-img['\"][^>]*\bsrc=['\"]([^'\"]+)['\"][^>]*>",
-        re.I | re.S,
-    )
-    image_match = image_pattern.search(html)
-    if not image_match:
-        return None
-
-    value = normalize_space(image_match.group(1))
-    return build_absolute_scholar_url(value)
-
-
-def extract_articles_range(html: str) -> str | None:
-    pattern = re.compile(
-        r"<[^>]*\bid\s*=\s*['\"]gsc_a_nn['\"][^>]*>(.*?)</[^>]+>",
-        re.I | re.S,
-    )
-    match = pattern.search(html)
-    if not match:
-        return None
-    value = strip_tags(match.group(1))
-    return value or None
-
-
-def has_show_more_button(html: str) -> bool:
-    match = SHOW_MORE_BUTTON_RE.search(html)
-    if match is None:
-        return False
-
-    button_tag = match.group(0).lower()
-    if "disabled" in button_tag:
-        return False
-    if 'aria-disabled="true"' in button_tag or "aria-disabled='true'" in button_tag:
-        return False
-    if "gs_dis" in button_tag:
-        return False
-    return True
-
-
-def has_operation_error_banner(html: str) -> bool:
-    lowered = html.lower()
-    if "id=\"gsc_a_err\"" not in lowered and "id='gsc_a_err'" not in lowered:
-        return False
-    return "can't perform the operation now" in lowered or "cannot perform the operation now" in lowered
-
-
-def count_markers(html: str) -> dict[str, int]:
-    lowered = html.lower()
-    return {key: lowered.count(key.lower()) for key in MARKER_KEYS}
diff --git a/build/lib/app/services/domains/scholar/rate_limit.py b/build/lib/app/services/domains/scholar/rate_limit.py
deleted file mode 100644
index 947c91f..0000000
--- a/build/lib/app/services/domains/scholar/rate_limit.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import time
-
-_REQUEST_LOCK = asyncio.Lock()
-_LAST_REQUEST_AT = 0.0
-
-
-async def wait_for_scholar_slot(*, min_interval_seconds: float) -> None:
-    global _LAST_REQUEST_AT
-    interval = max(float(min_interval_seconds), 0.0)
-    async with _REQUEST_LOCK:
-        elapsed = time.monotonic() - _LAST_REQUEST_AT
-        remaining = interval - elapsed
-        if remaining > 0:
-            await asyncio.sleep(remaining)
-        _LAST_REQUEST_AT = time.monotonic()
diff --git a/build/lib/app/services/domains/scholar/source.py b/build/lib/app/services/domains/scholar/source.py
deleted file mode 100644
index 92c6702..0000000
--- a/build/lib/app/services/domains/scholar/source.py
+++ /dev/null
@@ -1,235 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-import random
-from dataclasses import dataclass
-from typing import Protocol
-from urllib.error import HTTPError, URLError
-from urllib.parse import urlencode
-from urllib.request import Request, urlopen
-
-SCHOLAR_PROFILE_URL = "https://scholar.google.com/citations"
-DEFAULT_PAGE_SIZE = 100
-
-DEFAULT_USER_AGENTS = [
-    (
-        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
-        "(KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
-    ),
-    (
-        "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7) AppleWebKit/605.1.15 "
-        "(KHTML, like Gecko) Version/18.1 Safari/605.1.15"
-    ),
-    (
-        "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) "
-        "Gecko/20100101 Firefox/131.0"
-    ),
-]
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class FetchResult:
-    requested_url: str
-    status_code: int | None
-    final_url: str | None
-    body: str
-    error: str | None
-
-
-class ScholarSource(Protocol):
-    async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
-        ...
-
-    async def fetch_profile_page_html(
-        self,
-        scholar_id: str,
-        *,
-        cstart: int,
-        pagesize: int,
-    ) -> FetchResult:
-        ...
-
-    async def fetch_author_search_html(
-        self,
-        query: str,
-        *,
-        start: int,
-    ) -> FetchResult:
-        ...
-
-
-class LiveScholarSource:
-    def __init__(
-        self,
-        *,
-        timeout_seconds: float = 25.0,
-        user_agents: list[str] | None = None,
-    ) -> None:
-        self._timeout_seconds = timeout_seconds
-        self._user_agents = user_agents or DEFAULT_USER_AGENTS
-
-    async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
-        return await self.fetch_profile_page_html(
-            scholar_id,
-            cstart=0,
-            pagesize=DEFAULT_PAGE_SIZE,
-        )
-
-    async def fetch_profile_page_html(
-        self,
-        scholar_id: str,
-        *,
-        cstart: int,
-        pagesize: int = DEFAULT_PAGE_SIZE,
-    ) -> FetchResult:
-        requested_url = _build_profile_url(
-            scholar_id=scholar_id,
-            cstart=cstart,
-            pagesize=pagesize,
-        )
-        logger.debug(
-            "scholar_source.fetch_started",
-            extra={
-                "event": "scholar_source.fetch_started",
-                "scholar_id": scholar_id,
-                "requested_url": requested_url,
-                "cstart": cstart,
-                "pagesize": pagesize,
-            },
-        )
-        return await asyncio.to_thread(self._fetch_sync, requested_url)
-
-    async def fetch_author_search_html(
-        self,
-        query: str,
-        *,
-        start: int = 0,
-    ) -> FetchResult:
-        requested_url = _build_author_search_url(
-            query=query,
-            start=start,
-        )
-        logger.debug(
-            "scholar_source.search_fetch_started",
-            extra={
-                "event": "scholar_source.search_fetch_started",
-                "query": query,
-                "requested_url": requested_url,
-                "start": start,
-            },
-        )
-        return await asyncio.to_thread(self._fetch_sync, requested_url)
-
-    async def fetch_publication_html(self, publication_url: str) -> FetchResult:
-        logger.debug(
-            "scholar_source.publication_fetch_started",
-            extra={
-                "event": "scholar_source.publication_fetch_started",
-                "requested_url": publication_url,
-            },
-        )
-        return await asyncio.to_thread(self._fetch_sync, publication_url)
-
-    def _build_request(self, requested_url: str) -> Request:
-        return Request(
-            requested_url,
-            headers={
-                "User-Agent": random.choice(self._user_agents),
-                "Accept": "text/html,application/xhtml+xml",
-                "Accept-Language": "en-US,en;q=0.9",
-                "Connection": "close",
-            },
-        )
-
-    @staticmethod
-    def _http_error_body(exc: HTTPError) -> str:
-        try:
-            return exc.read().decode("utf-8", errors="replace")
-        except Exception:
-            return ""
-
-    @staticmethod
-    def _network_error_result(requested_url: str, exc: URLError) -> FetchResult:
-        logger.warning(
-            "scholar_source.fetch_network_error",
-            extra={"event": "scholar_source.fetch_network_error", "requested_url": requested_url},
-        )
-        return FetchResult(
-            requested_url=requested_url,
-            status_code=None,
-            final_url=None,
-            body="",
-            error=str(exc),
-        )
-
-    @staticmethod
-    def _http_error_result(requested_url: str, exc: HTTPError) -> FetchResult:
-        logger.warning(
-            "scholar_source.fetch_http_error",
-            extra={
-                "event": "scholar_source.fetch_http_error",
-                "requested_url": requested_url,
-                "status_code": exc.code,
-            },
-        )
-        return FetchResult(
-            requested_url=requested_url,
-            status_code=exc.code,
-            final_url=exc.geturl(),
-            body=LiveScholarSource._http_error_body(exc),
-            error=str(exc),
-        )
-
-    @staticmethod
-    def _success_result(requested_url: str, response) -> FetchResult:
-        body = response.read().decode("utf-8", errors="replace")
-        status_code = getattr(response, "status", 200)
-        logger.debug(
-            "scholar_source.fetch_succeeded",
-            extra={
-                "event": "scholar_source.fetch_succeeded",
-                "requested_url": requested_url,
-                "status_code": status_code,
-            },
-        )
-        return FetchResult(
-            requested_url=requested_url,
-            status_code=status_code,
-            final_url=response.geturl(),
-            body=body,
-            error=None,
-        )
-
-    def _fetch_sync(self, requested_url: str) -> FetchResult:
-        request = self._build_request(requested_url)
-
-        try:
-            with urlopen(request, timeout=self._timeout_seconds) as response:
-                return self._success_result(requested_url, response)
-        except HTTPError as exc:
-            return self._http_error_result(requested_url, exc)
-        except URLError as exc:
-            return self._network_error_result(requested_url, exc)
-
-
-def _build_profile_url(*, scholar_id: str, cstart: int, pagesize: int) -> str:
-    query: dict[str, int | str] = {"hl": "en", "user": scholar_id}
-    if cstart > 0:
-        query["cstart"] = int(cstart)
-    if pagesize > 0:
-        query["pagesize"] = int(pagesize)
-    return f"{SCHOLAR_PROFILE_URL}?{urlencode(query)}"
-
-
-def _build_author_search_url(*, query: str, start: int) -> str:
-    params: dict[str, int | str] = {
-        "hl": "en",
-        "view_op": "search_authors",
-        "mauthors": query,
-    }
-    if start > 0:
-        params["astart"] = int(start)
-    return f"{SCHOLAR_PROFILE_URL}?{urlencode(params)}"
diff --git a/build/lib/app/services/domains/scholar/state_detection.py b/build/lib/app/services/domains/scholar/state_detection.py
deleted file mode 100644
index cdc8780..0000000
--- a/build/lib/app/services/domains/scholar/state_detection.py
+++ /dev/null
@@ -1,164 +0,0 @@
-from __future__ import annotations
-
-from app.services.domains.scholar.parser_constants import (
-    BLOCKED_KEYWORDS,
-    NETWORK_DNS_ERROR_KEYWORDS,
-    NETWORK_TIMEOUT_KEYWORDS,
-    NETWORK_TLS_ERROR_KEYWORDS,
-    NO_AUTHOR_RESULTS_KEYWORDS,
-    NO_RESULTS_KEYWORDS,
-)
-from app.services.domains.scholar.parser_types import ParseState, PublicationCandidate, ScholarSearchCandidate
-from app.services.domains.scholar.source import FetchResult
-
-
-def classify_network_error_reason(fetch_error: str | None) -> str:
-    lowered = (fetch_error or "").lower()
-    if lowered:
-        if any(keyword in lowered for keyword in NETWORK_DNS_ERROR_KEYWORDS):
-            return "network_dns_resolution_failed"
-        if any(keyword in lowered for keyword in NETWORK_TIMEOUT_KEYWORDS):
-            return "network_timeout"
-        if any(keyword in lowered for keyword in NETWORK_TLS_ERROR_KEYWORDS):
-            return "network_tls_error"
-        if "connection reset" in lowered:
-            return "network_connection_reset"
-        if "connection refused" in lowered:
-            return "network_connection_refused"
-        if "network is unreachable" in lowered:
-            return "network_unreachable"
-    return "network_error_missing_status_code"
-
-
-def classify_block_or_captcha_reason(
-    *,
-    status_code: int,
-    final_url: str,
-    body_lowered: str,
-) -> str | None:
-    if "accounts.google.com" in final_url and ("signin" in final_url or "servicelogin" in final_url):
-        return "blocked_accounts_redirect"
-    if status_code == 429:
-        return "blocked_http_429_rate_limited"
-    if status_code == 403:
-        if "recaptcha" in body_lowered or "captcha" in body_lowered or "sorry/index" in final_url:
-            return "blocked_http_403_captcha_challenge"
-        return "blocked_http_403_forbidden"
-    if "sorry/index" in final_url or "sorry/index" in body_lowered:
-        return "blocked_google_sorry_challenge"
-    if "our systems have detected" in body_lowered or "unusual traffic" in body_lowered:
-        return "blocked_unusual_traffic_detected"
-    if "automated queries" in body_lowered:
-        return "blocked_automated_queries_detected"
-    if "not a robot" in body_lowered:
-        return "blocked_not_a_robot_challenge"
-    if "recaptcha" in body_lowered:
-        return "blocked_recaptcha_challenge"
-    if "captcha" in body_lowered:
-        return "blocked_captcha_challenge"
-    if any(keyword in body_lowered for keyword in BLOCKED_KEYWORDS):
-        return "blocked_keyword_detected"
-    return None
-
-
-def _warnings_contain(warnings: list[str], code: str) -> bool:
-    return any(item == code for item in warnings)
-
-
-def _has_layout_row_failure(marker_counts: dict[str, int], warnings: list[str]) -> bool:
-    if _warnings_contain(warnings, "layout_all_rows_unparseable"):
-        return True
-    if marker_counts.get("gsc_a_tr", 0) <= 0:
-        return False
-    if _warnings_contain(warnings, "row_missing_title"):
-        return True
-    return marker_counts.get("gsc_a_at", 0) <= 0
-
-
-def _first_layout_warning(warnings: list[str]) -> str | None:
-    for warning in warnings:
-        if warning.startswith("layout_"):
-            return warning
-    return None
-
-
-def detect_state(
-    fetch_result: FetchResult,
-    publications: list[PublicationCandidate],
-    marker_counts: dict[str, int],
-    *,
-    warnings: list[str],
-    has_show_more_button_flag: bool,
-    articles_range: str | None,
-    visible_text: str,
-) -> tuple[ParseState, str]:
-    if fetch_result.status_code is None:
-        return ParseState.NETWORK_ERROR, classify_network_error_reason(fetch_result.error)
-
-    lowered = fetch_result.body.lower()
-    final = (fetch_result.final_url or "").lower()
-    status_code = int(fetch_result.status_code)
-
-    block_reason = classify_block_or_captcha_reason(
-        status_code=status_code,
-        final_url=final,
-        body_lowered=lowered,
-    )
-    if block_reason is not None:
-        return ParseState.BLOCKED_OR_CAPTCHA, block_reason
-
-    if not publications and any(keyword in visible_text for keyword in NO_RESULTS_KEYWORDS):
-        return ParseState.NO_RESULTS, "no_results_keyword_detected"
-
-    layout_warning = _first_layout_warning(warnings)
-    if layout_warning is not None:
-        return ParseState.LAYOUT_CHANGED, layout_warning
-
-    if _has_layout_row_failure(marker_counts, warnings):
-        return ParseState.LAYOUT_CHANGED, "layout_publication_rows_unparseable"
-
-    if has_show_more_button_flag and not articles_range:
-        return ParseState.LAYOUT_CHANGED, "layout_show_more_without_articles_range"
-
-    if not publications:
-        has_profile_markers = marker_counts.get("gsc_prf_in", 0) > 0
-        has_table_markers = marker_counts.get("gsc_a_tr", 0) > 0 or marker_counts.get("gsc_a_at", 0) > 0
-        if not has_profile_markers and not has_table_markers:
-            return ParseState.LAYOUT_CHANGED, "layout_markers_missing"
-        return ParseState.OK, "no_rows_with_known_markers"
-
-    return ParseState.OK, "publications_extracted"
-
-
-def detect_author_search_state(
-    fetch_result: FetchResult,
-    candidates: list[ScholarSearchCandidate],
-    marker_counts: dict[str, int],
-    *,
-    visible_text: str,
-) -> tuple[ParseState, str]:
-    if fetch_result.status_code is None:
-        return ParseState.NETWORK_ERROR, classify_network_error_reason(fetch_result.error)
-
-    lowered = fetch_result.body.lower()
-    final = (fetch_result.final_url or "").lower()
-    status_code = int(fetch_result.status_code)
-
-    block_reason = classify_block_or_captcha_reason(
-        status_code=status_code,
-        final_url=final,
-        body_lowered=lowered,
-    )
-    if block_reason is not None:
-        return ParseState.BLOCKED_OR_CAPTCHA, block_reason
-
-    if not candidates and any(keyword in visible_text for keyword in NO_AUTHOR_RESULTS_KEYWORDS):
-        return ParseState.NO_RESULTS, "no_results_keyword_detected"
-
-    if not candidates:
-        has_search_markers = marker_counts.get("gsc_1usr", 0) > 0 or marker_counts.get("gs_ai_name", 0) > 0
-        if not has_search_markers:
-            return ParseState.NO_RESULTS, "no_search_candidates_detected"
-        return ParseState.LAYOUT_CHANGED, "layout_author_candidates_unparseable"
-
-    return ParseState.OK, "author_candidates_extracted"
diff --git a/build/lib/app/services/domains/scholars/__init__.py b/build/lib/app/services/domains/scholars/__init__.py
deleted file mode 100644
index 9d48db4..0000000
--- a/build/lib/app/services/domains/scholars/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from __future__ import annotations
diff --git a/build/lib/app/services/domains/scholars/application.py b/build/lib/app/services/domains/scholars/application.py
deleted file mode 100644
index 8da041f..0000000
--- a/build/lib/app/services/domains/scholars/application.py
+++ /dev/null
@@ -1,974 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from dataclasses import replace
-from datetime import datetime
-from datetime import timedelta
-from datetime import timezone
-import logging
-import os
-import random
-from uuid import uuid4
-
-from sqlalchemy import delete, func, select, text
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import AuthorSearchCacheEntry, AuthorSearchRuntimeState, ScholarProfile
-from app.services.domains.scholar.parser import (
-    ParseState,
-    ParsedAuthorSearchPage,
-    ScholarParserError,
-    parse_author_search_page,
-    parse_profile_page,
-)
-from app.services.domains.scholar.source import ScholarSource
-from app.services.domains.scholars.constants import (
-    ALLOWED_IMAGE_UPLOAD_CONTENT_TYPES,
-    AUTHOR_SEARCH_LOCK_KEY,
-    AUTHOR_SEARCH_LOCK_NAMESPACE,
-    AUTHOR_SEARCH_RUNTIME_STATE_KEY,
-    DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS,
-    DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES,
-    DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD,
-    DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD,
-    DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS,
-    DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS,
-    MAX_AUTHOR_SEARCH_LIMIT,
-    DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS,
-    DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD,
-    SEARCH_CACHED_BLOCK_REASON,
-    SEARCH_COOLDOWN_REASON,
-    SEARCH_DISABLED_REASON,
-)
-from app.services.domains.scholars.exceptions import ScholarServiceError
-from app.services.domains.scholars.search_hints import (
-    _merge_warnings,
-    _policy_blocked_author_search_result,
-    _trim_author_search_result,
-    resolve_profile_image,
-    scrape_state_hint,
-)
-from app.services.domains.scholars.uploads import (
-    _ensure_upload_root,
-    _resolve_upload_path,
-    _safe_remove_upload,
-    resolve_upload_file_path,
-)
-from app.services.domains.scholars.validators import (
-    normalize_display_name,
-    normalize_profile_image_url,
-    validate_scholar_id,
-)
-logger = logging.getLogger(__name__)
-
-
-async def _acquire_author_search_lock(db_session: AsyncSession) -> None:
-    await db_session.execute(
-        text("SELECT pg_advisory_xact_lock(:namespace, :lock_key)"),
-        {
-            "namespace": AUTHOR_SEARCH_LOCK_NAMESPACE,
-            "lock_key": AUTHOR_SEARCH_LOCK_KEY,
-        },
-    )
-
-
-async def _load_runtime_state_for_update(
-    db_session: AsyncSession,
-) -> AuthorSearchRuntimeState:
-    result = await db_session.execute(
-        select(AuthorSearchRuntimeState)
-        .where(AuthorSearchRuntimeState.state_key == AUTHOR_SEARCH_RUNTIME_STATE_KEY)
-        .with_for_update()
-    )
-    state = result.scalar_one_or_none()
-    if state is not None:
-        return state
-
-    state = AuthorSearchRuntimeState(state_key=AUTHOR_SEARCH_RUNTIME_STATE_KEY)
-    db_session.add(state)
-    await db_session.flush()
-    return state
-
-
-def _serialize_parsed_author_search_page(parsed: ParsedAuthorSearchPage) -> dict:
-    return {
-        "state": parsed.state.value,
-        "state_reason": parsed.state_reason,
-        "marker_counts": {str(key): int(value) for key, value in parsed.marker_counts.items()},
-        "warnings": [str(value) for value in parsed.warnings],
-        "candidates": [
-            {
-                "scholar_id": candidate.scholar_id,
-                "display_name": candidate.display_name,
-                "affiliation": candidate.affiliation,
-                "email_domain": candidate.email_domain,
-                "cited_by_count": candidate.cited_by_count,
-                "interests": [str(interest) for interest in candidate.interests],
-                "profile_url": candidate.profile_url,
-                "profile_image_url": candidate.profile_image_url,
-            }
-            for candidate in parsed.candidates
-        ],
-    }
-
-
-def _payload_state(payload: dict[str, object]) -> ParseState | None:
-    state_raw = str(payload.get("state", "")).strip()
-    try:
-        return ParseState(state_raw)
-    except ValueError:
-        return None
-
-
-def _payload_marker_counts(payload: dict[str, object]) -> dict[str, int]:
-    marker_counts_payload = payload.get("marker_counts")
-    if not isinstance(marker_counts_payload, dict):
-        return {}
-    parsed: dict[str, int] = {}
-    for key, value in marker_counts_payload.items():
-        try:
-            parsed[str(key)] = int(value)
-        except (TypeError, ValueError):
-            continue
-    return parsed
-
-
-def _payload_warnings(payload: dict[str, object]) -> list[str]:
-    warnings_payload = payload.get("warnings")
-    if not isinstance(warnings_payload, list):
-        return []
-    return [str(value) for value in warnings_payload if isinstance(value, str)]
-
-
-def _parse_optional_string(value: object) -> str | None:
-    if value is None:
-        return None
-    normalized = str(value).strip()
-    return normalized or None
-
-
-def _parse_optional_int(value: object) -> int | None:
-    if isinstance(value, int):
-        return value
-    if isinstance(value, str) and value.strip():
-        try:
-            return int(value)
-        except ValueError:
-            return None
-    return None
-
-
-def _normalize_interests(value: object) -> list[str]:
-    if not isinstance(value, list):
-        return []
-    return [str(item) for item in value if isinstance(item, str)]
-
-
-def _deserialize_candidate_payload(value: object) -> dict[str, object] | None:
-    if not isinstance(value, dict):
-        return None
-    scholar_id = str(value.get("scholar_id", "")).strip()
-    display_name = str(value.get("display_name", "")).strip()
-    profile_url = str(value.get("profile_url", "")).strip()
-    if not scholar_id or not display_name or not profile_url:
-        return None
-    return {
-        "scholar_id": scholar_id,
-        "display_name": display_name,
-        "affiliation": _parse_optional_string(value.get("affiliation")),
-        "email_domain": _parse_optional_string(value.get("email_domain")),
-        "cited_by_count": _parse_optional_int(value.get("cited_by_count")),
-        "interests": _normalize_interests(value.get("interests")),
-        "profile_url": profile_url,
-        "profile_image_url": _parse_optional_string(value.get("profile_image_url")),
-    }
-
-
-def _deserialize_candidates(payload: dict[str, object]) -> list[dict[str, object]]:
-    candidates_payload = payload.get("candidates")
-    if not isinstance(candidates_payload, list):
-        return []
-    normalized: list[dict[str, object]] = []
-    for value in candidates_payload:
-        candidate = _deserialize_candidate_payload(value)
-        if candidate is not None:
-            normalized.append(candidate)
-    return normalized
-
-
-def _deserialize_parsed_author_search_page(payload: object) -> ParsedAuthorSearchPage | None:
-    if not isinstance(payload, dict):
-        return None
-
-    state = _payload_state(payload)
-    if state is None:
-        return None
-
-    marker_counts = _payload_marker_counts(payload)
-    warnings = _payload_warnings(payload)
-    from app.services.domains.scholar.parser import ScholarSearchCandidate
-
-    normalized_candidates = _deserialize_candidates(payload)
-
-    return ParsedAuthorSearchPage(
-        state=state,
-        state_reason=str(payload.get("state_reason", "")).strip() or "unknown",
-        candidates=[
-            ScholarSearchCandidate(
-                scholar_id=item["scholar_id"],
-                display_name=item["display_name"],
-                affiliation=item["affiliation"],
-                email_domain=item["email_domain"],
-                cited_by_count=item["cited_by_count"],
-                interests=item["interests"],
-                profile_url=item["profile_url"],
-                profile_image_url=item["profile_image_url"],
-            )
-            for item in normalized_candidates
-        ],
-        marker_counts=marker_counts,
-        warnings=warnings,
-    )
-
-
-async def _cache_get_author_search_result(
-    db_session: AsyncSession,
-    *,
-    query_key: str,
-    now_utc: datetime,
-) -> ParsedAuthorSearchPage | None:
-    result = await db_session.execute(
-        select(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key == query_key)
-    )
-    entry = result.scalar_one_or_none()
-    if entry is None:
-        return None
-    expires_at = entry.expires_at
-    if expires_at.tzinfo is None:
-        expires_at = expires_at.replace(tzinfo=timezone.utc)
-    if expires_at <= now_utc:
-        await db_session.delete(entry)
-        return None
-    parsed = _deserialize_parsed_author_search_page(entry.payload)
-    if parsed is None:
-        await db_session.delete(entry)
-        return None
-    return parsed
-
-
-async def _cache_set_author_search_result(
-    db_session: AsyncSession,
-    *,
-    query_key: str,
-    parsed: ParsedAuthorSearchPage,
-    ttl_seconds: float,
-    max_entries: int,
-    now_utc: datetime,
-) -> None:
-    ttl = max(float(ttl_seconds), 0.0)
-    existing_result = await db_session.execute(
-        select(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key == query_key)
-    )
-    existing = existing_result.scalar_one_or_none()
-
-    if ttl <= 0.0:
-        if existing is not None:
-            await db_session.delete(existing)
-        return
-
-    expires_at = now_utc + timedelta(seconds=ttl)
-    payload = _serialize_parsed_author_search_page(parsed)
-    if existing is None:
-        db_session.add(
-            AuthorSearchCacheEntry(
-                query_key=query_key,
-                payload=payload,
-                expires_at=expires_at,
-                cached_at=now_utc,
-                updated_at=now_utc,
-            )
-        )
-    else:
-        existing.payload = payload
-        existing.expires_at = expires_at
-        existing.cached_at = now_utc
-        existing.updated_at = now_utc
-
-    await _prune_author_search_cache(db_session, now_utc=now_utc, max_entries=max_entries)
-
-
-async def _prune_author_search_cache(
-    db_session: AsyncSession,
-    *,
-    now_utc: datetime,
-    max_entries: int,
-) -> None:
-    await db_session.execute(
-        delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.expires_at <= now_utc)
-    )
-    bounded_max_entries = max(1, int(max_entries))
-    count_result = await db_session.execute(
-        select(func.count()).select_from(AuthorSearchCacheEntry)
-    )
-    entry_count = int(count_result.scalar_one() or 0)
-    overflow = max(0, entry_count - bounded_max_entries)
-    if overflow <= 0:
-        return
-    stale_keys_result = await db_session.execute(
-        select(AuthorSearchCacheEntry.query_key)
-        .order_by(AuthorSearchCacheEntry.cached_at.asc())
-        .limit(overflow)
-    )
-    stale_keys = [str(row[0]) for row in stale_keys_result.all()]
-    if stale_keys:
-        await db_session.execute(
-            delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key.in_(stale_keys))
-        )
-
-
-def _is_author_search_block_state(parsed: ParsedAuthorSearchPage) -> bool:
-    return parsed.state == ParseState.BLOCKED_OR_CAPTCHA
-
-
-def _author_search_cooldown_remaining_seconds(
-    runtime_state: AuthorSearchRuntimeState,
-    now_utc: datetime,
-) -> int:
-    cooldown_until = runtime_state.cooldown_until
-    if cooldown_until is None:
-        return 0
-    if cooldown_until.tzinfo is None:
-        cooldown_until = cooldown_until.replace(tzinfo=timezone.utc)
-    remaining_seconds = int((cooldown_until - now_utc).total_seconds())
-    return max(0, remaining_seconds)
-
-
-async def list_scholars_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-) -> list[ScholarProfile]:
-    result = await db_session.execute(
-        select(ScholarProfile)
-        .where(ScholarProfile.user_id == user_id)
-        .order_by(ScholarProfile.created_at.desc(), ScholarProfile.id.desc())
-    )
-    return list(result.scalars().all())
-
-
-async def create_scholar_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_id: str,
-    display_name: str,
-    profile_image_url: str | None = None,
-) -> ScholarProfile:
-    profile = ScholarProfile(
-        user_id=user_id,
-        scholar_id=validate_scholar_id(scholar_id),
-        display_name=normalize_display_name(display_name),
-        profile_image_url=normalize_profile_image_url(profile_image_url),
-    )
-    db_session.add(profile)
-    try:
-        await db_session.commit()
-    except IntegrityError as exc:
-        await db_session.rollback()
-        raise ScholarServiceError("That scholar is already tracked for this account.") from exc
-    await db_session.refresh(profile)
-    return profile
-
-
-async def get_user_scholar_by_id(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int,
-) -> ScholarProfile | None:
-    result = await db_session.execute(
-        select(ScholarProfile).where(
-            ScholarProfile.id == scholar_profile_id,
-            ScholarProfile.user_id == user_id,
-        )
-    )
-    return result.scalar_one_or_none()
-
-
-async def toggle_scholar_enabled(
-    db_session: AsyncSession,
-    *,
-    profile: ScholarProfile,
-) -> ScholarProfile:
-    profile.is_enabled = not profile.is_enabled
-    await db_session.commit()
-    await db_session.refresh(profile)
-    return profile
-
-
-async def delete_scholar(
-    db_session: AsyncSession,
-    *,
-    profile: ScholarProfile,
-    upload_dir: str | None = None,
-) -> None:
-    if upload_dir:
-        upload_root = _ensure_upload_root(upload_dir, create=True)
-        _safe_remove_upload(upload_root, profile.profile_image_upload_path)
-
-    await db_session.delete(profile)
-    await db_session.commit()
-
-
-def _normalize_author_search_inputs(query: str, limit: int) -> tuple[str, int, str]:
-    normalized_query = query.strip()
-    if len(normalized_query) < 2:
-        raise ScholarServiceError("Search query must be at least 2 characters.")
-    bounded_limit = max(1, min(int(limit), MAX_AUTHOR_SEARCH_LIMIT))
-    return normalized_query, bounded_limit, normalized_query.casefold()
-
-
-def _disabled_search_result(*, normalized_query: str, bounded_limit: int) -> ParsedAuthorSearchPage:
-    logger.warning(
-        "scholar_search.disabled_by_configuration",
-        extra={"event": "scholar_search.disabled_by_configuration", "query": normalized_query},
-    )
-    return _policy_blocked_author_search_result(
-        reason=SEARCH_DISABLED_REASON,
-        warning_codes=["author_search_disabled_by_configuration"],
-        limit=bounded_limit,
-    )
-
-
-def _normalize_runtime_cooldown_state(
-    runtime_state: AuthorSearchRuntimeState,
-    *,
-    now_utc: datetime,
-) -> bool:
-    if runtime_state.cooldown_until is None:
-        return False
-    cooldown_until = runtime_state.cooldown_until
-    updated = False
-    if cooldown_until.tzinfo is None:
-        cooldown_until = cooldown_until.replace(tzinfo=timezone.utc)
-        runtime_state.cooldown_until = cooldown_until
-        updated = True
-    if now_utc < cooldown_until:
-        return updated
-    logger.info(
-        "scholar_search.cooldown_expired",
-        extra={"event": "scholar_search.cooldown_expired", "cooldown_until_utc": cooldown_until.isoformat()},
-    )
-    runtime_state.cooldown_until = None
-    runtime_state.cooldown_rejection_count = 0
-    runtime_state.cooldown_alert_emitted = False
-    return True
-
-
-def _cooldown_warning_codes(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    cooldown_remaining_seconds: int,
-) -> list[str]:
-    warning_codes = [
-        "author_search_cooldown_active",
-        f"author_search_cooldown_remaining_{cooldown_remaining_seconds}s",
-    ]
-    if bool(runtime_state.cooldown_alert_emitted):
-        warning_codes.append("author_search_cooldown_alert_threshold_exceeded")
-    return warning_codes
-
-
-def _emit_cooldown_threshold_alert(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    normalized_query: str,
-    cooldown_rejection_alert_threshold: int,
-) -> bool:
-    runtime_state.cooldown_rejection_count = int(runtime_state.cooldown_rejection_count) + 1
-    threshold = max(1, int(cooldown_rejection_alert_threshold))
-    if int(runtime_state.cooldown_rejection_count) < threshold:
-        return True
-    if bool(runtime_state.cooldown_alert_emitted):
-        return True
-    logger.error(
-        "scholar_search.cooldown_rejection_threshold_exceeded",
-        extra={
-            "event": "scholar_search.cooldown_rejection_threshold_exceeded",
-            "query": normalized_query,
-            "cooldown_rejection_count": int(runtime_state.cooldown_rejection_count),
-            "threshold": threshold,
-            "cooldown_until_utc": runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
-        },
-    )
-    runtime_state.cooldown_alert_emitted = True
-    return True
-
-
-def _cooldown_block_result(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    normalized_query: str,
-    bounded_limit: int,
-    cooldown_rejection_alert_threshold: int,
-    cooldown_remaining_seconds: int,
-) -> ParsedAuthorSearchPage:
-    _emit_cooldown_threshold_alert(
-        runtime_state=runtime_state,
-        normalized_query=normalized_query,
-        cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
-    )
-    logger.warning(
-        "scholar_search.cooldown_active",
-        extra={
-            "event": "scholar_search.cooldown_active",
-            "query": normalized_query,
-            "cooldown_remaining_seconds": cooldown_remaining_seconds,
-            "cooldown_until_utc": runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
-        },
-    )
-    return _policy_blocked_author_search_result(
-        reason=SEARCH_COOLDOWN_REASON,
-        warning_codes=_cooldown_warning_codes(
-            runtime_state=runtime_state,
-            cooldown_remaining_seconds=cooldown_remaining_seconds,
-        ),
-        limit=bounded_limit,
-    )
-
-
-async def _cache_hit_result(
-    db_session: AsyncSession,
-    *,
-    query_key: str,
-    now_utc: datetime,
-    normalized_query: str,
-    bounded_limit: int,
-) -> ParsedAuthorSearchPage | None:
-    cached = await _cache_get_author_search_result(
-        db_session,
-        query_key=query_key,
-        now_utc=now_utc,
-    )
-    if cached is None:
-        return None
-    logger.info(
-        "scholar_search.cache_hit",
-        extra={
-            "event": "scholar_search.cache_hit",
-            "query": normalized_query,
-            "state": cached.state.value,
-            "state_reason": cached.state_reason,
-        },
-    )
-    state_reason_override = SEARCH_CACHED_BLOCK_REASON if _is_author_search_block_state(cached) else None
-    return _trim_author_search_result(
-        cached,
-        limit=bounded_limit,
-        extra_warnings=["author_search_served_from_cache"],
-        state_reason_override=state_reason_override,
-    )
-
-
-def _throttle_sleep_seconds(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    now_utc: datetime,
-    min_interval_seconds: float,
-    interval_jitter_seconds: float,
-) -> tuple[float, bool]:
-    updated = False
-    if runtime_state.last_live_request_at is None:
-        enforced_wait_seconds = 0.0
-    else:
-        last_live_request_at = runtime_state.last_live_request_at
-        if last_live_request_at.tzinfo is None:
-            last_live_request_at = last_live_request_at.replace(tzinfo=timezone.utc)
-            runtime_state.last_live_request_at = last_live_request_at
-            updated = True
-        enforced_wait_seconds = (
-            last_live_request_at + timedelta(seconds=max(float(min_interval_seconds), 0.0)) - now_utc
-        ).total_seconds()
-    jitter_seconds = random.uniform(0.0, max(float(interval_jitter_seconds), 0.0))
-    return max(0.0, float(enforced_wait_seconds)) + jitter_seconds, updated
-
-
-async def _wait_for_author_search_throttle(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    normalized_query: str,
-    now_utc: datetime,
-    min_interval_seconds: float,
-    interval_jitter_seconds: float,
-) -> bool:
-    sleep_seconds, updated = _throttle_sleep_seconds(
-        runtime_state=runtime_state,
-        now_utc=now_utc,
-        min_interval_seconds=min_interval_seconds,
-        interval_jitter_seconds=interval_jitter_seconds,
-    )
-    if sleep_seconds <= 0.0:
-        return updated
-    logger.info(
-        "scholar_search.throttle_wait",
-        extra={"event": "scholar_search.throttle_wait", "query": normalized_query, "sleep_seconds": round(sleep_seconds, 3)},
-    )
-    await asyncio.sleep(sleep_seconds)
-    return True
-
-
-async def _fetch_author_search_with_retries(
-    *,
-    source: ScholarSource,
-    normalized_query: str,
-    network_error_retries: int,
-    retry_backoff_seconds: float,
-) -> tuple[ParsedAuthorSearchPage, int, list[str]]:
-    max_attempts = max(1, int(network_error_retries) + 1)
-    parsed: ParsedAuthorSearchPage | None = None
-    retry_warnings: list[str] = []
-    retry_scheduled_count = 0
-    for attempt_index in range(max_attempts):
-        fetch_result = await source.fetch_author_search_html(normalized_query, start=0)
-        try:
-            parsed = parse_author_search_page(fetch_result)
-        except ScholarParserError as exc:
-            parsed = ParsedAuthorSearchPage(
-                state=ParseState.LAYOUT_CHANGED,
-                state_reason=exc.code,
-                candidates=[],
-                marker_counts={},
-                warnings=[exc.code],
-            )
-        if parsed.state != ParseState.NETWORK_ERROR or attempt_index >= max_attempts - 1:
-            break
-        retry_warnings.append("network_retry_scheduled_for_author_search")
-        retry_scheduled_count += 1
-        retry_sleep_seconds = max(float(retry_backoff_seconds), 0.0) * (2**attempt_index)
-        if retry_sleep_seconds > 0:
-            await asyncio.sleep(retry_sleep_seconds)
-    if parsed is None:
-        raise ScholarServiceError("Unable to complete scholar author search.")
-    return parsed, retry_scheduled_count, retry_warnings
-
-
-def _with_retry_warnings(
-    parsed: ParsedAuthorSearchPage,
-    *,
-    retry_warnings: list[str],
-    retry_scheduled_count: int,
-    retry_alert_threshold: int,
-    normalized_query: str,
-) -> ParsedAuthorSearchPage:
-    merged = replace(parsed, warnings=_merge_warnings(parsed.warnings, retry_warnings))
-    threshold = max(1, int(retry_alert_threshold))
-    if retry_scheduled_count < threshold:
-        return merged
-    logger.warning(
-        "scholar_search.retry_threshold_exceeded",
-        extra={
-            "event": "scholar_search.retry_threshold_exceeded",
-            "query": normalized_query,
-            "retry_scheduled_count": retry_scheduled_count,
-            "threshold": threshold,
-            "final_state": merged.state.value,
-            "final_state_reason": merged.state_reason,
-        },
-    )
-    return replace(
-        merged,
-        warnings=_merge_warnings(
-            merged.warnings,
-            [f"author_search_retry_threshold_exceeded_{retry_scheduled_count}"],
-        ),
-    )
-
-
-def _apply_block_circuit_breaker(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    merged_parsed: ParsedAuthorSearchPage,
-    cooldown_block_threshold: int,
-    cooldown_seconds: int,
-    normalized_query: str,
-) -> ParsedAuthorSearchPage:
-    if not _is_author_search_block_state(merged_parsed):
-        runtime_state.consecutive_blocked_count = 0
-        return merged_parsed
-    runtime_state.consecutive_blocked_count = int(runtime_state.consecutive_blocked_count) + 1
-    logger.warning(
-        "scholar_search.block_detected",
-        extra={
-            "event": "scholar_search.block_detected",
-            "query": normalized_query,
-            "state_reason": merged_parsed.state_reason,
-            "consecutive_blocked_count": int(runtime_state.consecutive_blocked_count),
-        },
-    )
-    if int(runtime_state.consecutive_blocked_count) < max(1, int(cooldown_block_threshold)):
-        return merged_parsed
-    runtime_state.cooldown_until = datetime.now(timezone.utc) + timedelta(seconds=max(60, int(cooldown_seconds)))
-    runtime_state.consecutive_blocked_count = 0
-    runtime_state.cooldown_rejection_count = 0
-    runtime_state.cooldown_alert_emitted = False
-    logger.error(
-        "scholar_search.cooldown_activated",
-        extra={
-            "event": "scholar_search.cooldown_activated",
-            "query": normalized_query,
-            "cooldown_until_utc": runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
-        },
-    )
-    return replace(
-        merged_parsed,
-        warnings=_merge_warnings(merged_parsed.warnings, ["author_search_circuit_breaker_armed"]),
-    )
-
-
-def _resolve_author_search_cache_ttl_seconds(
-    *,
-    merged_parsed: ParsedAuthorSearchPage,
-    blocked_cache_ttl_seconds: int,
-    cache_ttl_seconds: int,
-) -> int:
-    if _is_author_search_block_state(merged_parsed):
-        return min(max(1, int(blocked_cache_ttl_seconds)), max(1, int(cache_ttl_seconds)))
-    return max(1, int(cache_ttl_seconds))
-
-
-async def _load_locked_runtime_state(
-    db_session: AsyncSession,
-) -> AuthorSearchRuntimeState:
-    await _acquire_author_search_lock(db_session)
-    return await _load_runtime_state_for_update(db_session)
-
-
-async def _cooldown_or_cache_result(
-    db_session: AsyncSession,
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    query_key: str,
-    normalized_query: str,
-    bounded_limit: int,
-    cooldown_rejection_alert_threshold: int,
-) -> tuple[ParsedAuthorSearchPage | None, bool]:
-    runtime_state_updated = _normalize_runtime_cooldown_state(
-        runtime_state,
-        now_utc=datetime.now(timezone.utc),
-    )
-    cooldown_remaining_seconds = _author_search_cooldown_remaining_seconds(
-        runtime_state,
-        datetime.now(timezone.utc),
-    )
-    if cooldown_remaining_seconds > 0:
-        return (
-            _cooldown_block_result(
-                runtime_state=runtime_state,
-                normalized_query=normalized_query,
-                bounded_limit=bounded_limit,
-                cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
-                cooldown_remaining_seconds=cooldown_remaining_seconds,
-            ),
-            True,
-        )
-    cached_result = await _cache_hit_result(
-        db_session,
-        query_key=query_key,
-        now_utc=datetime.now(timezone.utc),
-        normalized_query=normalized_query,
-        bounded_limit=bounded_limit,
-    )
-    return cached_result, runtime_state_updated
-
-
-async def _perform_live_author_search(db_session: AsyncSession, *, source: ScholarSource, runtime_state: AuthorSearchRuntimeState, normalized_query: str, query_key: str, network_error_retries: int, retry_backoff_seconds: float, min_interval_seconds: float, interval_jitter_seconds: float, retry_alert_threshold: int, cooldown_block_threshold: int, cooldown_seconds: int, blocked_cache_ttl_seconds: int, cache_ttl_seconds: int, cache_max_entries: int) -> tuple[ParsedAuthorSearchPage, bool]:
-    runtime_state_updated = await _wait_for_author_search_throttle(
-        runtime_state=runtime_state,
-        normalized_query=normalized_query,
-        now_utc=datetime.now(timezone.utc),
-        min_interval_seconds=min_interval_seconds,
-        interval_jitter_seconds=interval_jitter_seconds,
-    )
-    parsed, retry_count, retry_warnings = await _fetch_author_search_with_retries(
-        source=source,
-        normalized_query=normalized_query,
-        network_error_retries=network_error_retries,
-        retry_backoff_seconds=retry_backoff_seconds,
-    )
-    runtime_state.last_live_request_at = datetime.now(timezone.utc)
-    merged = _with_retry_warnings(
-        parsed,
-        retry_warnings=retry_warnings,
-        retry_scheduled_count=retry_count,
-        retry_alert_threshold=retry_alert_threshold,
-        normalized_query=normalized_query,
-    )
-    merged = _apply_block_circuit_breaker(
-        runtime_state=runtime_state,
-        merged_parsed=merged,
-        cooldown_block_threshold=cooldown_block_threshold,
-        cooldown_seconds=cooldown_seconds,
-        normalized_query=normalized_query,
-    )
-    ttl_seconds = _resolve_author_search_cache_ttl_seconds(
-        merged_parsed=merged,
-        blocked_cache_ttl_seconds=blocked_cache_ttl_seconds,
-        cache_ttl_seconds=cache_ttl_seconds,
-    )
-    await _cache_set_author_search_result(
-        db_session,
-        query_key=query_key,
-        parsed=merged,
-        ttl_seconds=float(ttl_seconds),
-        max_entries=cache_max_entries,
-        now_utc=datetime.now(timezone.utc),
-    )
-    return merged, True
-
-
-async def search_author_candidates(*, source: ScholarSource, db_session: AsyncSession, query: str, limit: int, network_error_retries: int = 1, retry_backoff_seconds: float = 1.0, search_enabled: bool = True, cache_ttl_seconds: int = 21_600, blocked_cache_ttl_seconds: int = DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS, cache_max_entries: int = DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES, min_interval_seconds: float = DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS, interval_jitter_seconds: float = DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS, cooldown_block_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD, cooldown_seconds: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS, retry_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD, cooldown_rejection_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD) -> ParsedAuthorSearchPage:
-    normalized_query, bounded_limit, query_key = _normalize_author_search_inputs(query, limit)
-    if not search_enabled:
-        return _disabled_search_result(
-            normalized_query=normalized_query,
-            bounded_limit=bounded_limit,
-        )
-
-    runtime_state = await _load_locked_runtime_state(db_session)
-    early_result, runtime_state_updated = await _cooldown_or_cache_result(
-        db_session,
-        runtime_state=runtime_state,
-        query_key=query_key,
-        normalized_query=normalized_query,
-        bounded_limit=bounded_limit,
-        cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
-    )
-    if early_result is not None:
-        await db_session.commit()
-        return early_result
-
-    merged_parsed, live_runtime_updated = await _perform_live_author_search(
-        db_session,
-        source=source,
-        runtime_state=runtime_state,
-        normalized_query=normalized_query,
-        query_key=query_key,
-        network_error_retries=network_error_retries,
-        retry_backoff_seconds=retry_backoff_seconds,
-        min_interval_seconds=min_interval_seconds,
-        interval_jitter_seconds=interval_jitter_seconds,
-        retry_alert_threshold=retry_alert_threshold,
-        cooldown_block_threshold=cooldown_block_threshold,
-        cooldown_seconds=cooldown_seconds,
-        blocked_cache_ttl_seconds=blocked_cache_ttl_seconds,
-        cache_ttl_seconds=cache_ttl_seconds,
-        cache_max_entries=cache_max_entries,
-    )
-    runtime_state_updated = runtime_state_updated or live_runtime_updated
-    if runtime_state_updated:
-        await db_session.commit()
-    return _trim_author_search_result(merged_parsed, limit=bounded_limit)
-
-
-async def hydrate_profile_metadata(
-    db_session: AsyncSession,
-    *,
-    profile: ScholarProfile,
-    source: ScholarSource,
-) -> ScholarProfile:
-    fetch_result = await source.fetch_profile_html(profile.scholar_id)
-    try:
-        parsed_page = parse_profile_page(fetch_result)
-    except ScholarParserError:
-        return profile
-
-    if parsed_page.profile_name and not (profile.display_name or "").strip():
-        profile.display_name = parsed_page.profile_name
-    if parsed_page.profile_image_url and not profile.profile_image_url:
-        profile.profile_image_url = parsed_page.profile_image_url
-
-    await db_session.commit()
-    await db_session.refresh(profile)
-    return profile
-
-
-async def set_profile_image_override_url(
-    db_session: AsyncSession,
-    *,
-    profile: ScholarProfile,
-    image_url: str | None,
-    upload_dir: str,
-) -> ScholarProfile:
-    upload_root = _ensure_upload_root(upload_dir, create=True)
-    _safe_remove_upload(upload_root, profile.profile_image_upload_path)
-
-    profile.profile_image_upload_path = None
-    profile.profile_image_override_url = normalize_profile_image_url(image_url)
-
-    await db_session.commit()
-    await db_session.refresh(profile)
-    return profile
-
-
-async def clear_profile_image_customization(
-    db_session: AsyncSession,
-    *,
-    profile: ScholarProfile,
-    upload_dir: str,
-) -> ScholarProfile:
-    upload_root = _ensure_upload_root(upload_dir, create=True)
-    _safe_remove_upload(upload_root, profile.profile_image_upload_path)
-
-    profile.profile_image_upload_path = None
-    profile.profile_image_override_url = None
-
-    await db_session.commit()
-    await db_session.refresh(profile)
-    return profile
-
-
-async def set_profile_image_upload(
-    db_session: AsyncSession,
-    *,
-    profile: ScholarProfile,
-    content_type: str | None,
-    image_bytes: bytes,
-    upload_dir: str,
-    max_upload_bytes: int,
-) -> ScholarProfile:
-    normalized_content_type = (content_type or "").strip().lower()
-    extension = ALLOWED_IMAGE_UPLOAD_CONTENT_TYPES.get(normalized_content_type)
-    if extension is None:
-        raise ScholarServiceError(
-            "Unsupported image type. Use JPEG, PNG, WEBP, or GIF."
-        )
-
-    if not image_bytes:
-        raise ScholarServiceError("Uploaded image file is empty.")
-
-    if len(image_bytes) > max_upload_bytes:
-        raise ScholarServiceError(
-            f"Uploaded image exceeds {max_upload_bytes} bytes."
-        )
-
-    upload_root = _ensure_upload_root(upload_dir, create=True)
-    user_dir = upload_root / str(profile.user_id)
-    user_dir.mkdir(parents=True, exist_ok=True)
-
-    filename = f"{profile.id}_{uuid4().hex}{extension}"
-    relative_path = os.path.join(str(profile.user_id), filename)
-    absolute_path = _resolve_upload_path(upload_root, relative_path)
-    absolute_path.write_bytes(image_bytes)
-
-    old_path = profile.profile_image_upload_path
-    profile.profile_image_upload_path = relative_path
-    profile.profile_image_override_url = None
-
-    await db_session.commit()
-    await db_session.refresh(profile)
-
-    if old_path and old_path != relative_path:
-        _safe_remove_upload(upload_root, old_path)
-
-    return profile
diff --git a/build/lib/app/services/domains/scholars/constants.py b/build/lib/app/services/domains/scholars/constants.py
deleted file mode 100644
index 7ee18ad..0000000
--- a/build/lib/app/services/domains/scholars/constants.py
+++ /dev/null
@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-import re
-
-SCHOLAR_ID_PATTERN = re.compile(r"^[a-zA-Z0-9_-]{12}$")
-MAX_IMAGE_URL_LENGTH = 2048
-MAX_AUTHOR_SEARCH_LIMIT = 25
-
-DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES = 512
-DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS = 300
-DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD = 1
-DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS = 1800
-DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS = 3.0
-DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS = 1.0
-DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD = 2
-DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD = 3
-
-AUTHOR_SEARCH_RUNTIME_STATE_KEY = "global"
-AUTHOR_SEARCH_LOCK_NAMESPACE = 3901
-AUTHOR_SEARCH_LOCK_KEY = 1
-
-ALLOWED_IMAGE_UPLOAD_CONTENT_TYPES = {
-    "image/jpeg": ".jpg",
-    "image/png": ".png",
-    "image/webp": ".webp",
-    "image/gif": ".gif",
-}
-
-SEARCH_DISABLED_REASON = "search_disabled_by_configuration"
-SEARCH_COOLDOWN_REASON = "search_temporarily_disabled_due_to_repeated_blocks"
-SEARCH_CACHED_BLOCK_REASON = "search_temporarily_disabled_from_cached_blocked_response"
-
-STATE_REASON_HINTS: dict[str, str] = {
-    SEARCH_DISABLED_REASON: (
-        "Scholar name search is currently disabled by service policy. "
-        "Add scholars by profile URL or Scholar ID."
-    ),
-    SEARCH_COOLDOWN_REASON: (
-        "Scholar name search is temporarily paused after repeated block responses. "
-        "Use Scholar URL/ID adds until cooldown expires."
-    ),
-    SEARCH_CACHED_BLOCK_REASON: (
-        "A recent blocked response was cached to reduce traffic. "
-        "Retry later or add by Scholar URL/ID."
-    ),
-    "network_dns_resolution_failed": (
-        "DNS resolution failed while reaching scholar.google.com. "
-        "Verify container DNS/network and retry."
-    ),
-    "network_timeout": (
-        "Request timed out before Google Scholar responded. "
-        "Increase delay/backoff and retry."
-    ),
-    "network_tls_error": (
-        "TLS handshake/certificate validation failed. "
-        "Verify outbound TLS/network configuration."
-    ),
-    "blocked_http_429_rate_limited": (
-        "Google Scholar rate-limited the request. "
-        "Slow request cadence and retry later."
-    ),
-    "blocked_unusual_traffic_detected": (
-        "Google Scholar flagged traffic as unusual. "
-        "Increase delay/jitter and reduce concurrent scraping."
-    ),
-    "blocked_accounts_redirect": (
-        "Request was redirected to Google Account sign-in. "
-        "Treat as access block and retry later."
-    ),
-}
diff --git a/build/lib/app/services/domains/scholars/exceptions.py b/build/lib/app/services/domains/scholars/exceptions.py
deleted file mode 100644
index f1383e3..0000000
--- a/build/lib/app/services/domains/scholars/exceptions.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-
-class ScholarServiceError(ValueError):
-    """Raised for expected scholar-management validation failures."""
diff --git a/build/lib/app/services/domains/scholars/search_hints.py b/build/lib/app/services/domains/scholars/search_hints.py
deleted file mode 100644
index f905c14..0000000
--- a/build/lib/app/services/domains/scholars/search_hints.py
+++ /dev/null
@@ -1,67 +0,0 @@
-from __future__ import annotations
-
-from app.db.models import ScholarProfile
-from app.services.domains.scholar.parser import ParseState, ParsedAuthorSearchPage
-from app.services.domains.scholars.constants import (
-    MAX_AUTHOR_SEARCH_LIMIT,
-    STATE_REASON_HINTS,
-)
-
-
-def resolve_profile_image(
-    profile: ScholarProfile,
-    *,
-    uploaded_image_url: str | None,
-) -> tuple[str | None, str]:
-    if profile.profile_image_upload_path and uploaded_image_url:
-        return uploaded_image_url, "upload"
-    if profile.profile_image_override_url:
-        return profile.profile_image_override_url, "override"
-    if profile.profile_image_url:
-        return profile.profile_image_url, "scraped"
-    return None, "none"
-
-
-def scrape_state_hint(*, state: ParseState, state_reason: str) -> str | None:
-    if state not in {ParseState.NETWORK_ERROR, ParseState.BLOCKED_OR_CAPTCHA}:
-        return None
-    return STATE_REASON_HINTS.get(state_reason)
-
-
-def _merge_warnings(base: list[str], extra: list[str]) -> list[str]:
-    if not extra:
-        return sorted(set(base))
-    return sorted(set(base + extra))
-
-
-def _trim_author_search_result(
-    parsed: ParsedAuthorSearchPage,
-    *,
-    limit: int,
-    extra_warnings: list[str] | None = None,
-    state_reason_override: str | None = None,
-) -> ParsedAuthorSearchPage:
-    bounded_limit = max(1, min(int(limit), MAX_AUTHOR_SEARCH_LIMIT))
-    return ParsedAuthorSearchPage(
-        state=parsed.state,
-        state_reason=state_reason_override or parsed.state_reason,
-        candidates=parsed.candidates[:bounded_limit],
-        marker_counts=parsed.marker_counts,
-        warnings=_merge_warnings(parsed.warnings, extra_warnings or []),
-    )
-
-
-def _policy_blocked_author_search_result(
-    *,
-    reason: str,
-    warning_codes: list[str],
-    limit: int,
-) -> ParsedAuthorSearchPage:
-    _ = limit
-    return ParsedAuthorSearchPage(
-        state=ParseState.BLOCKED_OR_CAPTCHA,
-        state_reason=reason,
-        candidates=[],
-        marker_counts={},
-        warnings=_merge_warnings([], warning_codes),
-    )
diff --git a/build/lib/app/services/domains/scholars/uploads.py b/build/lib/app/services/domains/scholars/uploads.py
deleted file mode 100644
index c33fd47..0000000
--- a/build/lib/app/services/domains/scholars/uploads.py
+++ /dev/null
@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from app.services.domains.scholars.exceptions import ScholarServiceError
-
-
-def _ensure_upload_root(upload_dir: str, *, create: bool) -> Path:
-    root = Path(upload_dir).expanduser().resolve()
-    if create:
-        root.mkdir(parents=True, exist_ok=True)
-    return root
-
-
-def _resolve_upload_path(upload_root: Path, relative_path: str) -> Path:
-    candidate = (upload_root / relative_path).resolve()
-    if upload_root != candidate and upload_root not in candidate.parents:
-        raise ScholarServiceError("Invalid scholar image path.")
-    return candidate
-
-
-def _safe_remove_upload(upload_root: Path, relative_path: str | None) -> None:
-    if not relative_path:
-        return
-    try:
-        file_path = _resolve_upload_path(upload_root, relative_path)
-    except ScholarServiceError:
-        return
-
-    try:
-        if file_path.exists() and file_path.is_file():
-            file_path.unlink()
-    except OSError:
-        return
-
-
-def resolve_upload_file_path(*, upload_dir: str, relative_path: str) -> Path:
-    root = _ensure_upload_root(upload_dir, create=False)
-    return _resolve_upload_path(root, relative_path)
diff --git a/build/lib/app/services/domains/scholars/validators.py b/build/lib/app/services/domains/scholars/validators.py
deleted file mode 100644
index 1c79baa..0000000
--- a/build/lib/app/services/domains/scholars/validators.py
+++ /dev/null
@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from urllib.parse import urlparse
-
-from app.services.domains.scholars.constants import MAX_IMAGE_URL_LENGTH, SCHOLAR_ID_PATTERN
-from app.services.domains.scholars.exceptions import ScholarServiceError
-
-
-def validate_scholar_id(value: str) -> str:
-    scholar_id = value.strip()
-    if not SCHOLAR_ID_PATTERN.fullmatch(scholar_id):
-        raise ScholarServiceError("Scholar ID must match [a-zA-Z0-9_-]{12}.")
-    return scholar_id
-
-
-def normalize_display_name(value: str) -> str | None:
-    normalized = value.strip()
-    return normalized if normalized else None
-
-
-def normalize_profile_image_url(value: str | None) -> str | None:
-    if value is None:
-        return None
-
-    candidate = value.strip()
-    if not candidate:
-        return None
-
-    if len(candidate) > MAX_IMAGE_URL_LENGTH:
-        raise ScholarServiceError(
-            f"Image URL must be {MAX_IMAGE_URL_LENGTH} characters or fewer."
-        )
-
-    parsed = urlparse(candidate)
-    if parsed.scheme.lower() not in {"http", "https"} or not parsed.netloc:
-        raise ScholarServiceError("Image URL must be an absolute http(s) URL.")
-
-    return candidate
diff --git a/build/lib/app/services/domains/settings/__init__.py b/build/lib/app/services/domains/settings/__init__.py
deleted file mode 100644
index 9d48db4..0000000
--- a/build/lib/app/services/domains/settings/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from __future__ import annotations
diff --git a/build/lib/app/services/domains/settings/application.py b/build/lib/app/services/domains/settings/application.py
deleted file mode 100644
index 7f435e8..0000000
--- a/build/lib/app/services/domains/settings/application.py
+++ /dev/null
@@ -1,159 +0,0 @@
-from __future__ import annotations
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import UserSetting
-
-
-class UserSettingsServiceError(ValueError):
-    """Raised for expected settings-validation failures."""
-
-
-NAV_PAGE_DASHBOARD = "dashboard"
-NAV_PAGE_SCHOLARS = "scholars"
-NAV_PAGE_PUBLICATIONS = "publications"
-NAV_PAGE_SETTINGS = "settings"
-NAV_PAGE_STYLE_GUIDE = "style-guide"
-NAV_PAGE_RUNS = "runs"
-NAV_PAGE_USERS = "users"
-
-ALLOWED_NAV_PAGES = (
-    NAV_PAGE_DASHBOARD,
-    NAV_PAGE_SCHOLARS,
-    NAV_PAGE_PUBLICATIONS,
-    NAV_PAGE_SETTINGS,
-    NAV_PAGE_STYLE_GUIDE,
-    NAV_PAGE_RUNS,
-    NAV_PAGE_USERS,
-)
-REQUIRED_NAV_PAGES = (
-    NAV_PAGE_DASHBOARD,
-    NAV_PAGE_SCHOLARS,
-    NAV_PAGE_SETTINGS,
-)
-DEFAULT_NAV_VISIBLE_PAGES = list(ALLOWED_NAV_PAGES)
-HARD_MIN_RUN_INTERVAL_MINUTES = 15
-HARD_MIN_REQUEST_DELAY_SECONDS = 2
-
-
-def resolve_run_interval_minimum(configured_minimum: int | None) -> int:
-    try:
-        parsed = int(configured_minimum) if configured_minimum is not None else HARD_MIN_RUN_INTERVAL_MINUTES
-    except (TypeError, ValueError):
-        parsed = HARD_MIN_RUN_INTERVAL_MINUTES
-    return max(HARD_MIN_RUN_INTERVAL_MINUTES, parsed)
-
-
-def resolve_request_delay_minimum(configured_minimum: int | None) -> int:
-    try:
-        parsed = int(configured_minimum) if configured_minimum is not None else HARD_MIN_REQUEST_DELAY_SECONDS
-    except (TypeError, ValueError):
-        parsed = HARD_MIN_REQUEST_DELAY_SECONDS
-    return max(HARD_MIN_REQUEST_DELAY_SECONDS, parsed)
-
-
-def parse_run_interval_minutes(value: str, *, minimum: int = HARD_MIN_RUN_INTERVAL_MINUTES) -> int:
-    try:
-        parsed = int(value)
-    except ValueError as exc:
-        raise UserSettingsServiceError("Check interval must be a whole number.") from exc
-    effective_minimum = resolve_run_interval_minimum(minimum)
-    if parsed < effective_minimum:
-        raise UserSettingsServiceError(
-            f"Check interval must be at least {effective_minimum} minutes."
-        )
-    return parsed
-
-
-def parse_request_delay_seconds(value: str, *, minimum: int = HARD_MIN_REQUEST_DELAY_SECONDS) -> int:
-    try:
-        parsed = int(value)
-    except ValueError as exc:
-        raise UserSettingsServiceError("Request delay must be a whole number.") from exc
-    effective_minimum = resolve_request_delay_minimum(minimum)
-    if parsed < effective_minimum:
-        raise UserSettingsServiceError(
-            f"Request delay must be at least {effective_minimum} seconds."
-        )
-    return parsed
-
-
-def parse_nav_visible_pages(value: object) -> list[str]:
-    if not isinstance(value, list):
-        raise UserSettingsServiceError("Navigation visibility must be a list of page ids.")
-
-    deduped: list[str] = []
-    seen: set[str] = set()
-
-    for raw_page in value:
-        if not isinstance(raw_page, str):
-            raise UserSettingsServiceError("Navigation visibility entries must be strings.")
-
-        page_id = raw_page.strip()
-        if page_id not in ALLOWED_NAV_PAGES:
-            raise UserSettingsServiceError(f"Unsupported navigation page id: {page_id}")
-
-        if page_id in seen:
-            continue
-
-        seen.add(page_id)
-        deduped.append(page_id)
-
-    missing_required = [page for page in REQUIRED_NAV_PAGES if page not in seen]
-    if missing_required:
-        raise UserSettingsServiceError(
-            "Dashboard, Scholars, and Settings must remain visible."
-        )
-
-    return deduped
-
-
-from app.settings import settings as app_settings
-
-async def get_or_create_settings(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-) -> UserSetting:
-    result = await db_session.execute(
-        select(UserSetting).where(UserSetting.user_id == user_id)
-    )
-    settings = result.scalar_one_or_none()
-    if settings is not None:
-        return settings
-
-    settings = UserSetting(
-        user_id=user_id,
-        openalex_api_key=app_settings.openalex_api_key,
-        crossref_api_token=app_settings.crossref_api_token,
-        crossref_api_mailto=app_settings.crossref_api_mailto,
-    )
-    db_session.add(settings)
-    await db_session.commit()
-    await db_session.refresh(settings)
-    return settings
-
-
-async def update_settings(
-    db_session: AsyncSession,
-    *,
-    settings: UserSetting,
-    auto_run_enabled: bool,
-    run_interval_minutes: int,
-    request_delay_seconds: int,
-    nav_visible_pages: list[str],
-    openalex_api_key: str | None,
-    crossref_api_token: str | None,
-    crossref_api_mailto: str | None,
-) -> UserSetting:
-    settings.auto_run_enabled = auto_run_enabled
-    settings.run_interval_minutes = run_interval_minutes
-    settings.request_delay_seconds = request_delay_seconds
-    settings.nav_visible_pages = nav_visible_pages
-    settings.openalex_api_key = openalex_api_key
-    settings.crossref_api_token = crossref_api_token
-    settings.crossref_api_mailto = crossref_api_mailto
-    await db_session.commit()
-    await db_session.refresh(settings)
-    return settings
diff --git a/build/lib/app/services/domains/unpaywall/__init__.py b/build/lib/app/services/domains/unpaywall/__init__.py
deleted file mode 100644
index a1baa12..0000000
--- a/build/lib/app/services/domains/unpaywall/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from __future__ import annotations
-
-
-async def resolve_publication_pdf_urls(*args, **kwargs):
-    from app.services.domains.unpaywall.application import resolve_publication_pdf_urls as _impl
-
-    return await _impl(*args, **kwargs)
-
-
-__all__ = ["resolve_publication_pdf_urls"]
diff --git a/build/lib/app/services/domains/unpaywall/application.py b/build/lib/app/services/domains/unpaywall/application.py
deleted file mode 100644
index 13104e9..0000000
--- a/build/lib/app/services/domains/unpaywall/application.py
+++ /dev/null
@@ -1,458 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-import logging
-import re
-from typing import TYPE_CHECKING
-from urllib.parse import unquote
-
-from app.services.domains.crossref.application import discover_doi_for_publication
-from app.services.domains.doi.normalize import normalize_doi
-from app.services.domains.unpaywall.pdf_discovery import (
-    looks_like_pdf_url,
-    resolve_pdf_from_landing_page,
-)
-from app.services.domains.unpaywall.rate_limit import wait_for_unpaywall_slot
-from app.settings import settings
-
-if TYPE_CHECKING:
-    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
-
-DOI_PATTERN = re.compile(r"10\.\d{4,9}/[-._;()/:A-Z0-9]+", re.I)
-DOI_PREFIX_RE = re.compile(r"\bdoi\s*[:=]\s*(10\.\d{4,9}/[-._;()/:A-Z0-9]+)", re.I)
-DOI_URL_RE = re.compile(r"(?:https?://)?(?:dx\.)?doi\.org/(10\.\d{4,9}/[-._;()/:A-Z0-9]+)", re.I)
-UNPAYWALL_URL_TEMPLATE = "https://api.unpaywall.org/v2/{doi}"
-FAILURE_MISSING_DOI = "missing_doi"
-FAILURE_NO_RECORD = "no_unpaywall_record"
-FAILURE_NO_PDF = "no_pdf_found"
-FAILURE_RESOLUTION_EXCEPTION = "resolution_exception"
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class OaResolutionOutcome:
-    publication_id: int
-    doi: str | None
-    pdf_url: str | None
-    failure_reason: str | None
-    source: str | None
-    used_crossref: bool
-
-
-def _extract_doi_candidate(text: str | None) -> str | None:
-    if not text:
-        return None
-    decoded = unquote(text)
-    match = DOI_PATTERN.search(decoded)
-    if not match:
-        return None
-    return match.group(0).rstrip(" .;,)")
-
-
-def _extract_explicit_doi(text: str | None) -> str | None:
-    if not text:
-        return None
-    decoded = unquote(text)
-    url_match = DOI_URL_RE.search(decoded)
-    if url_match:
-        return normalize_doi(url_match.group(1))
-    prefix_match = DOI_PREFIX_RE.search(decoded)
-    if prefix_match:
-        return normalize_doi(prefix_match.group(1))
-    return None
-
-
-def _publication_doi(item: PublicationListItem | UnreadPublicationItem) -> str | None:
-    stored = None
-    if getattr(item, "display_identifier", None) and item.display_identifier.kind == "doi":
-        stored = normalize_doi(item.display_identifier.value)
-    
-    explicit_doi = (
-        _extract_explicit_doi(item.pub_url)
-        or _extract_explicit_doi(item.venue_text)
-    )
-    if explicit_doi:
-        return explicit_doi
-    pub_url_doi = _extract_doi_candidate(item.pub_url)
-    if pub_url_doi:
-        return normalize_doi(pub_url_doi)
-    return stored
-
-
-def _payload_locations(payload: dict) -> list[dict]:
-    locations: list[dict] = []
-    best = payload.get("best_oa_location")
-    if isinstance(best, dict):
-        locations.append(best)
-    oa_locations = payload.get("oa_locations")
-    if isinstance(oa_locations, list):
-        locations.extend(location for location in oa_locations if isinstance(location, dict))
-    return locations
-
-
-def _location_value(location: dict, key: str) -> str | None:
-    value = location.get(key)
-    if not isinstance(value, str):
-        return None
-    normalized = value.strip()
-    return normalized or None
-
-
-def _payload_pdf_candidates(payload: dict) -> list[str]:
-    candidates: list[str] = []
-    seen: set[str] = set()
-    for location in _payload_locations(payload):
-        candidate = _location_value(location, "url_for_pdf")
-        if candidate is None or candidate in seen:
-            continue
-        seen.add(candidate)
-        candidates.append(candidate)
-    return candidates
-
-
-def _payload_landing_candidates(payload: dict) -> list[str]:
-    candidates: list[str] = []
-    seen: set[str] = set()
-    for location in _payload_locations(payload):
-        candidate = _location_value(location, "url")
-        if candidate is None or candidate in seen:
-            continue
-        seen.add(candidate)
-        candidates.append(candidate)
-    return candidates
-
-
-def _crawl_targets(
-    *,
-    payload: dict,
-    pdf_candidates: list[str],
-) -> list[str]:
-    targets = _payload_landing_candidates(payload)
-    seen = set(targets)
-    for candidate in pdf_candidates:
-        if candidate in seen:
-            continue
-        targets.append(candidate)
-        seen.add(candidate)
-    doi = normalize_doi(str(payload.get("doi") or ""))
-    doi_landing_url = f"https://doi.org/{doi}" if doi else None
-    if doi_landing_url and doi_landing_url not in seen:
-        targets.append(doi_landing_url)
-    return targets
-
-
-def _has_direct_payload_pdf(payload: dict) -> bool:
-    return any(looks_like_pdf_url(candidate) for candidate in _payload_pdf_candidates(payload))
-
-
-async def _resolved_pdf_url_from_payload(
-    payload: dict,
-    *,
-    client,
-) -> str | None:
-    pdf_candidates = _payload_pdf_candidates(payload)
-    for candidate in pdf_candidates:
-        if looks_like_pdf_url(candidate):
-            return candidate
-    for page_url in _crawl_targets(payload=payload, pdf_candidates=pdf_candidates)[:3]:
-        discovered = await resolve_pdf_from_landing_page(client, page_url=page_url)
-        if discovered:
-            logger.info(
-                "unpaywall.pdf_discovered_from_landing",
-                extra={"event": "unpaywall.pdf_discovered_from_landing", "landing_url": page_url},
-            )
-            return discovered
-    return None
-
-
-async def _fetch_unpaywall_payload_by_doi(
-    *,
-    client,
-    doi: str,
-    email: str,
-) -> dict | None:
-    await wait_for_unpaywall_slot(min_interval_seconds=settings.unpaywall_min_interval_seconds)
-    headers = {"User-Agent": f"scholar-scraper/1.0 (mailto:{email})"}
-    response = await client.get(
-        UNPAYWALL_URL_TEMPLATE.format(doi=doi),
-        params={"email": email},
-        headers=headers,
-    )
-    if response.status_code != 200:
-        return None
-    payload = response.json()
-    if not isinstance(payload, dict):
-        return None
-    return payload
-
-
-def _email_for_request(request_email: str | None) -> str | None:
-    email = (request_email or "").strip() or settings.unpaywall_email.strip()
-    return email or None
-
-
-def _log_resolution_summary(
-    *,
-    publication_count: int,
-    doi_input_count: int,
-    search_attempt_count: int,
-    resolved_pdf_count: int,
-    email: str,
-) -> None:
-    logger.info(
-        "unpaywall.resolve_completed",
-        extra={
-            "event": "unpaywall.resolve_completed",
-            "publication_count": publication_count,
-            "doi_input_count": doi_input_count,
-            "search_attempt_count": search_attempt_count,
-            "resolved_pdf_count": resolved_pdf_count,
-            "email_domain": email.split("@", 1)[-1] if "@" in email else None,
-        },
-    )
-
-
-async def _resolve_item_payload(
-    *,
-    client,
-    item: PublicationListItem,
-    email: str,
-    allow_crossref: bool,
-) -> tuple[dict | None, bool, str | None]:
-    doi = _publication_doi(item)
-    payload: dict | None = None
-    if doi:
-        payload = await _fetch_unpaywall_payload_by_doi(client=client, doi=doi, email=email)
-        if payload is not None and _has_direct_payload_pdf(payload):
-            return payload, False, doi
-    if not allow_crossref or not settings.crossref_enabled:
-        return payload, False, doi
-    crossref_doi = await discover_doi_for_publication(
-        item=item,
-        max_rows=settings.crossref_max_rows,
-        email=email,
-    )
-    if crossref_doi is None or crossref_doi == doi:
-        return payload, crossref_doi is not None, doi or crossref_doi
-    crossref_payload = await _fetch_unpaywall_payload_by_doi(
-        client=client,
-        doi=crossref_doi,
-        email=email,
-    )
-    if crossref_payload is not None:
-        return crossref_payload, True, crossref_doi
-    return payload, True, crossref_doi
-
-
-async def _doi_and_pdf_from_payload(
-    payload: dict,
-    *,
-    client,
-) -> tuple[str | None, str | None]:
-    doi = normalize_doi(str(payload.get("doi") or ""))
-    return doi, await _resolved_pdf_url_from_payload(payload, client=client)
-
-
-def _resolution_targets(items: list[PublicationListItem]) -> list[PublicationListItem]:
-    return [item for item in items if not item.pdf_url]
-
-
-def _crossref_budget_value() -> int:
-    return max(int(settings.crossref_max_lookups_per_request), 0)
-
-
-def _outcome_with_failure(
-    *,
-    item: PublicationListItem,
-    failure_reason: str,
-    used_crossref: bool,
-    doi_override: str | None = None,
-) -> OaResolutionOutcome:
-    return OaResolutionOutcome(
-        publication_id=item.publication_id,
-        doi=normalize_doi(doi_override) if doi_override is not None else _publication_doi(item),
-        pdf_url=None,
-        failure_reason=failure_reason,
-        source=None,
-        used_crossref=used_crossref,
-    )
-
-
-def _missing_payload_failure_reason(item: PublicationListItem, *, used_crossref: bool) -> str:
-    if _publication_doi(item):
-        return FAILURE_NO_RECORD
-    if used_crossref:
-        return FAILURE_NO_RECORD
-    return FAILURE_MISSING_DOI
-
-
-def _source_name(*, used_crossref: bool) -> str:
-    return "crossref+unpaywall" if used_crossref else "unpaywall"
-
-
-def _outcome_from_payload(
-    *,
-    item: PublicationListItem,
-    doi: str | None,
-    pdf_url: str | None,
-    used_crossref: bool,
-) -> OaResolutionOutcome:
-    return OaResolutionOutcome(
-        publication_id=item.publication_id,
-        doi=doi,
-        pdf_url=pdf_url,
-        failure_reason=None if pdf_url else FAILURE_NO_PDF,
-        source=_source_name(used_crossref=used_crossref),
-        used_crossref=used_crossref,
-    )
-
-
-def _resolved_pdf_count(outcomes: dict[int, OaResolutionOutcome]) -> int:
-    return sum(1 for outcome in outcomes.values() if outcome.pdf_url)
-
-
-def _outcome_metadata(outcomes: dict[int, OaResolutionOutcome]) -> dict[int, tuple[str | None, str | None]]:
-    return {
-        publication_id: (outcome.doi, outcome.pdf_url)
-        for publication_id, outcome in outcomes.items()
-    }
-
-
-async def _resolve_outcome_for_item(
-    *,
-    client,
-    item: PublicationListItem,
-    email: str,
-    allow_crossref: bool,
-) -> OaResolutionOutcome:
-    payload, used_crossref, resolved_doi = await _resolve_item_payload(
-        client=client,
-        item=item,
-        email=email,
-        allow_crossref=allow_crossref,
-    )
-    if not isinstance(payload, dict):
-        return _outcome_with_failure(
-            item=item,
-            failure_reason=_missing_payload_failure_reason(item, used_crossref=used_crossref),
-            used_crossref=used_crossref,
-            doi_override=resolved_doi,
-        )
-    doi, pdf_url = await _doi_and_pdf_from_payload(payload, client=client)
-    return _outcome_from_payload(
-        item=item,
-        doi=doi,
-        pdf_url=pdf_url,
-        used_crossref=used_crossref,
-    )
-
-
-def _doi_input_count(items: list[PublicationListItem]) -> int:
-    return len([item for item in items if _publication_doi(item)])
-
-
-def _search_attempt_count(*, targets: list[PublicationListItem]) -> int:
-    return len([item for item in targets if not _publication_doi(item)])
-
-
-async def _safe_outcome_for_item(
-    *,
-    client,
-    item: PublicationListItem,
-    email: str,
-    allow_crossref: bool,
-) -> OaResolutionOutcome:
-    try:
-        return await _resolve_outcome_for_item(
-            client=client,
-            item=item,
-            email=email,
-            allow_crossref=allow_crossref,
-        )
-    except Exception as exc:  # pragma: no cover - defensive network boundary
-        logger.warning(
-            "unpaywall.resolve_item_failed",
-            extra={
-                "event": "unpaywall.resolve_item_failed",
-                "publication_id": item.publication_id,
-                "error": str(exc),
-            },
-        )
-        return _outcome_with_failure(
-            item=item,
-            failure_reason=FAILURE_RESOLUTION_EXCEPTION,
-            used_crossref=allow_crossref and settings.crossref_enabled,
-        )
-
-
-async def _resolve_outcomes_with_client(
-    *,
-    client,
-    targets: list[PublicationListItem],
-    email: str,
-) -> dict[int, OaResolutionOutcome]:
-    outcomes: dict[int, OaResolutionOutcome] = {}
-    crossref_budget = _crossref_budget_value()
-    crossref_lookups = 0
-    for item in targets:
-        allow_crossref = crossref_budget > 0 and crossref_lookups < crossref_budget
-        outcome = await _safe_outcome_for_item(
-            client=client,
-            item=item,
-            email=email,
-            allow_crossref=allow_crossref,
-        )
-        if outcome.used_crossref:
-            crossref_lookups += 1
-        outcomes[item.publication_id] = outcome
-    return outcomes
-
-
-async def resolve_publication_oa_metadata(
-    items: list[PublicationListItem],
-    *,
-    request_email: str | None = None,
-) -> dict[int, tuple[str | None, str | None]]:
-    outcomes = await resolve_publication_oa_outcomes(items, request_email=request_email)
-    return _outcome_metadata(outcomes)
-
-
-async def resolve_publication_oa_outcomes(
-    items: list[PublicationListItem],
-    *,
-    request_email: str | None = None,
-) -> dict[int, OaResolutionOutcome]:
-    if not settings.unpaywall_enabled:
-        return {}
-    email = _email_for_request(request_email)
-    if email is None:
-        logger.debug("unpaywall.resolve_skipped_missing_email")
-        return {}
-    import httpx
-
-    timeout_seconds = max(float(settings.unpaywall_timeout_seconds), 0.5)
-    targets = _resolution_targets(items)[: max(int(settings.unpaywall_max_items_per_request), 0)]
-    headers = {"User-Agent": f"scholar-scraper/1.0 (mailto:{email})"}
-    async with httpx.AsyncClient(timeout=timeout_seconds, follow_redirects=True, headers=headers) as client:
-        outcomes = await _resolve_outcomes_with_client(
-            client=client,
-            targets=targets,
-            email=email,
-        )
-    _log_resolution_summary(
-        publication_count=len(items),
-        doi_input_count=_doi_input_count(items),
-        search_attempt_count=_search_attempt_count(targets=targets),
-        resolved_pdf_count=_resolved_pdf_count(outcomes),
-        email=email,
-    )
-    return outcomes
-
-
-async def resolve_publication_pdf_urls(
-    items: list[PublicationListItem],
-    *,
-    request_email: str | None = None,
-) -> dict[int, str | None]:
-    resolved = await resolve_publication_oa_metadata(items, request_email=request_email)
-    return {publication_id: pdf for publication_id, (_doi, pdf) in resolved.items()}
diff --git a/build/lib/app/services/domains/unpaywall/pdf_discovery.py b/build/lib/app/services/domains/unpaywall/pdf_discovery.py
deleted file mode 100644
index 5f82a58..0000000
--- a/build/lib/app/services/domains/unpaywall/pdf_discovery.py
+++ /dev/null
@@ -1,156 +0,0 @@
-from __future__ import annotations
-
-from html.parser import HTMLParser
-import re
-from urllib.parse import urljoin, urlparse
-
-from app.services.domains.unpaywall.rate_limit import wait_for_unpaywall_slot
-from app.settings import settings
-
-PDF_MIME = "application/pdf"
-URL_RE = re.compile(r"https?://[^\s\"'<>]+", re.I)
-
-
-class _LandingPdfParser(HTMLParser):
-    def __init__(self) -> None:
-        super().__init__(convert_charrefs=True)
-        self.base_href: str | None = None
-        self.candidates: list[str] = []
-
-    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
-        attrs_map = {key.lower(): (value or "").strip() for key, value in attrs}
-        if tag == "base":
-            self.base_href = attrs_map.get("href") or self.base_href
-            return
-        if tag == "meta":
-            self._append_meta_candidate(attrs_map)
-            return
-        if tag == "link":
-            self._append_link_candidate(attrs_map)
-            return
-        if tag == "a":
-            self._append_anchor_candidate(attrs_map)
-
-    def _append_meta_candidate(self, attrs_map: dict[str, str]) -> None:
-        meta_name = (attrs_map.get("name") or attrs_map.get("property") or "").lower()
-        if meta_name != "citation_pdf_url":
-            return
-        content = attrs_map.get("content")
-        if content:
-            self.candidates.append(content)
-
-    def _append_link_candidate(self, attrs_map: dict[str, str]) -> None:
-        href = attrs_map.get("href")
-        link_type = (attrs_map.get("type") or "").lower()
-        if href and "pdf" in link_type:
-            self.candidates.append(href)
-
-    def _append_anchor_candidate(self, attrs_map: dict[str, str]) -> None:
-        href = attrs_map.get("href")
-        if href:
-            self.candidates.append(href)
-
-
-def looks_like_pdf_url(url: str | None) -> bool:
-    if not isinstance(url, str):
-        return False
-    value = url.strip()
-    if not value:
-        return False
-    parsed = urlparse(value)
-    path = (parsed.path or "").lower()
-    query = (parsed.query or "").lower()
-    return path.endswith(".pdf") or ".pdf" in query
-
-
-def _normalized_candidate_urls(*, page_url: str, html: str) -> list[str]:
-    parser = _LandingPdfParser()
-    parser.feed(html)
-    parser.close()
-    base_url = urljoin(page_url, parser.base_href) if parser.base_href else page_url
-    raw_candidates = [*parser.candidates, *_text_url_candidates(html)]
-    deduped: list[str] = []
-    seen: set[str] = set()
-    for raw in raw_candidates:
-        absolute = urljoin(base_url, raw.strip())
-        parsed = urlparse(absolute)
-        if parsed.scheme not in {"http", "https"}:
-            continue
-        if absolute in seen:
-            continue
-        seen.add(absolute)
-        deduped.append(absolute)
-    return sorted(deduped, key=_candidate_sort_key)
-
-
-def _text_url_candidates(html: str) -> list[str]:
-    candidates: list[str] = []
-    for match in URL_RE.findall(html):
-        cleaned = match.rstrip(".,);]}>")
-        if "pdf" not in cleaned.lower():
-            continue
-        candidates.append(cleaned)
-    return candidates
-
-
-def _candidate_sort_key(candidate: str) -> tuple[int, str]:
-    lowered = candidate.lower()
-    if looks_like_pdf_url(candidate):
-        return (0, lowered)
-    if any(token in lowered for token in ("doi", "full", "article", "download")):
-        return (1, lowered)
-    return (2, lowered)
-
-
-def _is_html_response(response) -> bool:
-    content_type = str(response.headers.get("content-type") or "").lower()
-    return "text/html" in content_type or "application/xhtml+xml" in content_type
-
-
-async def _fetch_page_html(client, *, page_url: str) -> str | None:
-    await wait_for_unpaywall_slot(min_interval_seconds=settings.unpaywall_min_interval_seconds)
-    response = await client.get(page_url, follow_redirects=True)
-    if response.status_code != 200 or not _is_html_response(response):
-        return None
-    text = response.text or ""
-    return text[: max(int(settings.unpaywall_pdf_discovery_max_html_bytes), 0)]
-
-
-async def _candidate_is_pdf(client, *, candidate_url: str) -> bool:
-    if looks_like_pdf_url(candidate_url):
-        return True
-    await wait_for_unpaywall_slot(min_interval_seconds=settings.unpaywall_min_interval_seconds)
-    response = await client.get(candidate_url, follow_redirects=True)
-    content_type = str(response.headers.get("content-type") or "").lower()
-    return response.status_code == 200 and PDF_MIME in content_type
-
-
-def _candidate_limit() -> int:
-    return max(int(settings.unpaywall_pdf_discovery_max_candidates), 1)
-
-
-async def _resolve_pdf_from_candidate_page(client, *, candidate_url: str) -> str | None:
-    html = await _fetch_page_html(client, page_url=candidate_url)
-    if not html:
-        return None
-    nested_candidates = _normalized_candidate_urls(page_url=candidate_url, html=html)
-    for nested in nested_candidates[: _candidate_limit()]:
-        if await _candidate_is_pdf(client, candidate_url=nested):
-            return nested
-    return None
-
-
-async def resolve_pdf_from_landing_page(client, *, page_url: str) -> str | None:
-    if not settings.unpaywall_pdf_discovery_enabled:
-        return None
-    html = await _fetch_page_html(client, page_url=page_url)
-    if not html:
-        return None
-    candidates = _normalized_candidate_urls(page_url=page_url, html=html)
-    for candidate in candidates[: _candidate_limit()]:
-        if await _candidate_is_pdf(client, candidate_url=candidate):
-            return candidate
-        nested_pdf = await _resolve_pdf_from_candidate_page(client, candidate_url=candidate)
-        if nested_pdf:
-            return nested_pdf
-    return None
diff --git a/build/lib/app/services/domains/unpaywall/rate_limit.py b/build/lib/app/services/domains/unpaywall/rate_limit.py
deleted file mode 100644
index 76d8a3d..0000000
--- a/build/lib/app/services/domains/unpaywall/rate_limit.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import time
-
-_REQUEST_LOCK = asyncio.Lock()
-_LAST_REQUEST_AT = 0.0
-
-
-async def wait_for_unpaywall_slot(*, min_interval_seconds: float) -> None:
-    global _LAST_REQUEST_AT
-    interval = max(float(min_interval_seconds), 0.0)
-    async with _REQUEST_LOCK:
-        elapsed = time.monotonic() - _LAST_REQUEST_AT
-        remaining = interval - elapsed
-        if remaining > 0:
-            await asyncio.sleep(remaining)
-        _LAST_REQUEST_AT = time.monotonic()
diff --git a/build/lib/app/services/domains/users/__init__.py b/build/lib/app/services/domains/users/__init__.py
deleted file mode 100644
index 9d48db4..0000000
--- a/build/lib/app/services/domains/users/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from __future__ import annotations
diff --git a/build/lib/app/services/domains/users/application.py b/build/lib/app/services/domains/users/application.py
deleted file mode 100644
index 7f019c4..0000000
--- a/build/lib/app/services/domains/users/application.py
+++ /dev/null
@@ -1,98 +0,0 @@
-from __future__ import annotations
-
-import re
-
-from sqlalchemy import select
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.models import User
-
-EMAIL_PATTERN = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
-
-
-class UserServiceError(ValueError):
-    """Raised for expected user-management validation failures."""
-
-
-def normalize_email(value: str) -> str:
-    return value.strip().lower()
-
-
-def validate_email(value: str) -> str:
-    email = normalize_email(value)
-    if not EMAIL_PATTERN.fullmatch(email):
-        raise UserServiceError("Enter a valid email address.")
-    return email
-
-
-def validate_password(value: str) -> str:
-    password = value.strip()
-    if len(password) < 8:
-        raise UserServiceError("Password must be at least 8 characters.")
-    return password
-
-
-async def get_user_by_id(db_session: AsyncSession, user_id: int) -> User | None:
-    result = await db_session.execute(select(User).where(User.id == user_id))
-    return result.scalar_one_or_none()
-
-
-async def get_user_by_email(db_session: AsyncSession, email: str) -> User | None:
-    result = await db_session.execute(
-        select(User).where(User.email == normalize_email(email))
-    )
-    return result.scalar_one_or_none()
-
-
-async def list_users(db_session: AsyncSession) -> list[User]:
-    result = await db_session.execute(select(User).order_by(User.email.asc()))
-    return list(result.scalars().all())
-
-
-async def create_user(
-    db_session: AsyncSession,
-    *,
-    email: str,
-    password_hash: str,
-    is_admin: bool,
-) -> User:
-    user = User(
-        email=validate_email(email),
-        password_hash=password_hash,
-        is_admin=is_admin,
-        is_active=True,
-    )
-    db_session.add(user)
-    try:
-        await db_session.commit()
-    except IntegrityError as exc:
-        await db_session.rollback()
-        raise UserServiceError("A user with that email already exists.") from exc
-    await db_session.refresh(user)
-    return user
-
-
-async def set_user_active(
-    db_session: AsyncSession,
-    *,
-    user: User,
-    is_active: bool,
-) -> User:
-    user.is_active = is_active
-    await db_session.commit()
-    await db_session.refresh(user)
-    return user
-
-
-async def set_user_password_hash(
-    db_session: AsyncSession,
-    *,
-    user: User,
-    password_hash: str,
-) -> User:
-    user.password_hash = password_hash
-    await db_session.commit()
-    await db_session.refresh(user)
-    return user
-
diff --git a/build/lib/app/settings.py b/build/lib/app/settings.py
deleted file mode 100644
index f56ff51..0000000
--- a/build/lib/app/settings.py
+++ /dev/null
@@ -1,267 +0,0 @@
-from dataclasses import dataclass
-import os
-
-DEFAULT_SECURITY_PERMISSIONS_POLICY = (
-    "accelerometer=(), autoplay=(), camera=(), display-capture=(), "
-    "geolocation=(), gyroscope=(), microphone=(), payment=(), usb=()"
-)
-DEFAULT_SECURITY_CSP_POLICY = (
-    "default-src 'self'; "
-    "base-uri 'self'; "
-    "form-action 'self'; "
-    "frame-ancestors 'none'; "
-    "img-src 'self' data: https:; "
-    "script-src 'self'; "
-    "style-src 'self' 'unsafe-inline'; "
-    "font-src 'self' data:; "
-    "connect-src 'self'; "
-    "object-src 'none'"
-)
-DEFAULT_SECURITY_CSP_DOCS_POLICY = (
-    "default-src 'self'; "
-    "img-src 'self' data: https:; "
-    "script-src 'self' 'unsafe-inline'; "
-    "style-src 'self' 'unsafe-inline'; "
-    "font-src 'self' data:; "
-    "connect-src 'self' https:; "
-    "object-src 'none'; "
-    "frame-ancestors 'none'"
-)
-
-
-def _env_bool(name: str, default: bool) -> bool:
-    value = os.getenv(name)
-    if value is None:
-        return default
-    return value.strip().lower() in {"1", "true", "yes", "on"}
-
-
-def _env_int(name: str, default: int) -> int:
-    value = os.getenv(name)
-    if value is None:
-        return default
-    return int(value)
-
-
-def _env_float(name: str, default: float) -> float:
-    value = os.getenv(name)
-    if value is None:
-        return default
-    return float(value)
-
-
-def _env_str(name: str, default: str) -> str:
-    value = os.getenv(name)
-    if value is None:
-        return default
-    return value.strip() or default
-
-
-@dataclass(frozen=True)
-class Settings:
-    app_name: str = os.getenv("APP_NAME", "scholarr")
-    database_url: str = os.getenv(
-        "DATABASE_URL",
-        "postgresql+asyncpg://scholar:scholar@db:5432/scholar",
-    )
-    database_pool_mode: str = _env_str("DATABASE_POOL_MODE", "auto")
-    database_pool_size: int = _env_int("DATABASE_POOL_SIZE", 5)
-    database_pool_max_overflow: int = _env_int("DATABASE_POOL_MAX_OVERFLOW", 10)
-    database_pool_timeout_seconds: int = _env_int("DATABASE_POOL_TIMEOUT_SECONDS", 30)
-    session_secret_key: str = os.getenv("SESSION_SECRET_KEY", "dev-insecure-session-key")
-    session_cookie_secure: bool = _env_bool("SESSION_COOKIE_SECURE", False)
-    security_headers_enabled: bool = _env_bool("SECURITY_HEADERS_ENABLED", True)
-    security_x_content_type_options: str = _env_str("SECURITY_X_CONTENT_TYPE_OPTIONS", "nosniff")
-    security_x_frame_options: str = _env_str("SECURITY_X_FRAME_OPTIONS", "DENY")
-    security_referrer_policy: str = _env_str("SECURITY_REFERRER_POLICY", "strict-origin-when-cross-origin")
-    security_permissions_policy: str = _env_str(
-        "SECURITY_PERMISSIONS_POLICY",
-        DEFAULT_SECURITY_PERMISSIONS_POLICY,
-    )
-    security_cross_origin_opener_policy: str = _env_str(
-        "SECURITY_CROSS_ORIGIN_OPENER_POLICY",
-        "same-origin",
-    )
-    security_cross_origin_resource_policy: str = _env_str(
-        "SECURITY_CROSS_ORIGIN_RESOURCE_POLICY",
-        "same-origin",
-    )
-    security_csp_enabled: bool = _env_bool("SECURITY_CSP_ENABLED", True)
-    security_csp_policy: str = _env_str("SECURITY_CSP_POLICY", DEFAULT_SECURITY_CSP_POLICY)
-    security_csp_docs_policy: str = _env_str("SECURITY_CSP_DOCS_POLICY", DEFAULT_SECURITY_CSP_DOCS_POLICY)
-    security_csp_report_only: bool = _env_bool("SECURITY_CSP_REPORT_ONLY", False)
-    security_strict_transport_security_enabled: bool = _env_bool(
-        "SECURITY_STRICT_TRANSPORT_SECURITY_ENABLED",
-        False,
-    )
-    security_strict_transport_security_max_age: int = _env_int(
-        "SECURITY_STRICT_TRANSPORT_SECURITY_MAX_AGE",
-        31_536_000,
-    )
-    security_strict_transport_security_include_subdomains: bool = _env_bool(
-        "SECURITY_STRICT_TRANSPORT_SECURITY_INCLUDE_SUBDOMAINS",
-        True,
-    )
-    security_strict_transport_security_preload: bool = _env_bool(
-        "SECURITY_STRICT_TRANSPORT_SECURITY_PRELOAD",
-        False,
-    )
-    login_rate_limit_attempts: int = _env_int("LOGIN_RATE_LIMIT_ATTEMPTS", 5)
-    login_rate_limit_window_seconds: int = _env_int(
-        "LOGIN_RATE_LIMIT_WINDOW_SECONDS",
-        60,
-    )
-    log_level: str = _env_str("LOG_LEVEL", "INFO")
-    log_format: str = _env_str("LOG_FORMAT", "console")
-    log_requests: bool = _env_bool("LOG_REQUESTS", True)
-    log_uvicorn_access: bool = _env_bool("LOG_UVICORN_ACCESS", False)
-    log_request_skip_paths: str = _env_str("LOG_REQUEST_SKIP_PATHS", "/healthz")
-    log_redact_fields: str = os.getenv("LOG_REDACT_FIELDS", "")
-    scheduler_enabled: bool = _env_bool("SCHEDULER_ENABLED", True)
-    scheduler_tick_seconds: int = _env_int("SCHEDULER_TICK_SECONDS", 60)
-    ingestion_automation_allowed: bool = _env_bool(
-        "INGESTION_AUTOMATION_ALLOWED",
-        True,
-    )
-    ingestion_manual_run_allowed: bool = _env_bool(
-        "INGESTION_MANUAL_RUN_ALLOWED",
-        True,
-    )
-    ingestion_min_run_interval_minutes: int = _env_int(
-        "INGESTION_MIN_RUN_INTERVAL_MINUTES",
-        15,
-    )
-    ingestion_min_request_delay_seconds: int = _env_int(
-        "INGESTION_MIN_REQUEST_DELAY_SECONDS",
-        2,
-    )
-    ingestion_network_error_retries: int = _env_int("INGESTION_NETWORK_ERROR_RETRIES", 1)
-    ingestion_retry_backoff_seconds: float = _env_float(
-        "INGESTION_RETRY_BACKOFF_SECONDS",
-        1.0,
-    )
-    ingestion_rate_limit_retries: int = _env_int("INGESTION_RATE_LIMIT_RETRIES", 3)
-    ingestion_rate_limit_backoff_seconds: float = _env_float(
-        "INGESTION_RATE_LIMIT_BACKOFF_SECONDS",
-        30.0,
-    )
-    ingestion_max_pages_per_scholar: int = _env_int(
-        "INGESTION_MAX_PAGES_PER_SCHOLAR",
-        30,
-    )
-    ingestion_page_size: int = _env_int("INGESTION_PAGE_SIZE", 100)
-    ingestion_alert_blocked_failure_threshold: int = _env_int(
-        "INGESTION_ALERT_BLOCKED_FAILURE_THRESHOLD",
-        1,
-    )
-    ingestion_alert_network_failure_threshold: int = _env_int(
-        "INGESTION_ALERT_NETWORK_FAILURE_THRESHOLD",
-        2,
-    )
-    ingestion_alert_retry_scheduled_threshold: int = _env_int(
-        "INGESTION_ALERT_RETRY_SCHEDULED_THRESHOLD",
-        3,
-    )
-    ingestion_safety_cooldown_blocked_seconds: int = _env_int(
-        "INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS",
-        1800,
-    )
-    ingestion_safety_cooldown_network_seconds: int = _env_int(
-        "INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS",
-        900,
-    )
-    ingestion_continuation_queue_enabled: bool = _env_bool(
-        "INGESTION_CONTINUATION_QUEUE_ENABLED",
-        True,
-    )
-    ingestion_continuation_base_delay_seconds: int = _env_int(
-        "INGESTION_CONTINUATION_BASE_DELAY_SECONDS",
-        120,
-    )
-    ingestion_continuation_max_delay_seconds: int = _env_int(
-        "INGESTION_CONTINUATION_MAX_DELAY_SECONDS",
-        3600,
-    )
-    ingestion_continuation_max_attempts: int = _env_int(
-        "INGESTION_CONTINUATION_MAX_ATTEMPTS",
-        6,
-    )
-    scheduler_queue_batch_size: int = _env_int("SCHEDULER_QUEUE_BATCH_SIZE", 10)
-    scheduler_pdf_queue_batch_size: int = _env_int("SCHEDULER_PDF_QUEUE_BATCH_SIZE", 15)
-    frontend_enabled: bool = _env_bool("FRONTEND_ENABLED", True)
-    frontend_dist_dir: str = _env_str("FRONTEND_DIST_DIR", "/app/frontend/dist")
-    scholar_image_upload_dir: str = _env_str(
-        "SCHOLAR_IMAGE_UPLOAD_DIR",
-        "/tmp/scholarr_uploads/scholar_images",
-    )
-    scholar_image_upload_max_bytes: int = _env_int(
-        "SCHOLAR_IMAGE_UPLOAD_MAX_BYTES",
-        2_000_000,
-    )
-    scholar_name_search_enabled: bool = _env_bool("SCHOLAR_NAME_SEARCH_ENABLED", True)
-    scholar_name_search_cache_ttl_seconds: int = _env_int(
-        "SCHOLAR_NAME_SEARCH_CACHE_TTL_SECONDS",
-        21_600,
-    )
-    scholar_name_search_blocked_cache_ttl_seconds: int = _env_int(
-        "SCHOLAR_NAME_SEARCH_BLOCKED_CACHE_TTL_SECONDS",
-        300,
-    )
-    scholar_name_search_cache_max_entries: int = _env_int(
-        "SCHOLAR_NAME_SEARCH_CACHE_MAX_ENTRIES",
-        512,
-    )
-    scholar_name_search_min_interval_seconds: float = _env_float(
-        "SCHOLAR_NAME_SEARCH_MIN_INTERVAL_SECONDS",
-        8.0,
-    )
-    scholar_name_search_interval_jitter_seconds: float = _env_float(
-        "SCHOLAR_NAME_SEARCH_INTERVAL_JITTER_SECONDS",
-        2.0,
-    )
-    scholar_name_search_cooldown_block_threshold: int = _env_int(
-        "SCHOLAR_NAME_SEARCH_COOLDOWN_BLOCK_THRESHOLD",
-        1,
-    )
-    scholar_name_search_cooldown_seconds: int = _env_int(
-        "SCHOLAR_NAME_SEARCH_COOLDOWN_SECONDS",
-        1800,
-    )
-    scholar_name_search_alert_retry_count_threshold: int = _env_int(
-        "SCHOLAR_NAME_SEARCH_ALERT_RETRY_COUNT_THRESHOLD",
-        2,
-    )
-    scholar_name_search_alert_cooldown_rejections_threshold: int = _env_int(
-        "SCHOLAR_NAME_SEARCH_ALERT_COOLDOWN_REJECTIONS_THRESHOLD",
-        3,
-    )
-    unpaywall_enabled: bool = _env_bool("UNPAYWALL_ENABLED", True)
-    unpaywall_email: str = _env_str("UNPAYWALL_EMAIL", "")
-    unpaywall_timeout_seconds: float = _env_float("UNPAYWALL_TIMEOUT_SECONDS", 4.0)
-    unpaywall_min_interval_seconds: float = _env_float("UNPAYWALL_MIN_INTERVAL_SECONDS", 0.6)
-    unpaywall_max_items_per_request: int = _env_int("UNPAYWALL_MAX_ITEMS_PER_REQUEST", 20)
-    unpaywall_retry_cooldown_seconds: int = _env_int("UNPAYWALL_RETRY_COOLDOWN_SECONDS", 1800)
-    pdf_auto_retry_interval_seconds: int = _env_int(
-        "PDF_AUTO_RETRY_INTERVAL_SECONDS",
-        86_400,
-    )
-    pdf_auto_retry_first_interval_seconds: int = _env_int(
-        "PDF_AUTO_RETRY_FIRST_INTERVAL_SECONDS",
-        3_600,
-    )
-    pdf_auto_retry_max_attempts: int = _env_int("PDF_AUTO_RETRY_MAX_ATTEMPTS", 3)
-    unpaywall_pdf_discovery_enabled: bool = _env_bool("UNPAYWALL_PDF_DISCOVERY_ENABLED", True)
-    unpaywall_pdf_discovery_max_candidates: int = _env_int("UNPAYWALL_PDF_DISCOVERY_MAX_CANDIDATES", 5)
-    unpaywall_pdf_discovery_max_html_bytes: int = _env_int("UNPAYWALL_PDF_DISCOVERY_MAX_HTML_BYTES", 500_000)
-    crossref_enabled: bool = _env_bool("CROSSREF_ENABLED", True)
-    crossref_max_rows: int = _env_int("CROSSREF_MAX_ROWS", 10)
-    crossref_timeout_seconds: float = _env_float("CROSSREF_TIMEOUT_SECONDS", 8.0)
-    crossref_min_interval_seconds: float = _env_float("CROSSREF_MIN_INTERVAL_SECONDS", 0.6)
-    crossref_max_lookups_per_request: int = _env_int("CROSSREF_MAX_LOOKUPS_PER_REQUEST", 8)
-    
-    openalex_api_key: str | None = os.getenv("OPENALEX_API_KEY")
-    crossref_api_token: str | None = os.getenv("CROSSREF_API_TOKEN")
-    crossref_api_mailto: str | None = os.getenv("CROSSREF_API_MAILTO")
-
-
-settings = Settings()
diff --git a/diag_pubs.py b/diag_pubs.py
deleted file mode 100644
index 2417001..0000000
--- a/diag_pubs.py
+++ /dev/null
@@ -1,39 +0,0 @@
-
-import asyncio
-from sqlalchemy import select, func
-from app.db.session import get_session_factory
-from app.db.models import Publication, ScholarPublication
-
-async def check_publications():
-    session_factory = get_session_factory()
-    async with session_factory() as session:
-        # Total publications
-        total_pubs = await session.execute(select(func.count()).select_from(Publication))
-        print(f"Total Publications: {total_pubs.scalar()}")
-
-        # Total scholar links
-        total_links = await session.execute(select(func.count()).select_from(ScholarPublication))
-        print(f"Total Scholar-Publication Links: {total_links.scalar()}")
-
-        # Check for orphans
-        orphans = await session.execute(
-            select(func.count())
-            .select_from(Publication)
-            .outerjoin(ScholarPublication, Publication.id == ScholarPublication.publication_id)
-            .where(ScholarPublication.publication_id == None)
-        )
-        print(f"Orphaned Publications (no link): {orphans.scalar()}")
-
-        # Check sorting behavior
-        latest_links = await session.execute(
-            select(Publication.title_raw, ScholarPublication.created_at)
-            .join(ScholarPublication, Publication.id == ScholarPublication.publication_id)
-            .order_by(ScholarPublication.created_at.desc())
-            .limit(10)
-        )
-        print("\nLatest 10 links by created_at:")
-        for row in latest_links:
-            print(f"- {row.created_at}: {row.title_raw[:50]}")
-
-if __name__ == "__main__":
-    asyncio.run(check_publications())
diff --git a/frontend/docs/website/package-lock.json b/frontend/docs/website/package-lock.json
deleted file mode 100644
index 4ff32e6..0000000
--- a/frontend/docs/website/package-lock.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "name": "website",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {}
-}
diff --git a/test_enrich.py b/test_enrich.py
deleted file mode 100644
index 9a76001..0000000
--- a/test_enrich.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import asyncio
-from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
-from app.settings import settings
-from app.db.models import ScholarProfile
-from app.services.domains.ingestion.application import ScholarIngestionService
-from app.services.domains.scholar.parser_types import PublicationCandidate
-from app.services.domains.openalex.client import OpenAlexClient
-
-async def main():
-    service = ScholarIngestionService()
-    scholar = ScholarProfile(
-        id=1,
-        scholar_id="SaiiI5MAAAAJ",
-        name="Test Scholar"
-    )
-    pubs = [
-        PublicationCandidate(
-            title="A fast quantum mechanical algorithm for database search",
-            year=1996,
-            citation_count=1000,
-            authors_text="LK Grover",
-            venue_text="Proceedings of the 28th Annual ACM Symposium on the Theory of Computing",
-            cluster_id=None,
-            title_url=None,
-            pdf_url=None
-        )
-    ]
-    
-    print("Enriching...")
-    try:
-        enriched = await service._enrich_publications_with_openalex(scholar, pubs)
-        for p in enriched:
-            print(f"Title: {p.title}")
-            print(f"Year: {p.year}")
-            print(f"Citations: {p.citation_count}")
-            print(f"PDF URL: {p.pdf_url}")
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    asyncio.run(main())
-- 
2.49.1


From 6b47b56867faa73a1b61807ef97610c47d91953c Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Thu, 26 Feb 2026 21:31:32 +0100
Subject: [PATCH 06/38] refactor: add structured_log utility to eliminate
 logging boilerplate

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/logging_utils.py       | 29 +++++++++++++++++
 tests/unit/test_logging.py | 67 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 95 insertions(+), 1 deletion(-)
 create mode 100644 app/logging_utils.py

diff --git a/app/logging_utils.py b/app/logging_utils.py
new file mode 100644
index 0000000..e81628e
--- /dev/null
+++ b/app/logging_utils.py
@@ -0,0 +1,29 @@
+"""Structured logging utility — eliminates boilerplate across domain services."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+
+def structured_log(
+    logger: logging.Logger,
+    level: str,
+    event: str,
+    /,
+    **fields: Any,
+) -> None:
+    """Emit a structured log entry.
+
+    The event name is passed as the log message. The JsonLogFormatter in
+    logging_config.py extracts it via record.getMessage() when no explicit
+    'event' key exists in extra — so we do NOT duplicate it.
+
+    Usage:
+        structured_log(logger, "info", "ingestion.run_started", user_id=1, scholar_count=5)
+    """
+    fields.pop("metric_name", None)
+    fields.pop("metric_value", None)
+
+    log_method = getattr(logger, level.lower())
+    log_method(event, extra=fields)
diff --git a/tests/unit/test_logging.py b/tests/unit/test_logging.py
index 84cf882..2a08d4c 100644
--- a/tests/unit/test_logging.py
+++ b/tests/unit/test_logging.py
@@ -7,7 +7,8 @@ from unittest.mock import AsyncMock
 
 from fastapi.testclient import TestClient
 
-from app.logging_config import JsonLogFormatter, parse_redact_fields
+from app.logging_config import ConsoleLogFormatter, JsonLogFormatter, parse_redact_fields
+from app.logging_utils import structured_log
 from app.main import app
 from app.http.middleware import REQUEST_ID_HEADER, parse_skip_paths
 
@@ -53,3 +54,67 @@ def test_parse_skip_paths_trims_and_discards_empty_segments() -> None:
         "/healthz",
         "/api/v1/metrics",
     )
+
+
+# --- structured_log tests ---
+
+
+def _capture_structured_log(caplog, level, event, **fields):
+    """Helper: call structured_log and return the captured LogRecord."""
+    logger = logging.getLogger("tests.structured")
+    with caplog.at_level(logging.DEBUG, logger="tests.structured"):
+        structured_log(logger, level, event, **fields)
+    return caplog.records[-1]
+
+
+def test_structured_log_json_formatter_uses_event_as_message(caplog) -> None:
+    record = _capture_structured_log(caplog, "info", "ingestion.run_started", user_id=42)
+    formatter = JsonLogFormatter(redact_fields=set())
+    payload = json.loads(formatter.format(record))
+
+    assert payload["event"] == "ingestion.run_started"
+    assert payload["user_id"] == 42
+
+
+def test_structured_log_console_formatter(caplog) -> None:
+    record = _capture_structured_log(caplog, "warning", "export.failed", scholar_id=7)
+    formatter = ConsoleLogFormatter(redact_fields=set())
+    output = formatter.format(record)
+
+    assert "export.failed" in output
+    assert "scholar_id=7" in output
+
+
+def test_structured_log_strips_metric_fields(caplog) -> None:
+    record = _capture_structured_log(
+        caplog,
+        "info",
+        "scrape.complete",
+        metric_name="articles_scraped",
+        metric_value=15,
+        scholar_id=3,
+    )
+    formatter = JsonLogFormatter(redact_fields=set())
+    payload = json.loads(formatter.format(record))
+
+    assert "metric_name" not in payload
+    assert "metric_value" not in payload
+    assert payload["scholar_id"] == 3
+
+
+def test_structured_log_extra_fields_in_output(caplog) -> None:
+    record = _capture_structured_log(
+        caplog,
+        "info",
+        "scholar.created",
+        user_id=1,
+        scholar_id=99,
+        scholar_name="Ada Lovelace",
+    )
+    formatter = JsonLogFormatter(redact_fields=set())
+    payload = json.loads(formatter.format(record))
+
+    assert payload["event"] == "scholar.created"
+    assert payload["user_id"] == 1
+    assert payload["scholar_id"] == 99
+    assert payload["scholar_name"] == "Ada Lovelace"
-- 
2.49.1


From 19ca53186cc2ad45099510b3faba14ca34b679a5 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Thu, 26 Feb 2026 21:41:05 +0100
Subject: [PATCH 07/38] refactor: migrate ingestion service logging to
 structured_log

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/services/domains/ingestion/application.py | 580 ++++++------------
 1 file changed, 195 insertions(+), 385 deletions(-)

diff --git a/app/services/domains/ingestion/application.py b/app/services/domains/ingestion/application.py
index cedd165..da37c88 100644
--- a/app/services/domains/ingestion/application.py
+++ b/app/services/domains/ingestion/application.py
@@ -66,6 +66,7 @@ from app.services.domains.scholar.parser import (
     parse_profile_page,
 )
 from app.services.domains.scholar.source import FetchResult, ScholarSource
+from app.logging_utils import structured_log
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
@@ -119,28 +120,6 @@ class ScholarIngestionService:
         )
         return max(policy_minimum, _int_or_default(value, policy_minimum))
 
-    @staticmethod
-    def _log_request_delay_coercion(
-        *,
-        user_id: int,
-        requested_request_delay_seconds: int,
-        effective_request_delay_seconds: int,
-    ) -> None:
-        logger.warning(
-            "ingestion.request_delay_coerced_to_policy_floor",
-            extra={
-                "event": "ingestion.request_delay_coerced_to_policy_floor",
-                "user_id": user_id,
-                "requested_request_delay_seconds": requested_request_delay_seconds,
-                "effective_request_delay_seconds": effective_request_delay_seconds,
-                "policy_minimum_request_delay_seconds": user_settings_service.resolve_request_delay_minimum(
-                    settings.ingestion_min_request_delay_seconds
-                ),
-                "metric_name": "ingestion_request_delay_coerced_total",
-                "metric_value": 1,
-            },
-        )
-
     async def _load_user_settings_for_run(
         self,
         db_session: AsyncSession,
@@ -173,16 +152,11 @@ class ScholarIngestionService:
         if run_safety_service.clear_expired_cooldown(user_settings, now_utc=now_utc):
             await db_session.commit()
             await db_session.refresh(user_settings)
-            logger.info(
-                "ingestion.safety_cooldown_cleared",
-                extra={
-                    "event": "ingestion.safety_cooldown_cleared",
-                    "user_id": user_id,
-                    "reason": previous.get("cooldown_reason"),
-                    "cooldown_until": previous.get("cooldown_until"),
-                    "metric_name": "ingestion_safety_cooldown_cleared_total",
-                    "metric_value": 1,
-                },
+            structured_log(
+                logger, "info", "ingestion.safety_cooldown_cleared",
+                user_id=user_id,
+                reason=previous.get("cooldown_reason"),
+                cooldown_until=previous.get("cooldown_until"),
             )
             now_utc = datetime.now(timezone.utc)
         if run_safety_service.is_cooldown_active(user_settings, now_utc=now_utc):
@@ -208,19 +182,14 @@ class ScholarIngestionService:
             now_utc=now_utc,
         )
         await db_session.commit()
-        logger.warning(
-            "ingestion.safety_policy_blocked_run_start",
-            extra={
-                "event": "ingestion.safety_policy_blocked_run_start",
-                "user_id": user_id,
-                "trigger_type": trigger_type.value,
-                "reason": safety_state.get("cooldown_reason"),
-                "cooldown_until": safety_state.get("cooldown_until"),
-                "cooldown_remaining_seconds": safety_state.get("cooldown_remaining_seconds"),
-                "blocked_start_count": ((safety_state.get("counters") or {}).get("blocked_start_count")),
-                "metric_name": "ingestion_safety_run_start_blocked_total",
-                "metric_value": 1,
-            },
+        structured_log(
+            logger, "warning", "ingestion.safety_policy_blocked_run_start",
+            user_id=user_id,
+            trigger_type=trigger_type.value,
+            reason=safety_state.get("cooldown_reason"),
+            cooldown_until=safety_state.get("cooldown_until"),
+            cooldown_remaining_seconds=safety_state.get("cooldown_remaining_seconds"),
+            blocked_start_count=((safety_state.get("counters") or {}).get("blocked_start_count")),
         )
         raise RunBlockedBySafetyPolicyError(
             code="scrape_cooldown_active",
@@ -306,43 +275,6 @@ class ScholarIngestionService:
             error_log={},
         )
 
-    @staticmethod
-    def _log_run_started(
-        *,
-        user_id: int,
-        trigger_type: RunTriggerType,
-        scholar_count: int,
-        filtered: bool,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-        idempotency_key: str | None,
-        alert_blocked_failure_threshold: int,
-        alert_network_failure_threshold: int,
-        alert_retry_scheduled_threshold: int,
-    ) -> None:
-        logger.info(
-            "ingestion.run_started",
-            extra={
-                "event": "ingestion.run_started",
-                "user_id": user_id,
-                "trigger_type": trigger_type.value,
-                "scholar_count": scholar_count,
-                "is_filtered_run": filtered,
-                "request_delay_seconds": request_delay_seconds,
-                "network_error_retries": network_error_retries,
-                "retry_backoff_seconds": retry_backoff_seconds,
-                "max_pages_per_scholar": max_pages_per_scholar,
-                "page_size": page_size,
-                "idempotency_key": idempotency_key,
-                "alert_blocked_failure_threshold": alert_blocked_failure_threshold,
-                "alert_network_failure_threshold": alert_network_failure_threshold,
-                "alert_retry_scheduled_threshold": alert_retry_scheduled_threshold,
-            },
-        )
-
     @staticmethod
     async def _wait_between_scholars(*, index: int, request_delay_seconds: int) -> None:
         if index <= 0 or request_delay_seconds <= 0:
@@ -379,35 +311,6 @@ class ScholarIngestionService:
             scholar.profile_image_url = first_page.profile_image_url
         scholar.last_initial_page_checked_at = run_dt
 
-    @staticmethod
-    def _log_scholar_parsed(
-        *,
-        user_id: int,
-        run_id: int,
-        scholar: ScholarProfile,
-        paged_parse_result: PagedParseResult,
-    ) -> None:
-        parsed_page = paged_parse_result.parsed_page
-        logger.info(
-            "ingestion.scholar_parsed",
-            extra={
-                "event": "ingestion.scholar_parsed",
-                "user_id": user_id,
-                "crawl_run_id": run_id,
-                "scholar_profile_id": scholar.id,
-                "scholar_id": scholar.scholar_id,
-                "state": parsed_page.state.value,
-                "publication_count": len(paged_parse_result.publications),
-                "has_show_more_button": parsed_page.has_show_more_button,
-                "pages_fetched": paged_parse_result.pages_fetched,
-                "pages_attempted": paged_parse_result.pages_attempted,
-                "has_more_remaining": paged_parse_result.has_more_remaining,
-                "pagination_truncated_reason": paged_parse_result.pagination_truncated_reason,
-                "warning_count": len(parsed_page.warnings),
-                "skipped_no_change": paged_parse_result.skipped_no_change,
-            },
-        )
-
     @staticmethod
     def _build_result_entry(
         *,
@@ -594,7 +497,6 @@ class ScholarIngestionService:
         logger.exception(
             "ingestion.scholar_failed",
             extra={
-                "event": "ingestion.scholar_failed",
                 "crawl_run_id": run.id,
                 "scholar_profile_id": scholar.id,
                 "scholar_id": scholar.scholar_id,
@@ -618,16 +520,13 @@ class ScholarIngestionService:
             attempt_log=paged_parse_result.attempt_log,
             page_logs=paged_parse_result.page_logs,
         )
-        logger.warning(
-            "ingestion.scholar_parse_failed",
-            extra={
-                "event": "ingestion.scholar_parse_failed",
-                "scholar_profile_id": scholar.id,
-                "scholar_id": scholar.scholar_id,
-                "state": paged_parse_result.parsed_page.state.value,
-                "state_reason": paged_parse_result.parsed_page.state_reason,
-                "status_code": paged_parse_result.fetch_result.status_code,
-            },
+        structured_log(
+            logger, "warning", "ingestion.scholar_parse_failed",
+            scholar_profile_id=scholar.id,
+            scholar_id=scholar.scholar_id,
+            state=paged_parse_result.parsed_page.state.value,
+            state_reason=paged_parse_result.parsed_page.state_reason,
+            status_code=paged_parse_result.fetch_result.status_code,
         )
         return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
 
@@ -797,7 +696,23 @@ class ScholarIngestionService:
         )
         self._assert_valid_paged_parse_result(scholar_id=scholar.scholar_id, paged_parse_result=paged_parse_result)
         self._apply_first_page_profile_metadata(scholar=scholar, paged_parse_result=paged_parse_result, run_dt=run_dt)
-        self._log_scholar_parsed(user_id=user_id, run_id=run.id, scholar=scholar, paged_parse_result=paged_parse_result)
+        parsed_page = paged_parse_result.parsed_page
+        structured_log(
+            logger, "info", "ingestion.scholar_parsed",
+            user_id=user_id,
+            crawl_run_id=run.id,
+            scholar_profile_id=scholar.id,
+            scholar_id=scholar.scholar_id,
+            state=parsed_page.state.value,
+            publication_count=len(paged_parse_result.publications),
+            has_show_more_button=parsed_page.has_show_more_button,
+            pages_fetched=paged_parse_result.pages_fetched,
+            pages_attempted=paged_parse_result.pages_attempted,
+            has_more_remaining=paged_parse_result.has_more_remaining,
+            pagination_truncated_reason=paged_parse_result.pagination_truncated_reason,
+            warning_count=len(parsed_page.warnings),
+            skipped_no_change=paged_parse_result.skipped_no_change,
+        )
         result_entry = self._build_result_entry(
             scholar=scholar,
             start_cstart=start_cstart,
@@ -918,7 +833,6 @@ class ScholarIngestionService:
         logger.exception(
             "ingestion.scholar_unexpected_failure",
             extra={
-                "event": "ingestion.scholar_unexpected_failure",
                 "crawl_run_id": run.id,
                 "scholar_profile_id": scholar.id,
                 "scholar_id": scholar.scholar_id,
@@ -1009,54 +923,6 @@ class ScholarIngestionService:
             alert_flags=alert_flags,
         )
 
-    @staticmethod
-    def _log_alert_thresholds(
-        *,
-        user_id: int,
-        run_id: int,
-        failure_summary: RunFailureSummary,
-        alert_summary: RunAlertSummary,
-    ) -> None:
-        if alert_summary.alert_flags["blocked_failure_threshold_exceeded"]:
-            logger.warning(
-                "ingestion.alert_blocked_failure_threshold_exceeded",
-                extra={
-                    "event": "ingestion.alert_blocked_failure_threshold_exceeded",
-                    "user_id": user_id,
-                    "crawl_run_id": run_id,
-                    "blocked_failure_count": alert_summary.blocked_failure_count,
-                    "threshold": alert_summary.blocked_failure_threshold,
-                    "metric_name": "ingestion_blocked_failure_threshold_exceeded_total",
-                    "metric_value": 1,
-                },
-            )
-        if alert_summary.alert_flags["network_failure_threshold_exceeded"]:
-            logger.warning(
-                "ingestion.alert_network_failure_threshold_exceeded",
-                extra={
-                    "event": "ingestion.alert_network_failure_threshold_exceeded",
-                    "user_id": user_id,
-                    "crawl_run_id": run_id,
-                    "network_failure_count": alert_summary.network_failure_count,
-                    "threshold": alert_summary.network_failure_threshold,
-                    "metric_name": "ingestion_network_failure_threshold_exceeded_total",
-                    "metric_value": 1,
-                },
-            )
-        if alert_summary.alert_flags["retry_scheduled_threshold_exceeded"]:
-            logger.warning(
-                "ingestion.alert_retry_scheduled_threshold_exceeded",
-                extra={
-                    "event": "ingestion.alert_retry_scheduled_threshold_exceeded",
-                    "user_id": user_id,
-                    "crawl_run_id": run_id,
-                    "retries_scheduled_count": failure_summary.retries_scheduled_count,
-                    "threshold": alert_summary.retry_scheduled_threshold,
-                    "metric_name": "ingestion_retry_scheduled_threshold_exceeded_total",
-                    "metric_value": 1,
-                },
-            )
-
     @staticmethod
     def _apply_safety_outcome(
         *,
@@ -1080,56 +946,27 @@ class ScholarIngestionService:
             network_cooldown_seconds=settings.ingestion_safety_cooldown_network_seconds,
             now_utc=datetime.now(timezone.utc),
         )
-        ScholarIngestionService._log_safety_transition(
-            user_id=user_id,
-            run_id=int(run.id),
-            alert_summary=alert_summary,
-            pre_apply_state=pre_apply_state,
-            safety_state=safety_state,
-            cooldown_trigger_reason=cooldown_trigger_reason,
-        )
-
-    @staticmethod
-    def _log_safety_transition(
-        *,
-        user_id: int,
-        run_id: int,
-        alert_summary: RunAlertSummary,
-        pre_apply_state: dict[str, Any],
-        safety_state: dict[str, Any],
-        cooldown_trigger_reason: str | None,
-    ) -> None:
         if cooldown_trigger_reason is not None:
-            logger.warning(
-                "ingestion.safety_cooldown_entered",
-                extra={
-                    "event": "ingestion.safety_cooldown_entered",
-                    "user_id": user_id,
-                    "crawl_run_id": run_id,
-                    "reason": cooldown_trigger_reason,
-                    "blocked_failure_count": alert_summary.blocked_failure_count,
-                    "network_failure_count": alert_summary.network_failure_count,
-                    "blocked_failure_threshold": alert_summary.blocked_failure_threshold,
-                    "network_failure_threshold": alert_summary.network_failure_threshold,
-                    "cooldown_until": safety_state.get("cooldown_until"),
-                    "cooldown_remaining_seconds": safety_state.get("cooldown_remaining_seconds"),
-                    "safety_counters": safety_state.get("counters", {}),
-                    "metric_name": "ingestion_safety_cooldown_entered_total",
-                    "metric_value": 1,
-                },
+            structured_log(
+                logger, "warning", "ingestion.safety_cooldown_entered",
+                user_id=user_id,
+                crawl_run_id=int(run.id),
+                reason=cooldown_trigger_reason,
+                blocked_failure_count=alert_summary.blocked_failure_count,
+                network_failure_count=alert_summary.network_failure_count,
+                blocked_failure_threshold=alert_summary.blocked_failure_threshold,
+                network_failure_threshold=alert_summary.network_failure_threshold,
+                cooldown_until=safety_state.get("cooldown_until"),
+                cooldown_remaining_seconds=safety_state.get("cooldown_remaining_seconds"),
+                safety_counters=safety_state.get("counters", {}),
             )
         elif pre_apply_state.get("cooldown_active") and not safety_state.get("cooldown_active"):
-            logger.info(
-                "ingestion.safety_cooldown_cleared",
-                extra={
-                    "event": "ingestion.safety_cooldown_cleared",
-                    "user_id": user_id,
-                    "crawl_run_id": run_id,
-                    "reason": pre_apply_state.get("cooldown_reason"),
-                    "cooldown_until": pre_apply_state.get("cooldown_until"),
-                    "metric_name": "ingestion_safety_cooldown_cleared_total",
-                    "metric_value": 1,
-                },
+            structured_log(
+                logger, "info", "ingestion.safety_cooldown_cleared",
+                user_id=user_id,
+                crawl_run_id=int(run.id),
+                reason=pre_apply_state.get("cooldown_reason"),
+                cooldown_until=pre_apply_state.get("cooldown_until"),
             )
 
     def _finalize_run_record(
@@ -1174,35 +1011,6 @@ class ScholarIngestionService:
             "meta": {"idempotency_key": idempotency_key} if idempotency_key else {},
         }
 
-    @staticmethod
-    def _log_run_completed(
-        *,
-        user_id: int,
-        run: CrawlRun,
-        scholars: list[ScholarProfile],
-        progress: RunProgress,
-        alert_summary: RunAlertSummary,
-        failure_summary: RunFailureSummary,
-    ) -> None:
-        logger.info(
-            "ingestion.run_completed",
-            extra={
-                "event": "ingestion.run_completed",
-                "user_id": user_id,
-                "crawl_run_id": run.id,
-                "status": run.status.value,
-                "scholar_count": len(scholars),
-                "succeeded_count": progress.succeeded_count,
-                "failed_count": progress.failed_count,
-                "partial_count": progress.partial_count,
-                "new_publication_count": run.new_pub_count,
-                "blocked_failure_count": alert_summary.blocked_failure_count,
-                "network_failure_count": alert_summary.network_failure_count,
-                "retries_scheduled_count": failure_summary.retries_scheduled_count,
-                "alert_flags": alert_summary.alert_flags,
-            },
-        )
-
     @staticmethod
     def _paging_kwargs(
         *,
@@ -1307,11 +1115,12 @@ class ScholarIngestionService:
         alert_network_failure_threshold: int,
         alert_retry_scheduled_threshold: int,
     ) -> CrawlRun:
-        self._log_run_started(
+        structured_log(
+            logger, "info", "ingestion.run_started",
             user_id=user_id,
-            trigger_type=trigger_type,
+            trigger_type=trigger_type.value,
             scholar_count=len(scholars),
-            filtered=filtered,
+            is_filtered_run=filtered,
             request_delay_seconds=request_delay_seconds,
             network_error_retries=network_error_retries,
             retry_backoff_seconds=retry_backoff_seconds,
@@ -1367,9 +1176,9 @@ class ScholarIngestionService:
         for index, scholar in enumerate(scholars):
             await db_session.refresh(run)
             if run.status == RunStatus.CANCELED:
-                logger.info(
-                    "ingestion.run_canceled",
-                    extra={"event": "ingestion.run_canceled", "run_id": run.id, "user_id": user_id},
+                structured_log(
+                    logger, "info", "ingestion.run_canceled",
+                    run_id=run.id, user_id=user_id,
                 )
                 return progress
             await self._wait_between_scholars(index=index, request_delay_seconds=request_delay_seconds)
@@ -1407,9 +1216,9 @@ class ScholarIngestionService:
                 continue  # first page failed, had no continuation, or was skipped
             await db_session.refresh(run)
             if run.status == RunStatus.CANCELED:
-                logger.info(
-                    "ingestion.run_canceled",
-                    extra={"event": "ingestion.run_canceled", "run_id": run.id, "user_id": user_id},
+                structured_log(
+                    logger, "info", "ingestion.run_canceled",
+                    run_id=run.id, user_id=user_id,
                 )
                 break
             await self._wait_between_scholars(index=index, request_delay_seconds=request_delay_seconds)
@@ -1452,12 +1261,30 @@ class ScholarIngestionService:
             alert_network_failure_threshold=alert_network_failure_threshold,
             alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
         )
-        self._log_alert_thresholds(
-            user_id=user_id,
-            run_id=int(run.id),
-            failure_summary=failure_summary,
-            alert_summary=alert_summary,
-        )
+        if alert_summary.alert_flags["blocked_failure_threshold_exceeded"]:
+            structured_log(
+                logger, "warning", "ingestion.alert_blocked_failure_threshold_exceeded",
+                user_id=user_id,
+                crawl_run_id=int(run.id),
+                blocked_failure_count=alert_summary.blocked_failure_count,
+                threshold=alert_summary.blocked_failure_threshold,
+            )
+        if alert_summary.alert_flags["network_failure_threshold_exceeded"]:
+            structured_log(
+                logger, "warning", "ingestion.alert_network_failure_threshold_exceeded",
+                user_id=user_id,
+                crawl_run_id=int(run.id),
+                network_failure_count=alert_summary.network_failure_count,
+                threshold=alert_summary.network_failure_threshold,
+            )
+        if alert_summary.alert_flags["retry_scheduled_threshold_exceeded"]:
+            structured_log(
+                logger, "warning", "ingestion.alert_retry_scheduled_threshold_exceeded",
+                user_id=user_id,
+                crawl_run_id=int(run.id),
+                retries_scheduled_count=failure_summary.retries_scheduled_count,
+                threshold=alert_summary.retry_scheduled_threshold,
+            )
         self._apply_safety_outcome(user_settings=user_settings, run=run, user_id=user_id, alert_summary=alert_summary)
         self._finalize_run_record(
             run=run,
@@ -1491,10 +1318,14 @@ class ScholarIngestionService:
     ) -> tuple[CrawlRun, list[ScholarProfile], dict[int, int]]:
         effective_delay = self._effective_request_delay_seconds(request_delay_seconds)
         if effective_delay != _int_or_default(request_delay_seconds, effective_delay):
-            self._log_request_delay_coercion(
+            structured_log(
+                logger, "warning", "ingestion.request_delay_coerced_to_policy_floor",
                 user_id=user_id,
                 requested_request_delay_seconds=_int_or_default(request_delay_seconds, 0),
                 effective_request_delay_seconds=effective_delay,
+                policy_minimum_request_delay_seconds=user_settings_service.resolve_request_delay_minimum(
+                    settings.ingestion_min_request_delay_seconds
+                ),
             )
 
         paging_kwargs = self._paging_kwargs(
@@ -1595,7 +1426,21 @@ class ScholarIngestionService:
                 if intended_final_status not in (RunStatus.CANCELED,):
                     run.status = RunStatus.RESOLVING
                 await db_session.commit()
-                self._log_run_completed(user_id=user_id, run=run, scholars=attached_scholars, progress=progress, alert_summary=alert_summary, failure_summary=failure_summary)
+                structured_log(
+                    logger, "info", "ingestion.run_completed",
+                    user_id=user_id,
+                    crawl_run_id=run.id,
+                    status=run.status.value,
+                    scholar_count=len(attached_scholars),
+                    succeeded_count=progress.succeeded_count,
+                    failed_count=progress.failed_count,
+                    partial_count=progress.partial_count,
+                    new_publication_count=run.new_pub_count,
+                    blocked_failure_count=alert_summary.blocked_failure_count,
+                    network_failure_count=alert_summary.network_failure_count,
+                    retries_scheduled_count=failure_summary.retries_scheduled_count,
+                    alert_flags=alert_summary.alert_flags,
+                )
 
                 # Fire-and-forget enrichment in a separate background task
                 if intended_final_status not in (RunStatus.CANCELED,):
@@ -1609,7 +1454,7 @@ class ScholarIngestionService:
                     )
             except Exception as exc:
                 await db_session.rollback()
-                logger.exception("ingestion.background_run_failed", extra={"event": "ingestion.background_run_failed", "run_id": run_id, "user_id": user_id})
+                logger.exception("ingestion.background_run_failed", extra={"run_id": run_id, "user_id": user_id})
                 await self._fail_run_in_background(session_factory, run_id, exc)
 
     async def _prepare_execute_run(
@@ -1782,7 +1627,21 @@ class ScholarIngestionService:
             run.status = intended_final_status
         await db_session.commit()
 
-        self._log_run_completed(user_id=user_id, run=run, scholars=scholars, progress=progress, alert_summary=alert_summary, failure_summary=failure_summary)
+        structured_log(
+            logger, "info", "ingestion.run_completed",
+            user_id=user_id,
+            crawl_run_id=run.id,
+            status=run.status.value,
+            scholar_count=len(scholars),
+            succeeded_count=progress.succeeded_count,
+            failed_count=progress.failed_count,
+            partial_count=progress.partial_count,
+            new_publication_count=run.new_pub_count,
+            blocked_failure_count=alert_summary.blocked_failure_count,
+            network_failure_count=alert_summary.network_failure_count,
+            retries_scheduled_count=failure_summary.retries_scheduled_count,
+            alert_flags=alert_summary.alert_flags,
+        )
         return self._run_execution_summary(run=run, scholars=scholars, progress=progress)
 
     async def _fetch_profile_page(
@@ -1816,7 +1675,6 @@ class ScholarIngestionService:
             logger.exception(
                 "ingestion.fetch_unexpected_error",
                 extra={
-                    "event": "ingestion.fetch_unexpected_error",
                     "scholar_id": scholar_id,
                     "cstart": cstart,
                     "page_size": page_size,
@@ -1833,23 +1691,6 @@ class ScholarIngestionService:
                 error=str(exc),
             )
 
-    @staticmethod
-    def _attempt_log_entry(
-        *,
-        attempt: int,
-        cstart: int,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-    ) -> dict[str, Any]:
-        return {
-            "attempt": attempt,
-            "cstart": cstart,
-            "state": parsed_page.state.value,
-            "state_reason": parsed_page.state_reason,
-            "status_code": fetch_result.status_code,
-            "fetch_error": fetch_result.error,
-        }
-
     @staticmethod
     def _should_retry_page_fetch(
         *,
@@ -1883,16 +1724,13 @@ class ScholarIngestionService:
             sleep_seconds = retry_backoff_seconds * (2 ** (network_attempt_count - 1))
             attempt_label = network_attempt_count
 
-        logger.warning(
-            "ingestion.scholar_retry_scheduled",
-            extra={
-                "event": "ingestion.scholar_retry_scheduled",
-                "scholar_id": scholar_id,
-                "cstart": cstart,
-                "attempt_count": attempt_label,
-                "sleep_seconds": sleep_seconds,
-                "state_reason": state_reason,
-            },
+        structured_log(
+            logger, "warning", "ingestion.scholar_retry_scheduled",
+            scholar_id=scholar_id,
+            cstart=cstart,
+            attempt_count=attempt_label,
+            sleep_seconds=sleep_seconds,
+            state_reason=state_reason,
         )
         if sleep_seconds > 0:
             await asyncio.sleep(sleep_seconds)
@@ -1931,14 +1769,14 @@ class ScholarIngestionService:
             else:
                 total_attempts = network_attempts + rate_limit_attempts + 1
 
-            attempt_log.append(
-                self._attempt_log_entry(
-                    attempt=total_attempts,
-                    cstart=cstart,
-                    fetch_result=fetch_result,
-                    parsed_page=parsed_page,
-                )
-            )
+            attempt_log.append({
+                "attempt": total_attempts,
+                "cstart": cstart,
+                "state": parsed_page.state.value,
+                "state_reason": parsed_page.state_reason,
+                "status_code": fetch_result.status_code,
+                "fetch_error": fetch_result.error,
+            })
 
             if not self._should_retry_page_fetch(
                 parsed_page=parsed_page,
@@ -1995,28 +1833,6 @@ class ScholarIngestionService:
             articles_range=None,
         )
 
-    @staticmethod
-    def _page_log_entry(
-        *,
-        page_number: int,
-        cstart: int,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        attempt_count: int,
-    ) -> dict[str, Any]:
-        return {
-            "page": page_number,
-            "cstart": cstart,
-            "state": parsed_page.state.value,
-            "state_reason": parsed_page.state_reason,
-            "status_code": fetch_result.status_code,
-            "publication_count": len(parsed_page.publications),
-            "articles_range": parsed_page.articles_range,
-            "has_show_more_button": parsed_page.has_show_more_button,
-            "warning_codes": parsed_page.warnings,
-            "attempt_count": attempt_count,
-        }
-
     @staticmethod
     def _should_skip_no_change(
         *,
@@ -2179,15 +1995,18 @@ class ScholarIngestionService:
     ) -> None:
         state.pages_attempted += 1
         state.attempt_log.extend(page_attempt_log)
-        state.page_logs.append(
-            ScholarIngestionService._page_log_entry(
-                page_number=state.pages_attempted,
-                cstart=state.current_cstart,
-                fetch_result=fetch_result,
-                parsed_page=parsed_page,
-                attempt_count=len(page_attempt_log),
-            )
-        )
+        state.page_logs.append({
+            "page": state.pages_attempted,
+            "cstart": state.current_cstart,
+            "state": parsed_page.state.value,
+            "state_reason": parsed_page.state_reason,
+            "status_code": fetch_result.status_code,
+            "publication_count": len(parsed_page.publications),
+            "articles_range": parsed_page.articles_range,
+            "has_show_more_button": parsed_page.has_show_more_button,
+            "warning_codes": parsed_page.warnings,
+            "attempt_count": len(page_attempt_log),
+        })
         state.fetch_result = fetch_result
         state.parsed_page = parsed_page
 
@@ -2233,15 +2052,18 @@ class ScholarIngestionService:
         )
         first_page_fingerprint_sha256 = build_initial_page_fingerprint(parsed_page)
         attempt_log = list(first_attempt_log)
-        page_logs = [
-            self._page_log_entry(
-                page_number=1,
-                cstart=start_cstart,
-                fetch_result=fetch_result,
-                parsed_page=parsed_page,
-                attempt_count=len(first_attempt_log),
-            )
-        ]
+        page_logs = [{
+            "page": 1,
+            "cstart": start_cstart,
+            "state": parsed_page.state.value,
+            "state_reason": parsed_page.state_reason,
+            "status_code": fetch_result.status_code,
+            "publication_count": len(parsed_page.publications),
+            "articles_range": parsed_page.articles_range,
+            "has_show_more_button": parsed_page.has_show_more_button,
+            "warning_codes": parsed_page.warnings,
+            "attempt_count": len(first_attempt_log),
+        }]
         return fetch_result, parsed_page, first_page_fingerprint_sha256, attempt_log, page_logs
 
     async def _paginate_loop(
@@ -2275,9 +2097,9 @@ class ScholarIngestionService:
         while state.parsed_page.has_show_more_button:
             await db_session.refresh(run)
             if run.status == RunStatus.CANCELED:
-                logger.info(
-                    "ingestion.pagination_canceled",
-                    extra={"event": "ingestion.pagination_canceled", "run_id": run.id},
+                structured_log(
+                    logger, "info", "ingestion.pagination_canceled",
+                    run_id=run.id,
                 )
                 self._set_truncated_state(
                     state=state,
@@ -2532,22 +2354,22 @@ class ScholarIngestionService:
                     {"title.search": "|".join(titles)}, limit=batch_size * 3
                 )
             except OpenAlexBudgetExhaustedError:
-                logger.warning(
-                    "ingestion.openalex_budget_exhausted",
-                    extra={"event": "ingestion.openalex_budget_exhausted", "run_id": run_id},
+                structured_log(
+                    logger, "warning", "ingestion.openalex_budget_exhausted",
+                    run_id=run_id,
                 )
                 break  # Stop all enrichment — budget won't reset until midnight UTC
             except OpenAlexRateLimitError:
-                logger.warning(
-                    "ingestion.openalex_rate_limited",
-                    extra={"event": "ingestion.openalex_rate_limited", "run_id": run_id},
+                structured_log(
+                    logger, "warning", "ingestion.openalex_rate_limited",
+                    run_id=run_id,
                 )
                 await asyncio.sleep(60)
                 continue
             except Exception as e:
-                logger.warning(
-                    "ingestion.openalex_enrichment_failed",
-                    extra={"event": "ingestion.openalex_enrichment_failed", "error": str(e), "run_id": run_id},
+                structured_log(
+                    logger, "warning", "ingestion.openalex_enrichment_failed",
+                    error=str(e), run_id=run_id,
                 )
                 continue
 
@@ -2583,13 +2405,10 @@ class ScholarIngestionService:
 
         merge_count = await sweep_identifier_duplicates(db_session)
         if merge_count:
-            logger.info(
-                "ingestion.identifier_dedup_sweep",
-                extra={
-                    "event": "ingestion.identifier_dedup_sweep",
-                    "merged_count": merge_count,
-                    "run_id": run_id,
-                },
+            structured_log(
+                logger, "info", "ingestion.identifier_dedup_sweep",
+                merged_count=merge_count,
+                run_id=run_id,
             )
 
     async def _discover_identifiers_for_enrichment(
@@ -2624,14 +2443,11 @@ class ScholarIngestionService:
             )
             return True
         except ArxivRateLimitError:
-            logger.warning(
-                "ingestion.arxiv_rate_limited",
-                extra={
-                    "event": "ingestion.arxiv_rate_limited",
-                    "run_id": run_id,
-                    "publication_id": int(publication.id),
-                    "detail": "arXiv temporarily disabled for remaining enrichment pass",
-                },
+            structured_log(
+                logger, "warning", "ingestion.arxiv_rate_limited",
+                run_id=run_id,
+                publication_id=int(publication.id),
+                detail="arXiv temporarily disabled for remaining enrichment pass",
             )
             await identifier_service.sync_identifiers_for_publication_fields(
                 db_session,
@@ -2780,14 +2596,11 @@ class ScholarIngestionService:
             db_session.add(link)
             discovered_count += 1
 
-            logger.debug(
-                "ingestion.publication_discovered",
-                extra={
-                    "event": "ingestion.publication_discovered",
-                    "scholar_profile_id": scholar.id,
-                    "publication_id": publication.id,
-                    "crawl_run_id": run.id,
-                },
+            structured_log(
+                logger, "debug", "ingestion.publication_discovered",
+                scholar_profile_id=scholar.id,
+                publication_id=publication.id,
+                crawl_run_id=run.id,
             )
             
             await self._commit_discovered_publication(
@@ -2907,13 +2720,10 @@ class ScholarIngestionService:
         )
         db_session.add(publication)
         await db_session.flush()
-        logger.debug(
-            "ingestion.publication_created",
-            extra={
-                "event": "ingestion.publication_created",
-                "publication_id": publication.id,
-                "cluster_id": publication.cluster_id,
-            },
+        structured_log(
+            logger, "debug", "ingestion.publication_created",
+            publication_id=publication.id,
+            cluster_id=publication.cluster_id,
         )
         return publication
 
-- 
2.49.1


From db0ac6a228ca6a3e9b10bd6eb691f048ccde15b7 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Thu, 26 Feb 2026 21:59:34 +0100
Subject: [PATCH 08/38] refactor: migrate all remaining logging to
 structured_log, remove boilerplate helpers

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/api/routers/admin.py                      |  39 +--
 app/api/routers/admin_dbops.py                | 107 ++-------
 app/api/routers/auth.py                       |  40 +--
 app/api/routers/publications.py               |  61 +----
 app/api/routers/runs.py                       |  56 ++---
 app/api/routers/scholars.py                   | 141 +++--------
 app/api/routers/settings.py                   |  41 ++--
 app/auth/runtime.py                           |   9 +-
 app/db/session.py                             |  25 +-
 app/http/middleware.py                        |  28 +--
 app/main.py                                   |  24 +-
 app/security/csrf.py                          |  23 +-
 app/services/domains/arxiv/client.py          |  47 +---
 app/services/domains/arxiv/gateway.py         |   5 +-
 app/services/domains/arxiv/rate_limit.py      |  77 +-----
 app/services/domains/crossref/application.py  |   3 +-
 app/services/domains/ingestion/scheduler.py   | 227 +++++++-----------
 app/services/domains/openalex/client.py       |   4 +-
 app/services/domains/publications/dedup.py    |  10 +-
 .../domains/publications/enrichment.py        |  20 +-
 .../domains/publications/pdf_queue.py         |  29 +--
 .../publications/pdf_resolution_pipeline.py   |  33 +--
 app/services/domains/scholar/source.py        |  66 ++---
 app/services/domains/scholars/application.py  | 102 ++++----
 app/services/domains/unpaywall/application.py |  41 +---
 .../services/domains/arxiv/test_client.py     |   8 +-
 .../services/domains/arxiv/test_rate_limit.py |   8 +-
 27 files changed, 361 insertions(+), 913 deletions(-)

diff --git a/app/api/routers/admin.py b/app/api/routers/admin.py
index 9844c3e..b1f99b8 100644
--- a/app/api/routers/admin.py
+++ b/app/api/routers/admin.py
@@ -20,6 +20,7 @@ from app.auth.deps import get_auth_service
 from app.auth.service import AuthService
 from app.db.models import User
 from app.db.session import get_db_session
+from app.logging_utils import structured_log
 from app.services.domains.users import application as user_service
 
 logger = logging.getLogger(__name__)
@@ -48,14 +49,7 @@ async def list_users(
     admin_user: User = Depends(get_api_admin_user),
 ):
     users = await user_service.list_users(db_session)
-    logger.info(
-        "api.admin.users_listed",
-        extra={
-            "event": "api.admin.users_listed",
-            "admin_user_id": int(admin_user.id),
-            "user_count": len(users),
-        },
-    )
+    structured_log(logger, "info", "api.admin.users_listed", admin_user_id=int(admin_user.id), user_count=len(users))
     return success_payload(
         request,
         data={
@@ -92,15 +86,7 @@ async def create_user(
             message=str(exc),
         ) from exc
 
-    logger.info(
-        "api.admin.user_created",
-        extra={
-            "event": "api.admin.user_created",
-            "admin_user_id": int(admin_user.id),
-            "target_user_id": int(created_user.id),
-            "target_is_admin": bool(created_user.is_admin),
-        },
-    )
+    structured_log(logger, "info", "api.admin.user_created", admin_user_id=int(admin_user.id), target_user_id=int(created_user.id), target_is_admin=bool(created_user.is_admin))
     return success_payload(
         request,
         data=_serialize_user(created_user),
@@ -140,15 +126,7 @@ async def set_user_active(
         user=target_user,
         is_active=bool(payload.is_active),
     )
-    logger.info(
-        "api.admin.user_active_updated",
-        extra={
-            "event": "api.admin.user_active_updated",
-            "admin_user_id": int(admin_user.id),
-            "target_user_id": int(updated_user.id),
-            "is_active": bool(updated_user.is_active),
-        },
-    )
+    structured_log(logger, "info", "api.admin.user_active_updated", admin_user_id=int(admin_user.id), target_user_id=int(updated_user.id), is_active=bool(updated_user.is_active))
     return success_payload(
         request,
         data=_serialize_user(updated_user),
@@ -188,14 +166,7 @@ async def reset_user_password(
         user=target_user,
         password_hash=auth_service.hash_password(validated_password),
     )
-    logger.info(
-        "api.admin.user_password_reset",
-        extra={
-            "event": "api.admin.user_password_reset",
-            "admin_user_id": int(admin_user.id),
-            "target_user_id": int(target_user.id),
-        },
-    )
+    structured_log(logger, "info", "api.admin.user_password_reset", admin_user_id=int(admin_user.id), target_user_id=int(target_user.id))
     return success_payload(
         request,
         data={"message": f"Password reset: {target_user.email}"},
diff --git a/app/api/routers/admin_dbops.py b/app/api/routers/admin_dbops.py
index be23092..8230ab9 100644
--- a/app/api/routers/admin_dbops.py
+++ b/app/api/routers/admin_dbops.py
@@ -21,6 +21,7 @@ from app.api.schemas import (
 )
 from app.db.models import DataRepairJob, User
 from app.db.session import get_db_session
+from app.logging_utils import structured_log
 from app.services.domains.dbops import (
     collect_integrity_report,
     list_repair_jobs,
@@ -135,16 +136,7 @@ async def get_integrity_report(
     admin_user: User = Depends(get_api_admin_user),
 ):
     report = await collect_integrity_report(db_session)
-    logger.info(
-        "api.admin.db.integrity_checked",
-        extra={
-            "event": "api.admin.db.integrity_checked",
-            "admin_user_id": int(admin_user.id),
-            "status": report.get("status"),
-            "failure_count": len(report.get("failures", [])),
-            "warning_count": len(report.get("warnings", [])),
-        },
-    )
+    structured_log(logger, "info", "api.admin.db.integrity_checked", admin_user_id=int(admin_user.id), status=report.get("status"), failure_count=len(report.get("failures", [])), warning_count=len(report.get("warnings", [])))
     return success_payload(request, data=report)
 
 
@@ -159,15 +151,7 @@ async def get_repair_jobs(
     admin_user: User = Depends(get_api_admin_user),
 ):
     jobs = await list_repair_jobs(db_session, limit=limit)
-    logger.info(
-        "api.admin.db.repair_jobs_listed",
-        extra={
-            "event": "api.admin.db.repair_jobs_listed",
-            "admin_user_id": int(admin_user.id),
-            "limit": int(limit),
-            "job_count": len(jobs),
-        },
-    )
+    structured_log(logger, "info", "api.admin.db.repair_jobs_listed", admin_user_id=int(admin_user.id), limit=int(limit), job_count=len(jobs))
     return success_payload(
         request,
         data={"jobs": [_serialize_repair_job(job) for job in jobs]},
@@ -201,18 +185,15 @@ async def get_pdf_queue(
         offset=resolved_offset,
         status=normalized_status,
     )
-    logger.info(
-        "api.admin.db.pdf_queue_listed",
-        extra={
-            "event": "api.admin.db.pdf_queue_listed",
-            "admin_user_id": int(admin_user.id),
-            "page": int(resolved_page),
-            "page_size": int(resolved_limit),
-            "offset": int(resolved_offset),
-            "status": normalized_status,
-            "item_count": len(queue_page.items),
-            "total_count": int(queue_page.total_count),
-        },
+    structured_log(
+        logger, "info", "api.admin.db.pdf_queue_listed",
+        admin_user_id=int(admin_user.id),
+        page=int(resolved_page),
+        page_size=int(resolved_limit),
+        offset=int(resolved_offset),
+        status=normalized_status,
+        item_count=len(queue_page.items),
+        total_count=int(queue_page.total_count),
     )
     return success_payload(
         request,
@@ -251,15 +232,7 @@ async def requeue_pdf_lookup(
             message="Publication not found.",
         )
     status, message = _requeue_response_state(queued=result.queued)
-    logger.info(
-        "api.admin.db.pdf_queue_requeue_requested",
-        extra={
-            "event": "api.admin.db.pdf_queue_requeue_requested",
-            "admin_user_id": int(admin_user.id),
-            "publication_id": int(publication_id),
-            "queued": bool(result.queued),
-        },
-    )
+    structured_log(logger, "info", "api.admin.db.pdf_queue_requeue_requested", admin_user_id=int(admin_user.id), publication_id=int(publication_id), queued=bool(result.queued))
     return success_payload(
         request,
         data={
@@ -287,16 +260,7 @@ async def requeue_all_missing_pdfs(
         request_email=admin_user.email,
         limit=limit,
     )
-    logger.info(
-        "api.admin.db.pdf_queue_requeue_all",
-        extra={
-            "event": "api.admin.db.pdf_queue_requeue_all",
-            "admin_user_id": int(admin_user.id),
-            "limit": int(limit),
-            "requested_count": int(result.requested_count),
-            "queued_count": int(result.queued_count),
-        },
-    )
+    structured_log(logger, "info", "api.admin.db.pdf_queue_requeue_all", admin_user_id=int(admin_user.id), limit=int(limit), requested_count=int(result.requested_count), queued_count=int(result.queued_count))
     return success_payload(
         request,
         data={
@@ -336,18 +300,15 @@ async def trigger_publication_link_repair(
             code="invalid_repair_scope",
             message=str(exc),
         ) from exc
-    logger.info(
-        "api.admin.db.publication_link_repair_triggered",
-        extra={
-            "event": "api.admin.db.publication_link_repair_triggered",
-            "admin_user_id": int(admin_user.id),
-            "scope_mode": payload.scope_mode,
-            "target_user_id": int(payload.user_id) if payload.user_id is not None else None,
-            "dry_run": bool(payload.dry_run),
-            "gc_orphan_publications": bool(payload.gc_orphan_publications),
-            "job_id": int(result["job_id"]),
-            "status": result["status"],
-        },
+    structured_log(
+        logger, "info", "api.admin.db.publication_link_repair_triggered",
+        admin_user_id=int(admin_user.id),
+        scope_mode=payload.scope_mode,
+        target_user_id=int(payload.user_id) if payload.user_id is not None else None,
+        dry_run=bool(payload.dry_run),
+        gc_orphan_publications=bool(payload.gc_orphan_publications),
+        job_id=int(result["job_id"]),
+        status=result["status"],
     )
     return success_payload(request, data=result)
 
@@ -379,17 +340,7 @@ async def trigger_publication_near_duplicate_repair(
             code="invalid_near_duplicate_repair_request",
             message=str(exc),
         ) from exc
-    logger.info(
-        "api.admin.db.publication_near_duplicate_repair_triggered",
-        extra={
-            "event": "api.admin.db.publication_near_duplicate_repair_triggered",
-            "admin_user_id": int(admin_user.id),
-            "dry_run": bool(payload.dry_run),
-            "selected_cluster_count": len(payload.selected_cluster_keys),
-            "job_id": int(result["job_id"]),
-            "status": result["status"],
-        },
-    )
+    structured_log(logger, "info", "api.admin.db.publication_near_duplicate_repair_triggered", admin_user_id=int(admin_user.id), dry_run=bool(payload.dry_run), selected_cluster_count=len(payload.selected_cluster_keys), job_id=int(result["job_id"]), status=result["status"])
     return success_payload(request, data=result)
 
 
@@ -435,15 +386,7 @@ async def drop_all_publications(
     )
     await db_session.commit()
 
-    logger.warning(
-        "api.admin.db.all_publications_dropped",
-        extra={
-            "event": "api.admin.db.all_publications_dropped",
-            "admin_user_id": int(admin_user.id),
-            "admin_email": admin_user.email,
-            "deleted_count": int(total_publications),
-        },
-    )
+    structured_log(logger, "warning", "api.admin.db.all_publications_dropped", admin_user_id=int(admin_user.id), admin_email=admin_user.email, deleted_count=int(total_publications))
     return success_payload(
         request,
         data={
diff --git a/app/api/routers/auth.py b/app/api/routers/auth.py
index 8f8da17..3faffa6 100644
--- a/app/api/routers/auth.py
+++ b/app/api/routers/auth.py
@@ -17,6 +17,7 @@ from app.api.schemas import (
     MessageEnvelope,
 )
 from app.auth.deps import get_auth_service, get_login_rate_limiter
+from app.logging_utils import structured_log
 from app.auth.rate_limit import SlidingWindowRateLimiter
 from app.auth import runtime as auth_runtime
 from app.auth.service import AuthService
@@ -36,14 +37,7 @@ def _login_limiter_key_and_email(request: Request, payload: LoginRequest) -> tup
 
 
 def _raise_rate_limited(normalized_email: str, retry_after_seconds: int) -> None:
-    logger.warning(
-        "api.auth.login_rate_limited",
-        extra={
-            "event": "api.auth.login_rate_limited",
-            "email": normalized_email,
-            "retry_after_seconds": retry_after_seconds,
-        },
-    )
+    structured_log(logger, "warning", "api.auth.login_rate_limited", email=normalized_email, retry_after_seconds=retry_after_seconds)
     raise ApiException(
         status_code=429,
         code="rate_limited",
@@ -62,10 +56,7 @@ def _serialize_user_payload(user: User) -> dict[str, object]:
 
 
 def _raise_invalid_credentials(*, normalized_email: str) -> None:
-    logger.info(
-        "api.auth.login_failed",
-        extra={"event": "api.auth.login_failed", "email": normalized_email},
-    )
+    structured_log(logger, "info", "api.auth.login_failed", email=normalized_email)
     raise ApiException(
         status_code=401,
         code="invalid_credentials",
@@ -105,14 +96,7 @@ async def login(
         email=user.email,
         is_admin=user.is_admin,
     )
-    logger.info(
-        "api.auth.login_succeeded",
-        extra={
-            "event": "api.auth.login_succeeded",
-            "user_id": user.id,
-            "is_admin": user.is_admin,
-        },
-    )
+    structured_log(logger, "info", "api.auth.login_succeeded", user_id=user.id, is_admin=user.is_admin)
     return success_payload(
         request,
         data={
@@ -199,13 +183,7 @@ async def change_password(
         user=current_user,
         password_hash=auth_service.hash_password(validated_password),
     )
-    logger.info(
-        "api.auth.password_changed",
-        extra={
-            "event": "api.auth.password_changed",
-            "user_id": int(current_user.id),
-        },
-    )
+    structured_log(logger, "info", "api.auth.password_changed", user_id=int(current_user.id))
     return success_payload(
         request,
         data={"message": "Password updated successfully."},
@@ -222,13 +200,7 @@ async def logout(
 ):
     current_user = await auth_runtime.get_authenticated_user(request, db_session)
     auth_runtime.invalidate_session(request)
-    logger.info(
-        "api.auth.logout",
-        extra={
-            "event": "api.auth.logout",
-            "user_id": int(current_user.id) if current_user is not None else None,
-        },
-    )
+    structured_log(logger, "info", "api.auth.logout", user_id=int(current_user.id) if current_user is not None else None)
     return success_payload(
         request,
         data={
diff --git a/app/api/routers/publications.py b/app/api/routers/publications.py
index 7de2f12..7048d6b 100644
--- a/app/api/routers/publications.py
+++ b/app/api/routers/publications.py
@@ -22,6 +22,7 @@ from app.api.schemas import (
 )
 from app.db.models import User
 from app.db.session import get_db_session
+from app.logging_utils import structured_log
 from app.services.domains.publication_identifiers import application as identifier_service
 from app.services.domains.publications import application as publication_service
 from app.services.domains.scholars import application as scholar_service
@@ -340,30 +341,6 @@ async def _favorite_publication_state(
     return identifiers[0] if identifiers else current
 
 
-def _log_retry_pdf_result(
-    *,
-    current_user: User,
-    scholar_profile_id: int,
-    publication_id: int,
-    queued: bool,
-    resolved_pdf: bool,
-    pdf_status: str,
-    doi: str | None,
-) -> None:
-    logger.info(
-        "api.publications.retry_pdf",
-        extra={
-            "event": "api.publications.retry_pdf",
-            "user_id": current_user.id,
-            "scholar_profile_id": scholar_profile_id,
-            "publication_id": publication_id,
-            "queued": queued,
-            "resolved_pdf": resolved_pdf,
-            "pdf_status": pdf_status,
-        },
-    )
-
-
 @router.get(
     "",
     response_model=PublicationsListEnvelope,
@@ -443,14 +420,7 @@ async def mark_all_publications_read(
         db_session,
         user_id=current_user.id,
     )
-    logger.info(
-        "api.publications.mark_all_read",
-        extra={
-            "event": "api.publications.mark_all_read",
-            "user_id": current_user.id,
-            "updated_count": updated_count,
-        },
-    )
+    structured_log(logger, "info", "api.publications.mark_all_read", user_id=current_user.id, updated_count=updated_count)
     return success_payload(
         request,
         data={
@@ -481,15 +451,7 @@ async def mark_selected_publications_read(
         user_id=current_user.id,
         selections=selection_pairs,
     )
-    logger.info(
-        "api.publications.mark_selected_read",
-        extra={
-            "event": "api.publications.mark_selected_read",
-            "user_id": current_user.id,
-            "requested_count": len(selection_pairs),
-            "updated_count": updated_count,
-        },
-    )
+    structured_log(logger, "info", "api.publications.mark_selected_read", user_id=current_user.id, requested_count=len(selection_pairs), updated_count=updated_count)
     return success_payload(
         request,
         data={
@@ -523,14 +485,14 @@ async def retry_publication_pdf(
         resolved_pdf=resolved_pdf,
         pdf_status=current.pdf_status,
     )
-    _log_retry_pdf_result(
-        current_user=current_user,
+    structured_log(
+        logger, "info", "api.publications.retry_pdf",
+        user_id=current_user.id,
         scholar_profile_id=payload.scholar_profile_id,
         publication_id=publication_id,
         queued=queued,
         resolved_pdf=resolved_pdf,
         pdf_status=current.pdf_status,
-        doi=None,
     )
     return success_payload(
         request,
@@ -561,16 +523,7 @@ async def toggle_publication_favorite(
         publication_id=publication_id,
         is_favorite=payload.is_favorite,
     )
-    logger.info(
-        "api.publications.favorite",
-        extra={
-            "event": "api.publications.favorite",
-            "user_id": current_user.id,
-            "scholar_profile_id": payload.scholar_profile_id,
-            "publication_id": publication_id,
-            "is_favorite": bool(payload.is_favorite),
-        },
-    )
+    structured_log(logger, "info", "api.publications.favorite", user_id=current_user.id, scholar_profile_id=payload.scholar_profile_id, publication_id=publication_id, is_favorite=bool(payload.is_favorite))
     return success_payload(
         request,
         data={
diff --git a/app/api/routers/runs.py b/app/api/routers/runs.py
index b03a45d..f6e6644 100644
--- a/app/api/routers/runs.py
+++ b/app/api/routers/runs.py
@@ -22,6 +22,7 @@ from app.api.schemas import (
 )
 from app.db.models import RunStatus, RunTriggerType, User
 from app.db.session import get_db_session
+from app.logging_utils import structured_log
 from app.services.domains.ingestion import application as ingestion_service
 from app.services.domains.ingestion import safety as run_safety_service
 from app.services.domains.runs import application as run_service
@@ -287,31 +288,21 @@ async def _load_safety_state(
     if run_safety_service.clear_expired_cooldown(user_settings):
         await db_session.commit()
         await db_session.refresh(user_settings)
-        logger.info(
-            "api.runs.safety_cooldown_cleared",
-            extra={
-                "event": "api.runs.safety_cooldown_cleared",
-                "user_id": user_id,
-                "reason": previous_safety_state.get("cooldown_reason"),
-                "cooldown_until": previous_safety_state.get("cooldown_until"),
-                "metric_name": "api_runs_safety_cooldown_cleared_total",
-                "metric_value": 1,
-            },
-    )
+        structured_log(
+            logger, "info", "api.runs.safety_cooldown_cleared",
+            user_id=user_id,
+            reason=previous_safety_state.get("cooldown_reason"),
+            cooldown_until=previous_safety_state.get("cooldown_until"),
+        )
     return run_safety_service.get_safety_state_payload(user_settings)
 
 
 def _raise_manual_runs_disabled(*, user_id: int, safety_state: dict[str, Any]) -> None:
-    logger.warning(
-        "api.runs.manual_blocked_policy",
-        extra={
-            "event": "api.runs.manual_blocked_policy",
-            "user_id": user_id,
-            "policy": {"manual_run_allowed": False},
-            "safety_state": safety_state,
-            "metric_name": "api_runs_manual_blocked_policy_total",
-            "metric_value": 1,
-        },
+    structured_log(
+        logger, "warning", "api.runs.manual_blocked_policy",
+        user_id=user_id,
+        policy={"manual_run_allowed": False},
+        safety_state=safety_state,
     )
     raise ApiException(
         status_code=403,
@@ -399,7 +390,7 @@ async def _recover_integrity_error(
     if idempotency_key is None:
         logger.exception(
             "api.runs.manual_integrity_error",
-            extra={"event": "api.runs.manual_integrity_error", "user_id": user_id},
+            extra={"user_id": user_id},
         )
         raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
     existing_run = await run_service.get_manual_run_by_idempotency_key(
@@ -410,7 +401,7 @@ async def _recover_integrity_error(
     if existing_run is None:
         logger.exception(
             "api.runs.manual_integrity_error",
-            extra={"event": "api.runs.manual_integrity_error", "user_id": user_id},
+            extra={"user_id": user_id},
         )
         raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
     if existing_run.status in (RunStatus.RUNNING, RunStatus.RESOLVING):
@@ -471,17 +462,12 @@ async def _execute_manual_run(
 
 
 def _raise_manual_blocked_safety(*, exc, user_id: int) -> None:
-    logger.info(
-        "api.runs.manual_blocked_safety",
-        extra={
-            "event": "api.runs.manual_blocked_safety",
-            "user_id": user_id,
-            "reason": exc.safety_state.get("cooldown_reason"),
-            "cooldown_until": exc.safety_state.get("cooldown_until"),
-            "cooldown_remaining_seconds": exc.safety_state.get("cooldown_remaining_seconds"),
-            "metric_name": "api_runs_manual_blocked_safety_total",
-            "metric_value": 1,
-        },
+    structured_log(
+        logger, "info", "api.runs.manual_blocked_safety",
+        user_id=user_id,
+        reason=exc.safety_state.get("cooldown_reason"),
+        cooldown_until=exc.safety_state.get("cooldown_until"),
+        cooldown_remaining_seconds=exc.safety_state.get("cooldown_remaining_seconds"),
     )
     raise ApiException(
         status_code=429,
@@ -494,7 +480,7 @@ def _raise_manual_blocked_safety(*, exc, user_id: int) -> None:
 def _raise_manual_failed(*, exc: Exception, user_id: int) -> None:
     logger.exception(
         "api.runs.manual_failed",
-        extra={"event": "api.runs.manual_failed", "user_id": user_id},
+        extra={"user_id": user_id},
     )
     raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from exc
 
diff --git a/app/api/routers/scholars.py b/app/api/routers/scholars.py
index 2dc0e2f..f0784fe 100644
--- a/app/api/routers/scholars.py
+++ b/app/api/routers/scholars.py
@@ -23,6 +23,7 @@ from app.api.schemas import (
 )
 from app.db.models import User
 from app.db.session import get_db_session
+from app.logging_utils import structured_log
 from app.services.domains.ingestion import queue as ingestion_queue_service
 from app.services.domains.portability import application as import_export_service
 from app.services.domains.scholar import rate_limit as scholar_rate_limit
@@ -80,24 +81,18 @@ async def _enqueue_initial_scrape_job_for_scholar(
         await db_session.commit()
     except Exception:
         await db_session.rollback()
-        logger.warning(
-            "api.scholars.initial_scrape_enqueue_failed",
-            extra={
-                "event": "api.scholars.initial_scrape_enqueue_failed",
-                "user_id": user_id,
-                "scholar_profile_id": profile.id,
-            },
+        structured_log(
+            logger, "warning", "api.scholars.initial_scrape_enqueue_failed",
+            user_id=user_id,
+            scholar_profile_id=profile.id,
         )
         return False
 
-    logger.info(
-        "api.scholars.initial_scrape_enqueued",
-        extra={
-            "event": "api.scholars.initial_scrape_enqueued",
-            "user_id": user_id,
-            "scholar_profile_id": profile.id,
-            "reason": INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON,
-        },
+    structured_log(
+        logger, "info", "api.scholars.initial_scrape_enqueued",
+        user_id=user_id,
+        scholar_profile_id=profile.id,
+        reason=INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON,
     )
     return True
 
@@ -143,15 +138,12 @@ async def _hydrate_scholar_metadata_if_needed(
 
     should_skip, remaining_seconds = _is_create_hydration_rate_limited()
     if should_skip:
-        logger.info(
-            "api.scholars.create_metadata_hydration_skipped",
-            extra={
-                "event": "api.scholars.create_metadata_hydration_skipped",
-                "reason": "scholar_request_throttle_active",
-                "user_id": user_id,
-                "scholar_profile_id": profile.id,
-                "retry_after_seconds": round(remaining_seconds, 3),
-            },
+        structured_log(
+            logger, "info", "api.scholars.create_metadata_hydration_skipped",
+            reason="scholar_request_throttle_active",
+            user_id=user_id,
+            scholar_profile_id=profile.id,
+            retry_after_seconds=round(remaining_seconds, 3),
         )
         return profile
 
@@ -165,23 +157,17 @@ async def _hydrate_scholar_metadata_if_needed(
             timeout=CREATE_METADATA_HYDRATION_TIMEOUT_SECONDS,
         )
     except TimeoutError:
-        logger.info(
-            "api.scholars.create_metadata_hydration_skipped",
-            extra={
-                "event": "api.scholars.create_metadata_hydration_skipped",
-                "reason": "create_timeout",
-                "user_id": user_id,
-                "scholar_profile_id": profile.id,
-            },
+        structured_log(
+            logger, "info", "api.scholars.create_metadata_hydration_skipped",
+            reason="create_timeout",
+            user_id=user_id,
+            scholar_profile_id=profile.id,
         )
     except Exception:
-        logger.warning(
-            "api.scholars.create_metadata_hydration_failed",
-            extra={
-                "event": "api.scholars.create_metadata_hydration_failed",
-                "user_id": user_id,
-                "scholar_profile_id": profile.id,
-            },
+        structured_log(
+            logger, "warning", "api.scholars.create_metadata_hydration_failed",
+            user_id=user_id,
+            scholar_profile_id=profile.id,
         )
     return profile
 
@@ -330,14 +316,7 @@ async def import_scholars_and_publications(
             code="invalid_import_payload",
             message=str(exc),
         ) from exc
-    logger.info(
-        "api.scholars.imported",
-        extra={
-            "event": "api.scholars.imported",
-            "user_id": current_user.id,
-            **result,
-        },
-    )
+    structured_log(logger, "info", "api.scholars.imported", user_id=current_user.id, **result)
     return success_payload(request, data=result)
 
 
@@ -367,14 +346,7 @@ async def create_scholar(
             code="invalid_scholar",
             message=str(exc),
         ) from exc
-    logger.info(
-        "api.scholars.created",
-        extra={
-            "event": "api.scholars.created",
-            "user_id": current_user.id,
-            "scholar_profile_id": created.id,
-        },
-    )
+    structured_log(logger, "info", "api.scholars.created", user_id=current_user.id, scholar_profile_id=created.id)
     did_queue_initial_scrape = await _enqueue_initial_scrape_job_for_scholar(
         db_session,
         profile=created,
@@ -421,16 +393,7 @@ async def search_scholars(
             message=str(exc),
         ) from exc
 
-    logger.info(
-        "api.scholars.search.completed",
-        extra={
-            "event": "api.scholars.search.completed",
-            "user_id": current_user.id,
-            "query": query.strip(),
-            "candidate_count": len(parsed.candidates),
-            "state": parsed.state.value,
-        },
-    )
+    structured_log(logger, "info", "api.scholars.search.completed", user_id=current_user.id, query=query.strip(), candidate_count=len(parsed.candidates), state=parsed.state.value)
     return success_payload(
         request,
         data=_search_response_data(query, parsed),
@@ -459,15 +422,7 @@ async def toggle_scholar(
             message="Scholar not found.",
         )
     updated = await scholar_service.toggle_scholar_enabled(db_session, profile=profile)
-    logger.info(
-        "api.scholars.toggled",
-        extra={
-            "event": "api.scholars.toggled",
-            "user_id": current_user.id,
-            "scholar_profile_id": updated.id,
-            "is_enabled": updated.is_enabled,
-        },
-    )
+    structured_log(logger, "info", "api.scholars.toggled", user_id=current_user.id, scholar_profile_id=updated.id, is_enabled=updated.is_enabled)
     return success_payload(
         request,
         data=_serialize_scholar(updated),
@@ -500,14 +455,7 @@ async def delete_scholar(
         profile=profile,
         upload_dir=settings.scholar_image_upload_dir,
     )
-    logger.info(
-        "api.scholars.deleted",
-        extra={
-            "event": "api.scholars.deleted",
-            "user_id": current_user.id,
-            "scholar_profile_id": scholar_profile_id,
-        },
-    )
+    structured_log(logger, "info", "api.scholars.deleted", user_id=current_user.id, scholar_profile_id=scholar_profile_id)
     return success_payload(
         request,
         data={"message": "Scholar deleted."},
@@ -551,14 +499,7 @@ async def update_scholar_image_url(
             message=str(exc),
         ) from exc
 
-    logger.info(
-        "api.scholars.image_url_updated",
-        extra={
-            "event": "api.scholars.image_url_updated",
-            "user_id": current_user.id,
-            "scholar_profile_id": updated.id,
-        },
-    )
+    structured_log(logger, "info", "api.scholars.image_url_updated", user_id=current_user.id, scholar_profile_id=updated.id)
     return success_payload(
         request,
         data=_serialize_scholar(updated),
@@ -600,16 +541,7 @@ async def upload_scholar_image(
         ) from exc
 
     image_size = len(image_bytes)
-    logger.info(
-        "api.scholars.image_uploaded",
-        extra={
-            "event": "api.scholars.image_uploaded",
-            "user_id": current_user.id,
-            "scholar_profile_id": updated.id,
-            "content_type": image.content_type,
-            "size_bytes": image_size,
-        },
-    )
+    structured_log(logger, "info", "api.scholars.image_uploaded", user_id=current_user.id, scholar_profile_id=updated.id, content_type=image.content_type, size_bytes=image_size)
     return success_payload(
         request,
         data=_serialize_scholar(updated),
@@ -643,14 +575,7 @@ async def clear_scholar_image_customization(
         profile=profile,
         upload_dir=settings.scholar_image_upload_dir,
     )
-    logger.info(
-        "api.scholars.image_customization_cleared",
-        extra={
-            "event": "api.scholars.image_customization_cleared",
-            "user_id": current_user.id,
-            "scholar_profile_id": updated.id,
-        },
-    )
+    structured_log(logger, "info", "api.scholars.image_customization_cleared", user_id=current_user.id, scholar_profile_id=updated.id)
     return success_payload(
         request,
         data=_serialize_scholar(updated),
diff --git a/app/api/routers/settings.py b/app/api/routers/settings.py
index 5a2ef91..e0c3f26 100644
--- a/app/api/routers/settings.py
+++ b/app/api/routers/settings.py
@@ -11,6 +11,7 @@ from app.api.responses import success_payload
 from app.api.schemas import SettingsEnvelope, SettingsUpdateRequest
 from app.db.models import User
 from app.db.session import get_db_session
+from app.logging_utils import structured_log
 from app.services.domains.ingestion import safety as run_safety_service
 from app.services.domains.settings import application as user_settings_service
 from app.settings import settings as settings_module
@@ -83,16 +84,11 @@ async def _clear_expired_cooldown_with_log(
         return
     await db_session.commit()
     await db_session.refresh(user_settings)
-    logger.info(
-        "api.settings.safety_cooldown_cleared",
-        extra={
-            "event": "api.settings.safety_cooldown_cleared",
-            "user_id": user_id,
-            "reason": previous_safety_state.get("cooldown_reason"),
-            "cooldown_until": previous_safety_state.get("cooldown_until"),
-            "metric_name": "api_settings_safety_cooldown_cleared_total",
-            "metric_value": 1,
-        },
+    structured_log(
+        logger, "info", "api.settings.safety_cooldown_cleared",
+        user_id=user_id,
+        reason=previous_safety_state.get("cooldown_reason"),
+        cooldown_until=previous_safety_state.get("cooldown_until"),
     )
 
 
@@ -100,21 +96,6 @@ def _effective_auto_run_enabled(payload: SettingsUpdateRequest) -> bool:
     return bool(payload.auto_run_enabled) and settings_module.ingestion_automation_allowed
 
 
-def _log_settings_update(*, user_id: int, updated) -> None:
-    logger.info(
-        "api.settings.updated",
-        extra={
-            "event": "api.settings.updated",
-            "user_id": user_id,
-            "auto_run_enabled": updated.auto_run_enabled,
-            "run_interval_minutes": updated.run_interval_minutes,
-            "request_delay_seconds": updated.request_delay_seconds,
-            "nav_visible_pages": updated.nav_visible_pages,
-            "openalex_api_key": "SET" if updated.openalex_api_key else "UNSET",
-        },
-    )
-
-
 @router.get(
     "",
     response_model=SettingsEnvelope,
@@ -182,7 +163,15 @@ async def update_settings(
         user_id=current_user.id,
         user_settings=updated,
     )
-    _log_settings_update(user_id=current_user.id, updated=updated)
+    structured_log(
+        logger, "info", "api.settings.updated",
+        user_id=current_user.id,
+        auto_run_enabled=updated.auto_run_enabled,
+        run_interval_minutes=updated.run_interval_minutes,
+        request_delay_seconds=updated.request_delay_seconds,
+        nav_visible_pages=updated.nav_visible_pages,
+        openalex_api_key="SET" if updated.openalex_api_key else "UNSET",
+    )
     return success_payload(
         request,
         data=_serialize_settings(updated),
diff --git a/app/auth/runtime.py b/app/auth/runtime.py
index 777e799..c379cd3 100644
--- a/app/auth/runtime.py
+++ b/app/auth/runtime.py
@@ -6,6 +6,7 @@ from fastapi import Request
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.auth.session import clear_session_user, get_session_user, set_session_user
+from app.logging_utils import structured_log
 from app.db.models import User
 from app.security.csrf import CSRF_SESSION_KEY
 from app.services.domains.users import application as user_service
@@ -28,13 +29,7 @@ async def get_authenticated_user(
 
     user = await user_service.get_user_by_id(db_session, session_user.id)
     if user is None or not user.is_active:
-        logger.info(
-            "auth.session_invalidated",
-            extra={
-                "event": "auth.session_invalidated",
-                "session_user_id": session_user.id,
-            },
-        )
+        structured_log(logger, "info", "auth.session_invalidated", session_user_id=session_user.id)
         invalidate_session(request)
         return None
 
diff --git a/app/db/session.py b/app/db/session.py
index c05266e..2223216 100644
--- a/app/db/session.py
+++ b/app/db/session.py
@@ -11,6 +11,7 @@ from sqlalchemy.ext.asyncio import (
 )
 from sqlalchemy.pool import NullPool
 
+from app.logging_utils import structured_log
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
@@ -30,13 +31,10 @@ def _normalized_pool_mode(raw_mode: str) -> str:
         return "queue"
     if mode in {"null", "queue"}:
         return mode
-    logger.warning(
-        "db.invalid_pool_mode_fallback",
-        extra={
-            "event": "db.invalid_pool_mode_fallback",
-            "database_pool_mode": raw_mode,
-            "fallback_mode": "queue",
-        },
+    structured_log(
+        logger, "warning", "db.invalid_pool_mode_fallback",
+        database_pool_mode=raw_mode,
+        fallback_mode="queue",
     )
     return "queue"
 
@@ -56,12 +54,9 @@ def get_engine() -> AsyncEngine:
             engine_kwargs["pool_timeout"] = max(1, int(settings.database_pool_timeout_seconds))
 
         _engine = create_async_engine(settings.database_url, **engine_kwargs)
-        logger.info(
-            "db.engine_initialized",
-            extra={
-                "event": "db.engine_initialized",
-                "pool_mode": pool_mode,
-            },
+        structured_log(
+            logger, "info", "db.engine_initialized",
+            pool_mode=pool_mode,
         )
     return _engine
 
@@ -86,7 +81,7 @@ async def check_database() -> bool:
             result = await conn.execute(text("SELECT 1"))
             return result.scalar_one() == 1
     except Exception:
-        logger.exception("db.healthcheck_failed", extra={"event": "db.healthcheck_failed"})
+        logger.exception("db.healthcheck_failed")
         return False
 
 
@@ -94,6 +89,6 @@ async def close_engine() -> None:
     global _engine, _session_factory
     if _engine is not None:
         await _engine.dispose()
-        logger.info("db.engine_disposed", extra={"event": "db.engine_disposed"})
+        structured_log(logger, "info", "db.engine_disposed")
         _engine = None
         _session_factory = None
diff --git a/app/http/middleware.py b/app/http/middleware.py
index ebe72f8..1cbea46 100644
--- a/app/http/middleware.py
+++ b/app/http/middleware.py
@@ -9,6 +9,7 @@ from starlette.requests import Request
 from starlette.responses import Response
 
 from app.logging_context import set_request_id
+from app.logging_utils import structured_log
 
 REQUEST_ID_HEADER = "X-Request-ID"
 DEFAULT_PERMISSIONS_POLICY = (
@@ -61,13 +62,10 @@ class RequestLoggingMiddleware(BaseHTTPMiddleware):
         start = time.perf_counter()
         should_log = self._log_requests and not self._is_skipped_path(request.url.path)
         if should_log:
-            logger.debug(
-                "request.started",
-                extra={
-                    "event": "request.started",
-                    "method": request.method,
-                    "path": request.url.path,
-                },
+            structured_log(
+                logger, "debug", "request.started",
+                method=request.method,
+                path=request.url.path,
             )
 
         try:
@@ -77,7 +75,6 @@ class RequestLoggingMiddleware(BaseHTTPMiddleware):
             logger.exception(
                 "request.failed",
                 extra={
-                    "event": "request.failed",
                     "method": request.method,
                     "path": request.url.path,
                     "duration_ms": duration_ms,
@@ -88,15 +85,12 @@ class RequestLoggingMiddleware(BaseHTTPMiddleware):
             duration_ms = int((time.perf_counter() - start) * 1000)
             response.headers[REQUEST_ID_HEADER] = request_id
             if should_log:
-                logger.debug(
-                    "request.completed",
-                    extra={
-                        "event": "request.completed",
-                        "method": request.method,
-                        "path": request.url.path,
-                        "status_code": response.status_code,
-                        "duration_ms": duration_ms,
-                    },
+                structured_log(
+                    logger, "debug", "request.completed",
+                    method=request.method,
+                    path=request.url.path,
+                    status_code=response.status_code,
+                    duration_ms=duration_ms,
                 )
             return response
         finally:
diff --git a/app/main.py b/app/main.py
index 56ddf58..522a552 100644
--- a/app/main.py
+++ b/app/main.py
@@ -21,6 +21,7 @@ from app.http.middleware import (
     parse_skip_paths,
 )
 from app.logging_config import configure_logging, parse_redact_fields
+from app.logging_utils import structured_log
 from app.security.csrf import CSRFMiddleware
 from app.services.domains.ingestion.scheduler import SchedulerService
 from app.settings import settings
@@ -50,22 +51,15 @@ scheduler_service = SchedulerService(
 )
 
 
-def _log_startup_build_marker() -> None:
-    logger.info(
-        "app.startup_build_marker",
-        extra={
-            "event": "app.startup_build_marker",
-            "build_marker": BUILD_MARKER,
-            "frontend_enabled": settings.frontend_enabled,
-            "scheduler_enabled": settings.scheduler_enabled,
-            "log_format": settings.log_format,
-        },
-    )
-
-
 @asynccontextmanager
 async def lifespan(_: FastAPI):
-    _log_startup_build_marker()
+    structured_log(
+        logger, "info", "app.startup_build_marker",
+        build_marker=BUILD_MARKER,
+        frontend_enabled=settings.frontend_enabled,
+        scheduler_enabled=settings.scheduler_enabled,
+        log_format=settings.log_format,
+    )
     
     from app.db.session import get_session_factory
     from sqlalchemy import text
@@ -74,7 +68,7 @@ async def lifespan(_: FastAPI):
         async with session_factory() as session:
             await session.execute(text("UPDATE crawl_runs SET status = 'failed' WHERE status::text IN ('running', 'resolving')"))
             await session.commit()
-            logger.info("app.startup_orphaned_runs_cleaned", extra={"event": "app.startup_orphaned_runs_cleaned"})
+            structured_log(logger, "info", "app.startup_orphaned_runs_cleaned")
     except Exception as e:
         logger.error(f"Failed to clean orphaned runs at startup: {e}")
 
diff --git a/app/security/csrf.py b/app/security/csrf.py
index 70eecac..d2ed1c5 100644
--- a/app/security/csrf.py
+++ b/app/security/csrf.py
@@ -9,6 +9,7 @@ from starlette.requests import Request
 from starlette.responses import JSONResponse, PlainTextResponse, Response
 from starlette.types import Message
 
+from app.logging_utils import structured_log
 
 CSRF_SESSION_KEY = "csrf_token"
 CSRF_FORM_FIELD = "csrf_token"
@@ -36,13 +37,10 @@ class CSRFMiddleware(BaseHTTPMiddleware):
 
         session_token = request.session.get(CSRF_SESSION_KEY)
         if not session_token:
-            logger.warning(
-                "csrf.missing_session_token",
-                extra={
-                    "event": "csrf.missing_session_token",
-                    "method": request.method,
-                    "path": request.url.path,
-                },
+            structured_log(
+                logger, "warning", "csrf.missing_session_token",
+                method=request.method,
+                path=request.url.path,
             )
             return self._csrf_error_response(
                 request,
@@ -57,13 +55,10 @@ class CSRFMiddleware(BaseHTTPMiddleware):
             request._receive = self._build_receive(body)  # type: ignore[attr-defined]
 
         if not request_token or not compare_digest(str(session_token), str(request_token)):
-            logger.warning(
-                "csrf.invalid_token",
-                extra={
-                    "event": "csrf.invalid_token",
-                    "method": request.method,
-                    "path": request.url.path,
-                },
+            structured_log(
+                logger, "warning", "csrf.invalid_token",
+                method=request.method,
+                path=request.url.path,
             )
             return self._csrf_error_response(
                 request,
diff --git a/app/services/domains/arxiv/client.py b/app/services/domains/arxiv/client.py
index 278ca0f..7bbf87c 100644
--- a/app/services/domains/arxiv/client.py
+++ b/app/services/domains/arxiv/client.py
@@ -5,6 +5,7 @@ import logging
 
 import httpx
 
+from app.logging_utils import structured_log
 from app.services.domains.arxiv.cache import (
     build_query_fingerprint,
     get_cached_feed,
@@ -102,17 +103,9 @@ class ArxivClient:
         if self._cache_enabled:
             cached = await get_cached_feed(query_fingerprint=query_fingerprint)
             if cached is not None:
-                _log_cache_event(
-                    event_name="arxiv.cache_hit",
-                    query_fingerprint=query_fingerprint,
-                    source_path=source_path,
-                )
+                structured_log(logger, "info", "arxiv.cache_hit", query_fingerprint=query_fingerprint, source_path=source_path)
                 return cached
-            _log_cache_event(
-                event_name="arxiv.cache_miss",
-                query_fingerprint=query_fingerprint,
-                source_path=source_path,
-            )
+            structured_log(logger, "info", "arxiv.cache_miss", query_fingerprint=query_fingerprint, source_path=source_path)
         return await run_with_inflight_dedupe(
             query_fingerprint=query_fingerprint,
             fetch_feed=lambda: self._fetch_live_feed(
@@ -222,9 +215,10 @@ async def _request_arxiv_feed(
     source_path = _source_path_from_params(params)
     cooldown_status = await get_arxiv_cooldown_status()
     if cooldown_status.is_active:
-        _log_request_skipped_for_cooldown(
+        structured_log(
+            logger, "warning", "arxiv.request_skipped_cooldown",
             source_path=source_path,
-            cooldown_remaining_seconds=cooldown_status.remaining_seconds,
+            cooldown_remaining_seconds=float(cooldown_status.remaining_seconds),
         )
         raise ArxivRateLimitError(
             f"arXiv global cooldown active ({cooldown_status.remaining_seconds:.0f}s remaining)"
@@ -280,32 +274,3 @@ def _source_path_from_params(params: dict[str, object]) -> str:
     return ARXIV_SOURCE_PATH_UNKNOWN
 
 
-def _log_cache_event(
-    *,
-    event_name: str,
-    query_fingerprint: str,
-    source_path: str,
-) -> None:
-    logger.info(
-        event_name,
-        extra={
-            "event": event_name,
-            "query_fingerprint": query_fingerprint,
-            "source_path": source_path,
-        },
-    )
-
-
-def _log_request_skipped_for_cooldown(
-    *,
-    source_path: str,
-    cooldown_remaining_seconds: float,
-) -> None:
-    logger.warning(
-        "arxiv.request_skipped_cooldown",
-        extra={
-            "event": "arxiv.request_skipped_cooldown",
-            "source_path": source_path,
-            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
-        },
-    )
diff --git a/app/services/domains/arxiv/gateway.py b/app/services/domains/arxiv/gateway.py
index 6782025..67d9543 100644
--- a/app/services/domains/arxiv/gateway.py
+++ b/app/services/domains/arxiv/gateway.py
@@ -5,6 +5,7 @@ import re
 from typing import TYPE_CHECKING, Protocol
 import unicodedata
 
+from app.logging_utils import structured_log
 from app.services.domains.arxiv.client import ArxivClient
 from app.services.domains.arxiv.errors import ArxivRateLimitError
 from app.services.domains.arxiv.types import ArxivFeed
@@ -112,7 +113,7 @@ class HttpArxivGateway:
         except ArxivRateLimitError:
             raise
         except Exception as exc:
-            logger.debug("arxiv.query_failed", extra={"event": "arxiv.query_failed", "error": str(exc)})
+            structured_log(logger, "debug", "arxiv.query_failed", error=str(exc))
             return None
 
 
@@ -136,6 +137,6 @@ def _author_surname(scholar_label: str | None) -> str | None:
 def _first_discovered_id(result: ArxivFeed) -> str | None:
     for entry in result.entries:
         if entry.arxiv_id:
-            logger.debug("arxiv.id_discovered", extra={"event": "arxiv.id_discovered", "arxiv_id": entry.arxiv_id})
+            structured_log(logger, "debug", "arxiv.id_discovered", arxiv_id=entry.arxiv_id)
             return entry.arxiv_id
     return None
diff --git a/app/services/domains/arxiv/rate_limit.py b/app/services/domains/arxiv/rate_limit.py
index 6506035..52e2c3f 100644
--- a/app/services/domains/arxiv/rate_limit.py
+++ b/app/services/domains/arxiv/rate_limit.py
@@ -12,6 +12,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import ArxivRuntimeState
 from app.db.session import get_session_factory
+from app.logging_utils import structured_log
 from app.services.domains.arxiv.constants import (
     ARXIV_RATE_LIMIT_LOCK_KEY,
     ARXIV_RATE_LIMIT_LOCK_NAMESPACE,
@@ -83,14 +84,12 @@ async def _run_serialized_fetch(
                 response_status=int(response.status_code),
                 source_path=source_path,
             )
-            _log_request_completed(
-                response_status=int(response.status_code),
+            structured_log(
+                logger, "info", "arxiv.request_completed",
+                status_code=int(response.status_code),
                 wait_seconds=wait_seconds,
+                cooldown_remaining_seconds=_cooldown_remaining_seconds(runtime_state.cooldown_until, now_utc=datetime.now(timezone.utc)),
                 source_path=source_path,
-                cooldown_remaining_seconds=_cooldown_remaining_seconds(
-                    runtime_state.cooldown_until,
-                    now_utc=datetime.now(timezone.utc),
-                ),
             )
             return response, hit_rate_limit
 
@@ -128,18 +127,10 @@ async def _wait_for_allowed_slot_or_raise(
     now_utc = datetime.now(timezone.utc)
     cooldown_seconds = _cooldown_remaining_seconds(runtime_state.cooldown_until, now_utc=now_utc)
     if cooldown_seconds > 0:
-        _log_request_scheduled(
-            wait_seconds=0.0,
-            source_path=source_path,
-            cooldown_remaining_seconds=cooldown_seconds,
-        )
+        structured_log(logger, "info", "arxiv.request_scheduled", wait_seconds=0.0, source_path=source_path, cooldown_remaining_seconds=cooldown_seconds)
         raise ArxivRateLimitError(f"arXiv global cooldown active ({cooldown_seconds:.0f}s remaining)")
     wait_seconds = _next_allowed_wait_seconds(runtime_state.next_allowed_at, now_utc=now_utc)
-    _log_request_scheduled(
-        wait_seconds=wait_seconds,
-        source_path=source_path,
-        cooldown_remaining_seconds=0.0,
-    )
+    structured_log(logger, "info", "arxiv.request_scheduled", wait_seconds=wait_seconds, source_path=source_path, cooldown_remaining_seconds=0.0)
     if wait_seconds > 0:
         await asyncio.sleep(wait_seconds)
     return wait_seconds
@@ -156,9 +147,10 @@ def _record_post_response_state(
     if response_status == 429:
         cooldown_seconds = _cooldown_seconds()
         runtime_state.cooldown_until = now_utc + timedelta(seconds=cooldown_seconds)
-        _log_cooldown_activated(
-            source_path=source_path,
+        structured_log(
+            logger, "warning", "arxiv.cooldown_activated",
             cooldown_remaining_seconds=cooldown_seconds,
+            source_path=source_path,
         )
         return True
     if _cooldown_remaining_seconds(runtime_state.cooldown_until, now_utc=now_utc) <= 0:
@@ -196,52 +188,3 @@ def _cooldown_seconds() -> float:
     return max(float(settings.arxiv_rate_limit_cooldown_seconds), 0.0)
 
 
-def _log_request_scheduled(
-    *,
-    wait_seconds: float,
-    source_path: str,
-    cooldown_remaining_seconds: float,
-) -> None:
-    logger.info(
-        "arxiv.request_scheduled",
-        extra={
-            "event": "arxiv.request_scheduled",
-            "wait_seconds": float(wait_seconds),
-            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
-            "source_path": source_path,
-        },
-    )
-
-
-def _log_request_completed(
-    *,
-    response_status: int,
-    wait_seconds: float,
-    source_path: str,
-    cooldown_remaining_seconds: float,
-) -> None:
-    logger.info(
-        "arxiv.request_completed",
-        extra={
-            "event": "arxiv.request_completed",
-            "status_code": int(response_status),
-            "wait_seconds": float(wait_seconds),
-            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
-            "source_path": source_path,
-        },
-    )
-
-
-def _log_cooldown_activated(
-    *,
-    source_path: str,
-    cooldown_remaining_seconds: float,
-) -> None:
-    logger.warning(
-        "arxiv.cooldown_activated",
-        extra={
-            "event": "arxiv.cooldown_activated",
-            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
-            "source_path": source_path,
-        },
-    )
diff --git a/app/services/domains/crossref/application.py b/app/services/domains/crossref/application.py
index f0e1311..7212101 100644
--- a/app/services/domains/crossref/application.py
+++ b/app/services/domains/crossref/application.py
@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING
 from crossref.restful import Etiquette, Works
 
 from app.services.domains.doi.normalize import normalize_doi
+from app.logging_utils import structured_log
 from app.settings import settings
 
 if TYPE_CHECKING:
@@ -377,6 +378,6 @@ async def discover_doi_for_publication(
             author_surname=author_surname,
         )
         if doi:
-            logger.debug("crossref.doi_discovered", extra={"event": "crossref.doi_discovered"})
+            structured_log(logger, "debug", "crossref.doi_discovered")
             return doi
     return None
diff --git a/app/services/domains/ingestion/scheduler.py b/app/services/domains/ingestion/scheduler.py
index b05e84d..1f2267a 100644
--- a/app/services/domains/ingestion/scheduler.py
+++ b/app/services/domains/ingestion/scheduler.py
@@ -23,6 +23,7 @@ from app.services.domains.ingestion.application import (
     RunBlockedBySafetyPolicyError,
     ScholarIngestionService,
 )
+from app.logging_utils import structured_log
 from app.services.domains.settings import application as user_settings_service
 from app.services.domains.scholar.source import LiveScholarSource
 from app.settings import settings
@@ -89,31 +90,23 @@ class SchedulerService:
 
     async def start(self) -> None:
         if not self._enabled:
-            logger.info(
-                "scheduler.disabled",
-                extra={
-                    "event": "scheduler.disabled",
-                },
-            )
+            structured_log(logger, "info", "scheduler.disabled")
             return
         if self._task is not None:
             return
         self._task = asyncio.create_task(self._run_loop(), name="scholarr-scheduler")
-        logger.info(
-            "scheduler.started",
-            extra={
-                "event": "scheduler.started",
-                "tick_seconds": self._tick_seconds,
-                "network_error_retries": self._network_error_retries,
-                "retry_backoff_seconds": self._retry_backoff_seconds,
-                "max_pages_per_scholar": self._max_pages_per_scholar,
-                "page_size": self._page_size,
-                "continuation_queue_enabled": self._continuation_queue_enabled,
-                "continuation_base_delay_seconds": self._continuation_base_delay_seconds,
-                "continuation_max_delay_seconds": self._continuation_max_delay_seconds,
-                "continuation_max_attempts": self._continuation_max_attempts,
-                "queue_batch_size": self._queue_batch_size,
-            },
+        structured_log(
+            logger, "info", "scheduler.started",
+            tick_seconds=self._tick_seconds,
+            network_error_retries=self._network_error_retries,
+            retry_backoff_seconds=self._retry_backoff_seconds,
+            max_pages_per_scholar=self._max_pages_per_scholar,
+            page_size=self._page_size,
+            continuation_queue_enabled=self._continuation_queue_enabled,
+            continuation_base_delay_seconds=self._continuation_base_delay_seconds,
+            continuation_max_delay_seconds=self._continuation_max_delay_seconds,
+            continuation_max_attempts=self._continuation_max_attempts,
+            queue_batch_size=self._queue_batch_size,
         )
 
     async def stop(self) -> None:
@@ -126,7 +119,7 @@ class SchedulerService:
             pass
         finally:
             self._task = None
-        logger.info("scheduler.stopped", extra={"event": "scheduler.stopped"})
+        structured_log(logger, "info", "scheduler.stopped")
 
     async def _run_loop(self) -> None:
         while True:
@@ -137,9 +130,7 @@ class SchedulerService:
             except Exception:
                 logger.exception(
                     "scheduler.tick_failed",
-                    extra={
-                        "event": "scheduler.tick_failed",
-                    },
+                    extra={},
                 )
             await asyncio.sleep(float(self._tick_seconds))
 
@@ -181,17 +172,12 @@ class SchedulerService:
         if cooldown_until is not None and cooldown_until.tzinfo is None:
             cooldown_until = cooldown_until.replace(tzinfo=timezone.utc)
         if cooldown_until is not None and cooldown_until > now_utc:
-            logger.info(
-                "scheduler.run_skipped_safety_cooldown_precheck",
-                extra={
-                    "event": "scheduler.run_skipped_safety_cooldown_precheck",
-                    "user_id": int(user_id),
-                    "reason": cooldown_reason,
-                    "cooldown_until": cooldown_until,
-                    "cooldown_remaining_seconds": int((cooldown_until - now_utc).total_seconds()),
-                    "metric_name": "scheduler_run_skipped_safety_cooldown_total",
-                    "metric_value": 1,
-                },
+            structured_log(
+                logger, "info", "scheduler.run_skipped_safety_cooldown_precheck",
+                user_id=int(user_id),
+                reason=cooldown_reason,
+                cooldown_until=cooldown_until,
+                cooldown_remaining_seconds=int((cooldown_until - now_utc).total_seconds()),
             )
             return None
         return _AutoRunCandidate(
@@ -261,42 +247,34 @@ class SchedulerService:
                 )
             except RunAlreadyInProgressError:
                 await session.rollback()
-                logger.info("scheduler.run_skipped_locked", extra={"event": "scheduler.run_skipped_locked", "user_id": candidate.user_id})
+                structured_log(logger, "info", "scheduler.run_skipped_locked", user_id=candidate.user_id)
                 return None
             except RunBlockedBySafetyPolicyError as exc:
                 await session.rollback()
-                logger.info(
-                    "scheduler.run_skipped_safety_cooldown",
-                    extra={
-                        "event": "scheduler.run_skipped_safety_cooldown",
-                        "user_id": candidate.user_id,
-                        "reason": exc.safety_state.get("cooldown_reason"),
-                        "cooldown_until": exc.safety_state.get("cooldown_until"),
-                        "cooldown_remaining_seconds": exc.safety_state.get("cooldown_remaining_seconds"),
-                        "metric_name": "scheduler_run_skipped_safety_cooldown_total",
-                        "metric_value": 1,
-                    },
+                structured_log(
+                    logger, "info", "scheduler.run_skipped_safety_cooldown",
+                    user_id=candidate.user_id,
+                    reason=exc.safety_state.get("cooldown_reason"),
+                    cooldown_until=exc.safety_state.get("cooldown_until"),
+                    cooldown_remaining_seconds=exc.safety_state.get("cooldown_remaining_seconds"),
                 )
                 return None
             except Exception:
                 await session.rollback()
-                logger.exception("scheduler.run_failed", extra={"event": "scheduler.run_failed", "user_id": candidate.user_id})
+                logger.exception("scheduler.run_failed", extra={"user_id": candidate.user_id})
                 return None
 
     async def _run_candidate(self, candidate: _AutoRunCandidate) -> None:
         run_summary = await self._run_candidate_ingestion(candidate=candidate)
         if run_summary is None:
             return
-        logger.info(
-            "scheduler.run_completed",
-            extra={
-                "event": "scheduler.run_completed",
-                "user_id": candidate.user_id,
-                "run_id": run_summary.crawl_run_id,
-                "status": run_summary.status.value,
-                "scholar_count": run_summary.scholar_count,
-                "new_publication_count": run_summary.new_publication_count,
-            },
+        structured_log(
+            logger, "info", "scheduler.run_completed",
+            user_id=candidate.user_id,
+            run_id=run_summary.crawl_run_id,
+            status=run_summary.status.value,
+            scholar_count=run_summary.scholar_count,
+            new_publication_count=run_summary.new_publication_count,
         )
 
     async def _drain_continuation_queue(self) -> None:
@@ -326,16 +304,13 @@ class SchedulerService:
             )
             await session.commit()
         if dropped is not None:
-            logger.warning(
-                "scheduler.queue_item_dropped_max_attempts",
-                extra={
-                    "event": "scheduler.queue_item_dropped_max_attempts",
-                    "queue_item_id": job.id,
-                    "user_id": job.user_id,
-                    "scholar_profile_id": job.scholar_profile_id,
-                    "attempt_count": job.attempt_count,
-                    "max_attempts": self._continuation_max_attempts,
-                },
+            structured_log(
+                logger, "warning", "scheduler.queue_item_dropped_max_attempts",
+                queue_item_id=job.id,
+                user_id=job.user_id,
+                scholar_profile_id=job.scholar_profile_id,
+                attempt_count=job.attempt_count,
+                max_attempts=self._continuation_max_attempts,
             )
         return True
 
@@ -376,14 +351,11 @@ class SchedulerService:
             )
             await session.commit()
         if dropped is not None:
-            logger.info(
-                "scheduler.queue_item_dropped_scholar_unavailable",
-                extra={
-                    "event": "scheduler.queue_item_dropped_scholar_unavailable",
-                    "queue_item_id": job.id,
-                    "user_id": job.user_id,
-                    "scholar_profile_id": job.scholar_profile_id,
-                },
+            structured_log(
+                logger, "info", "scheduler.queue_item_dropped_scholar_unavailable",
+                queue_item_id=job.id,
+                user_id=job.user_id,
+                scholar_profile_id=job.scholar_profile_id,
             )
         return False
 
@@ -398,9 +370,9 @@ class SchedulerService:
                 error="run_already_in_progress",
             )
             await recovery_session.commit()
-        logger.info(
-            "scheduler.queue_item_deferred_lock",
-            extra={"event": "scheduler.queue_item_deferred_lock", "queue_item_id": job.id, "user_id": job.user_id},
+        structured_log(
+            logger, "info", "scheduler.queue_item_deferred_lock",
+            queue_item_id=job.id, user_id=job.user_id,
         )
 
     async def _reschedule_queue_job_safety_cooldown(
@@ -422,17 +394,12 @@ class SchedulerService:
                 error=str(exc.message),
             )
             await recovery_session.commit()
-        logger.info(
-            "scheduler.queue_item_deferred_safety_cooldown",
-            extra={
-                "event": "scheduler.queue_item_deferred_safety_cooldown",
-                "queue_item_id": job.id,
-                "user_id": job.user_id,
-                "reason": exc.safety_state.get("cooldown_reason"),
-                "cooldown_remaining_seconds": cooldown_remaining_seconds,
-                "metric_name": "scheduler_queue_item_deferred_safety_cooldown_total",
-                "metric_value": 1,
-            },
+        structured_log(
+            logger, "info", "scheduler.queue_item_deferred_safety_cooldown",
+            queue_item_id=job.id,
+            user_id=job.user_id,
+            reason=exc.safety_state.get("cooldown_reason"),
+            cooldown_remaining_seconds=cooldown_remaining_seconds,
         )
 
     async def _reschedule_queue_job_after_exception(
@@ -455,9 +422,9 @@ class SchedulerService:
                     error=str(exc),
                 )
                 await recovery_session.commit()
-                logger.warning(
-                    "scheduler.queue_item_dropped_after_exception",
-                    extra={"event": "scheduler.queue_item_dropped_after_exception", "queue_item_id": job.id, "user_id": job.user_id, "attempt_count": queue_item.attempt_count},
+                structured_log(
+                    logger, "warning", "scheduler.queue_item_dropped_after_exception",
+                    queue_item_id=job.id, user_id=job.user_id, attempt_count=queue_item.attempt_count,
                 )
                 return
             delay_seconds = queue_service.compute_backoff_seconds(
@@ -473,7 +440,7 @@ class SchedulerService:
                 error=str(exc),
             )
             await recovery_session.commit()
-        logger.exception("scheduler.queue_item_run_failed", extra={"event": "scheduler.queue_item_run_failed", "queue_item_id": job.id, "user_id": job.user_id})
+        logger.exception("scheduler.queue_item_run_failed", extra={"queue_item_id": job.id, "user_id": job.user_id})
 
     async def _run_ingestion_for_queue_job(
         self,
@@ -514,28 +481,6 @@ class SchedulerService:
                 await self._reschedule_queue_job_after_exception(job, exc=exc)
         return None
 
-    @staticmethod
-    def _log_queue_item_resolved(
-        *,
-        event_name: str,
-        job: queue_service.ContinuationQueueJob,
-        run_summary,
-        attempt_count: int | None = None,
-        delay_seconds: int | None = None,
-    ) -> None:
-        payload = {
-            "event": event_name,
-            "queue_item_id": job.id,
-            "user_id": job.user_id,
-            "run_id": run_summary.crawl_run_id,
-            "status": run_summary.status.value,
-        }
-        if attempt_count is not None:
-            payload["attempt_count"] = attempt_count
-        if delay_seconds is not None:
-            payload["delay_seconds"] = delay_seconds
-        logger.info(event_name, extra=payload)
-
     async def _finalize_queue_job_after_run(self, job: queue_service.ContinuationQueueJob, run_summary) -> None:
         session_factory = get_session_factory()
         async with session_factory() as session:
@@ -543,35 +488,45 @@ class SchedulerService:
                 queue_item = await queue_service.reset_attempt_count(session, job_id=job.id)
                 await session.commit()
                 if queue_item is None:
-                    self._log_queue_item_resolved(event_name="scheduler.queue_item_resolved", job=job, run_summary=run_summary)
+                    structured_log(
+                        logger, "info", "scheduler.queue_item_resolved",
+                        queue_item_id=job.id, user_id=job.user_id,
+                        run_id=run_summary.crawl_run_id, status=run_summary.status.value,
+                    )
                     return
-                self._log_queue_item_resolved(
-                    event_name="scheduler.queue_item_progressed",
-                    job=job,
-                    run_summary=run_summary,
+                structured_log(
+                    logger, "info", "scheduler.queue_item_progressed",
+                    queue_item_id=job.id, user_id=job.user_id,
+                    run_id=run_summary.crawl_run_id, status=run_summary.status.value,
                     attempt_count=int(queue_item.attempt_count),
                 )
                 return
             queue_item = await queue_service.increment_attempt_count(session, job_id=job.id)
             if queue_item is None:
                 await session.commit()
-                self._log_queue_item_resolved(event_name="scheduler.queue_item_resolved", job=job, run_summary=run_summary)
+                structured_log(
+                    logger, "info", "scheduler.queue_item_resolved",
+                    queue_item_id=job.id, user_id=job.user_id,
+                    run_id=run_summary.crawl_run_id, status=run_summary.status.value,
+                )
                 return
             if int(queue_item.attempt_count) >= self._continuation_max_attempts:
                 await queue_service.mark_dropped(session, job_id=job.id, reason="max_attempts_after_run")
                 await session.commit()
-                logger.warning(
-                    "scheduler.queue_item_dropped_max_attempts_after_run",
-                    extra={"event": "scheduler.queue_item_dropped_max_attempts_after_run", "queue_item_id": job.id, "user_id": job.user_id, "attempt_count": queue_item.attempt_count, "run_id": run_summary.crawl_run_id, "status": run_summary.status.value},
+                structured_log(
+                    logger, "warning", "scheduler.queue_item_dropped_max_attempts_after_run",
+                    queue_item_id=job.id, user_id=job.user_id,
+                    attempt_count=queue_item.attempt_count,
+                    run_id=run_summary.crawl_run_id, status=run_summary.status.value,
                 )
                 return
             delay_seconds = queue_service.compute_backoff_seconds(base_seconds=self._continuation_base_delay_seconds, attempt_count=int(queue_item.attempt_count), max_seconds=self._continuation_max_delay_seconds)
             await queue_service.reschedule_job(session, job_id=job.id, delay_seconds=delay_seconds, reason=queue_item.reason, error=queue_item.last_error)
             await session.commit()
-        self._log_queue_item_resolved(
-            event_name="scheduler.queue_item_rescheduled_failed",
-            job=job,
-            run_summary=run_summary,
+        structured_log(
+            logger, "info", "scheduler.queue_item_rescheduled_failed",
+            queue_item_id=job.id, user_id=job.user_id,
+            run_id=run_summary.crawl_run_id, status=run_summary.status.value,
             attempt_count=int(queue_item.attempt_count),
             delay_seconds=delay_seconds,
         )
@@ -600,14 +555,12 @@ class SchedulerService:
                     max_attempts=settings.pdf_auto_retry_max_attempts,
                 )
                 if processed > 0:
-                    logger.info("scheduler.pdf_queue_drain_completed", extra={
-                        "event": "scheduler.pdf_queue_drain_completed",
-                        "processed_count": processed,
-                    })
+                    structured_log(
+                        logger, "info", "scheduler.pdf_queue_drain_completed",
+                        processed_count=processed,
+                    )
             except Exception:
-                logger.exception("scheduler.pdf_queue_drain_failed", extra={
-                    "event": "scheduler.pdf_queue_drain_failed",
-                })
+                logger.exception("scheduler.pdf_queue_drain_failed", extra={})
 
     async def _load_request_delay_for_user(
         self,
diff --git a/app/services/domains/openalex/client.py b/app/services/domains/openalex/client.py
index a85b630..f6db5fd 100644
--- a/app/services/domains/openalex/client.py
+++ b/app/services/domains/openalex/client.py
@@ -84,7 +84,7 @@ class OpenAlexClient:
                 )
             raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex work by DOI")
         if response.status_code >= 400:
-            logger.warning("OpenAlex API error: %s %s", response.status_code, response.text)
+            logger.warning("OpenAlex API error: %s %s", response.status_code, response.text[:500])
             raise OpenAlexClientError(f"API Error {response.status_code}")
 
         data = response.json()
@@ -134,7 +134,7 @@ class OpenAlexClient:
                 )
             raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex works list")
         if response.status_code >= 400:
-            logger.warning("OpenAlex API error (filters=%s): %s %s", filters, response.status_code, response.text)
+            logger.warning("OpenAlex API error (filters=%s): %s %s", filters, response.status_code, response.text[:500])
             raise OpenAlexClientError(f"API Error {response.status_code}")
 
         data = response.json()
diff --git a/app/services/domains/publications/dedup.py b/app/services/domains/publications/dedup.py
index 6615d3b..5bf1d43 100644
--- a/app/services/domains/publications/dedup.py
+++ b/app/services/domains/publications/dedup.py
@@ -10,6 +10,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import aliased
 
 from app.db.models import Publication, PublicationIdentifier, ScholarPublication
+from app.logging_utils import structured_log
 from app.services.domains.ingestion.fingerprints import (
     canonical_title_text_for_dedup,
     canonical_title_tokens_for_dedup,
@@ -104,14 +105,7 @@ async def merge_duplicate_publication(
     await _migrate_scholar_links(db_session, winner_id=winner_id, dup_id=dup_id)
     await _migrate_identifiers(db_session, winner_id=winner_id, dup_id=dup_id)
     await db_session.execute(delete(Publication).where(Publication.id == dup_id))
-    logger.info(
-        "publications.identifier_merge",
-        extra={
-            "event": "publications.identifier_merge",
-            "winner_id": winner_id,
-            "dup_id": dup_id,
-        },
-    )
+    structured_log(logger, "info", "publications.identifier_merge", winner_id=winner_id, dup_id=dup_id)
 
 
 async def _load_publication(
diff --git a/app/services/domains/publications/enrichment.py b/app/services/domains/publications/enrichment.py
index 381107a..8a6b04f 100644
--- a/app/services/domains/publications/enrichment.py
+++ b/app/services/domains/publications/enrichment.py
@@ -9,6 +9,7 @@ from app.services.domains.publications.pdf_queue import (
     enqueue_retry_pdf_job,
     overlay_pdf_job_state,
 )
+from app.logging_utils import structured_log
 from app.services.domains.publications.types import PublicationListItem
 
 logger = logging.getLogger(__name__)
@@ -29,14 +30,7 @@ async def schedule_missing_pdf_enrichment_for_user(
         rows=items,
         max_items=max_items,
     )
-    logger.info(
-        "publications.enrichment.scheduled",
-        extra={
-            "event": "publications.enrichment.scheduled",
-            "user_id": user_id,
-            "publication_count": len(queued_ids),
-        },
-    )
+    structured_log(logger, "info", "publications.enrichment.scheduled", user_id=user_id, publication_count=len(queued_ids))
     return len(queued_ids)
 
 
@@ -53,15 +47,7 @@ async def schedule_retry_pdf_enrichment_for_row(
         request_email=request_email,
         row=item,
     )
-    logger.info(
-        "publications.enrichment.retry_scheduled",
-        extra={
-            "event": "publications.enrichment.retry_scheduled",
-            "user_id": user_id,
-            "publication_id": item.publication_id,
-            "queued": queued,
-        },
-    )
+    structured_log(logger, "info", "publications.enrichment.retry_scheduled", user_id=user_id, publication_id=item.publication_id, queued=queued)
     return queued
 
 
diff --git a/app/services/domains/publications/pdf_queue.py b/app/services/domains/publications/pdf_queue.py
index 3cb0de4..83c9031 100644
--- a/app/services/domains/publications/pdf_queue.py
+++ b/app/services/domains/publications/pdf_queue.py
@@ -27,6 +27,7 @@ from app.services.domains.unpaywall.application import (
     FAILURE_RESOLUTION_EXCEPTION,
     OaResolutionOutcome,
 )
+from app.logging_utils import structured_log
 from app.settings import settings
 
 PDF_STATUS_UNTRACKED = "untracked"
@@ -320,10 +321,7 @@ def _drop_finished_task(task: asyncio.Task[None]) -> None:
     try:
         task.result()
     except Exception:
-        logger.exception(
-            "publications.pdf_queue.task_failed",
-            extra={"event": "publications.pdf_queue.task_failed"},
-        )
+        logger.exception("publications.pdf_queue.task_failed")
 
 
 async def _mark_attempt_started(
@@ -474,14 +472,7 @@ async def _resolve_publication_row(
         # Propagate upward so the batch loop can stop immediately.
         raise
     except Exception as exc:  # pragma: no cover - defensive network boundary
-        logger.warning(
-            "publications.pdf_queue.resolve_failed",
-            extra={
-                "event": "publications.pdf_queue.resolve_failed",
-                "publication_id": row.publication_id,
-                "error": str(exc),
-            },
-        )
+        structured_log(logger, "warning", "publications.pdf_queue.resolve_failed", publication_id=row.publication_id, error=str(exc))
         outcome = _failed_outcome(row=row)
         arxiv_rate_limited = False
     await _persist_outcome(
@@ -523,19 +514,9 @@ async def _run_resolution_task(
             )
             if arxiv_rate_limited and arxiv_lookup_allowed:
                 arxiv_lookup_allowed = False
-                logger.warning(
-                    "publications.pdf_queue.arxiv_batch_disabled",
-                    extra={
-                        "event": "publications.pdf_queue.arxiv_batch_disabled",
-                        "detail": "arXiv temporarily disabled for remaining batch after rate limit",
-                    },
-                )
+                structured_log(logger, "warning", "publications.pdf_queue.arxiv_batch_disabled", detail="arXiv temporarily disabled for remaining batch after rate limit")
         except OpenAlexBudgetExhaustedError:
-            logger.warning(
-                "publications.pdf_queue.budget_exhausted",
-                extra={"event": "publications.pdf_queue.budget_exhausted",
-                       "detail": "Stopping PDF resolution batch — OpenAlex daily budget exhausted"},
-            )
+            structured_log(logger, "warning", "publications.pdf_queue.budget_exhausted", detail="Stopping PDF resolution batch — OpenAlex daily budget exhausted")
             break
 
 
diff --git a/app/services/domains/publications/pdf_resolution_pipeline.py b/app/services/domains/publications/pdf_resolution_pipeline.py
index 7ad1f8d..f17d65b 100644
--- a/app/services/domains/publications/pdf_resolution_pipeline.py
+++ b/app/services/domains/publications/pdf_resolution_pipeline.py
@@ -9,6 +9,7 @@ from app.services.domains.arxiv.guards import arxiv_skip_reason_for_item
 from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
 from app.services.domains.publications.types import PublicationListItem
 from app.services.domains.unpaywall.application import OaResolutionOutcome, resolve_publication_oa_outcomes
+from app.logging_utils import structured_log
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
@@ -44,13 +45,7 @@ async def resolve_publication_pdf_outcome_for_row(
     except ArxivRateLimitError:
         arxiv_rate_limited = True
         arxiv_outcome = None
-        logger.warning(
-            "publications.pdf_resolution.arxiv_rate_limited",
-            extra={
-                "event": "publications.pdf_resolution.arxiv_rate_limited",
-                "publication_id": int(row.publication_id),
-            },
-        )
+        structured_log(logger, "warning", "publications.pdf_resolution.arxiv_rate_limited", publication_id=int(row.publication_id))
     if arxiv_outcome and arxiv_outcome.pdf_url:
         return PipelineOutcome(arxiv_outcome, None, arxiv_rate_limited=arxiv_rate_limited)
 
@@ -99,10 +94,7 @@ async def _openalex_outcome(
         # Re-raise so the caller's batch loop can stop hitting the API.
         raise
     except Exception as exc:
-        logger.warning(
-            "publications.pdf_resolution.openalex_failed",
-            extra={"event": "publications.pdf_resolution.openalex_failed", "error": str(exc)},
-        )
+        structured_log(logger, "warning", "publications.pdf_resolution.openalex_failed", error=str(exc))
     return None
 
 
@@ -115,12 +107,12 @@ async def _arxiv_outcome(
     from app.services.domains.arxiv.application import discover_arxiv_id_for_publication
 
     if not allow_lookup:
-        _log_arxiv_skip(row=row, skip_reason="batch_arxiv_cooldown_active")
+        structured_log(logger, "info", "publications.pdf_resolution.arxiv_skipped", publication_id=int(row.publication_id), skip_reason="batch_arxiv_cooldown_active")
         return None
 
     skip_reason = arxiv_skip_reason_for_item(item=row)
     if skip_reason is not None:
-        _log_arxiv_skip(row=row, skip_reason=skip_reason)
+        structured_log(logger, "info", "publications.pdf_resolution.arxiv_skipped", publication_id=int(row.publication_id), skip_reason=skip_reason)
         return None
 
     try:
@@ -138,23 +130,10 @@ async def _arxiv_outcome(
     except ArxivRateLimitError:
         raise  # propagate so orchestration can switch to non-arXiv fallback
     except Exception as exc:
-        logger.warning(
-            "publications.pdf_resolution.arxiv_failed",
-            extra={"event": "publications.pdf_resolution.arxiv_failed", "error": str(exc)},
-        )
+        structured_log(logger, "warning", "publications.pdf_resolution.arxiv_failed", error=str(exc))
     return None
 
 
-def _log_arxiv_skip(*, row: PublicationListItem, skip_reason: str) -> None:
-    logger.info(
-        "publications.pdf_resolution.arxiv_skipped",
-        extra={
-            "event": "publications.pdf_resolution.arxiv_skipped",
-            "publication_id": int(row.publication_id),
-            "skip_reason": skip_reason,
-        },
-    )
-
 
 async def _oa_outcome(
     *,
diff --git a/app/services/domains/scholar/source.py b/app/services/domains/scholar/source.py
index cf2ea0a..50d27ca 100644
--- a/app/services/domains/scholar/source.py
+++ b/app/services/domains/scholar/source.py
@@ -9,6 +9,7 @@ from urllib.error import HTTPError, URLError
 from urllib.parse import urlencode
 from urllib.request import Request, urlopen
 
+from app.logging_utils import structured_log
 from app.services.domains.scholar import rate_limit as scholar_rate_limit
 from app.settings import settings
 
@@ -100,15 +101,12 @@ class LiveScholarSource:
             cstart=cstart,
             pagesize=pagesize,
         )
-        logger.debug(
-            "scholar_source.fetch_started",
-            extra={
-                "event": "scholar_source.fetch_started",
-                "scholar_id": scholar_id,
-                "requested_url": requested_url,
-                "cstart": cstart,
-                "pagesize": pagesize,
-            },
+        structured_log(
+            logger, "debug", "scholar_source.fetch_started",
+            scholar_id=scholar_id,
+            requested_url=requested_url,
+            cstart=cstart,
+            pagesize=pagesize,
         )
         return await self._fetch_with_global_throttle(requested_url)
 
@@ -122,24 +120,18 @@ class LiveScholarSource:
             query=query,
             start=start,
         )
-        logger.debug(
-            "scholar_source.search_fetch_started",
-            extra={
-                "event": "scholar_source.search_fetch_started",
-                "query": query,
-                "requested_url": requested_url,
-                "start": start,
-            },
+        structured_log(
+            logger, "debug", "scholar_source.search_fetch_started",
+            query=query,
+            requested_url=requested_url,
+            start=start,
         )
         return await self._fetch_with_global_throttle(requested_url)
 
     async def fetch_publication_html(self, publication_url: str) -> FetchResult:
-        logger.debug(
-            "scholar_source.publication_fetch_started",
-            extra={
-                "event": "scholar_source.publication_fetch_started",
-                "requested_url": publication_url,
-            },
+        structured_log(
+            logger, "debug", "scholar_source.publication_fetch_started",
+            requested_url=publication_url,
         )
         return await self._fetch_with_global_throttle(publication_url)
 
@@ -169,9 +161,9 @@ class LiveScholarSource:
 
     @staticmethod
     def _network_error_result(requested_url: str, exc: URLError) -> FetchResult:
-        logger.warning(
-            "scholar_source.fetch_network_error",
-            extra={"event": "scholar_source.fetch_network_error", "requested_url": requested_url},
+        structured_log(
+            logger, "warning", "scholar_source.fetch_network_error",
+            requested_url=requested_url,
         )
         return FetchResult(
             requested_url=requested_url,
@@ -183,13 +175,10 @@ class LiveScholarSource:
 
     @staticmethod
     def _http_error_result(requested_url: str, exc: HTTPError) -> FetchResult:
-        logger.warning(
-            "scholar_source.fetch_http_error",
-            extra={
-                "event": "scholar_source.fetch_http_error",
-                "requested_url": requested_url,
-                "status_code": exc.code,
-            },
+        structured_log(
+            logger, "warning", "scholar_source.fetch_http_error",
+            requested_url=requested_url,
+            status_code=exc.code,
         )
         return FetchResult(
             requested_url=requested_url,
@@ -203,13 +192,10 @@ class LiveScholarSource:
     def _success_result(requested_url: str, response) -> FetchResult:
         body = response.read().decode("utf-8", errors="replace")
         status_code = getattr(response, "status", 200)
-        logger.debug(
-            "scholar_source.fetch_succeeded",
-            extra={
-                "event": "scholar_source.fetch_succeeded",
-                "requested_url": requested_url,
-                "status_code": status_code,
-            },
+        structured_log(
+            logger, "debug", "scholar_source.fetch_succeeded",
+            requested_url=requested_url,
+            status_code=status_code,
         )
         return FetchResult(
             requested_url=requested_url,
diff --git a/app/services/domains/scholars/application.py b/app/services/domains/scholars/application.py
index 8da041f..18ffdae 100644
--- a/app/services/domains/scholars/application.py
+++ b/app/services/domains/scholars/application.py
@@ -41,6 +41,7 @@ from app.services.domains.scholars.constants import (
     SEARCH_COOLDOWN_REASON,
     SEARCH_DISABLED_REASON,
 )
+from app.logging_utils import structured_log
 from app.services.domains.scholars.exceptions import ScholarServiceError
 from app.services.domains.scholars.search_hints import (
     _merge_warnings,
@@ -430,9 +431,9 @@ def _normalize_author_search_inputs(query: str, limit: int) -> tuple[str, int, s
 
 
 def _disabled_search_result(*, normalized_query: str, bounded_limit: int) -> ParsedAuthorSearchPage:
-    logger.warning(
-        "scholar_search.disabled_by_configuration",
-        extra={"event": "scholar_search.disabled_by_configuration", "query": normalized_query},
+    structured_log(
+        logger, "warning", "scholar_search.disabled_by_configuration",
+        query=normalized_query,
     )
     return _policy_blocked_author_search_result(
         reason=SEARCH_DISABLED_REASON,
@@ -456,9 +457,9 @@ def _normalize_runtime_cooldown_state(
         updated = True
     if now_utc < cooldown_until:
         return updated
-    logger.info(
-        "scholar_search.cooldown_expired",
-        extra={"event": "scholar_search.cooldown_expired", "cooldown_until_utc": cooldown_until.isoformat()},
+    structured_log(
+        logger, "info", "scholar_search.cooldown_expired",
+        cooldown_until_utc=cooldown_until.isoformat(),
     )
     runtime_state.cooldown_until = None
     runtime_state.cooldown_rejection_count = 0
@@ -492,15 +493,12 @@ def _emit_cooldown_threshold_alert(
         return True
     if bool(runtime_state.cooldown_alert_emitted):
         return True
-    logger.error(
-        "scholar_search.cooldown_rejection_threshold_exceeded",
-        extra={
-            "event": "scholar_search.cooldown_rejection_threshold_exceeded",
-            "query": normalized_query,
-            "cooldown_rejection_count": int(runtime_state.cooldown_rejection_count),
-            "threshold": threshold,
-            "cooldown_until_utc": runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
-        },
+    structured_log(
+        logger, "error", "scholar_search.cooldown_rejection_threshold_exceeded",
+        query=normalized_query,
+        cooldown_rejection_count=int(runtime_state.cooldown_rejection_count),
+        threshold=threshold,
+        cooldown_until_utc=runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
     )
     runtime_state.cooldown_alert_emitted = True
     return True
@@ -519,14 +517,11 @@ def _cooldown_block_result(
         normalized_query=normalized_query,
         cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
     )
-    logger.warning(
-        "scholar_search.cooldown_active",
-        extra={
-            "event": "scholar_search.cooldown_active",
-            "query": normalized_query,
-            "cooldown_remaining_seconds": cooldown_remaining_seconds,
-            "cooldown_until_utc": runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
-        },
+    structured_log(
+        logger, "warning", "scholar_search.cooldown_active",
+        query=normalized_query,
+        cooldown_remaining_seconds=cooldown_remaining_seconds,
+        cooldown_until_utc=runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
     )
     return _policy_blocked_author_search_result(
         reason=SEARCH_COOLDOWN_REASON,
@@ -553,14 +548,11 @@ async def _cache_hit_result(
     )
     if cached is None:
         return None
-    logger.info(
-        "scholar_search.cache_hit",
-        extra={
-            "event": "scholar_search.cache_hit",
-            "query": normalized_query,
-            "state": cached.state.value,
-            "state_reason": cached.state_reason,
-        },
+    structured_log(
+        logger, "info", "scholar_search.cache_hit",
+        query=normalized_query,
+        state=cached.state.value,
+        state_reason=cached.state_reason,
     )
     state_reason_override = SEARCH_CACHED_BLOCK_REASON if _is_author_search_block_state(cached) else None
     return _trim_author_search_result(
@@ -610,9 +602,10 @@ async def _wait_for_author_search_throttle(
     )
     if sleep_seconds <= 0.0:
         return updated
-    logger.info(
-        "scholar_search.throttle_wait",
-        extra={"event": "scholar_search.throttle_wait", "query": normalized_query, "sleep_seconds": round(sleep_seconds, 3)},
+    structured_log(
+        logger, "info", "scholar_search.throttle_wait",
+        query=normalized_query,
+        sleep_seconds=round(sleep_seconds, 3),
     )
     await asyncio.sleep(sleep_seconds)
     return True
@@ -665,16 +658,13 @@ def _with_retry_warnings(
     threshold = max(1, int(retry_alert_threshold))
     if retry_scheduled_count < threshold:
         return merged
-    logger.warning(
-        "scholar_search.retry_threshold_exceeded",
-        extra={
-            "event": "scholar_search.retry_threshold_exceeded",
-            "query": normalized_query,
-            "retry_scheduled_count": retry_scheduled_count,
-            "threshold": threshold,
-            "final_state": merged.state.value,
-            "final_state_reason": merged.state_reason,
-        },
+    structured_log(
+        logger, "warning", "scholar_search.retry_threshold_exceeded",
+        query=normalized_query,
+        retry_scheduled_count=retry_scheduled_count,
+        threshold=threshold,
+        final_state=merged.state.value,
+        final_state_reason=merged.state_reason,
     )
     return replace(
         merged,
@@ -697,14 +687,11 @@ def _apply_block_circuit_breaker(
         runtime_state.consecutive_blocked_count = 0
         return merged_parsed
     runtime_state.consecutive_blocked_count = int(runtime_state.consecutive_blocked_count) + 1
-    logger.warning(
-        "scholar_search.block_detected",
-        extra={
-            "event": "scholar_search.block_detected",
-            "query": normalized_query,
-            "state_reason": merged_parsed.state_reason,
-            "consecutive_blocked_count": int(runtime_state.consecutive_blocked_count),
-        },
+    structured_log(
+        logger, "warning", "scholar_search.block_detected",
+        query=normalized_query,
+        state_reason=merged_parsed.state_reason,
+        consecutive_blocked_count=int(runtime_state.consecutive_blocked_count),
     )
     if int(runtime_state.consecutive_blocked_count) < max(1, int(cooldown_block_threshold)):
         return merged_parsed
@@ -712,13 +699,10 @@ def _apply_block_circuit_breaker(
     runtime_state.consecutive_blocked_count = 0
     runtime_state.cooldown_rejection_count = 0
     runtime_state.cooldown_alert_emitted = False
-    logger.error(
-        "scholar_search.cooldown_activated",
-        extra={
-            "event": "scholar_search.cooldown_activated",
-            "query": normalized_query,
-            "cooldown_until_utc": runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
-        },
+    structured_log(
+        logger, "error", "scholar_search.cooldown_activated",
+        query=normalized_query,
+        cooldown_until_utc=runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
     )
     return replace(
         merged_parsed,
diff --git a/app/services/domains/unpaywall/application.py b/app/services/domains/unpaywall/application.py
index 13104e9..8b4d528 100644
--- a/app/services/domains/unpaywall/application.py
+++ b/app/services/domains/unpaywall/application.py
@@ -13,6 +13,7 @@ from app.services.domains.unpaywall.pdf_discovery import (
     resolve_pdf_from_landing_page,
 )
 from app.services.domains.unpaywall.rate_limit import wait_for_unpaywall_slot
+from app.logging_utils import structured_log
 from app.settings import settings
 
 if TYPE_CHECKING:
@@ -157,10 +158,7 @@ async def _resolved_pdf_url_from_payload(
     for page_url in _crawl_targets(payload=payload, pdf_candidates=pdf_candidates)[:3]:
         discovered = await resolve_pdf_from_landing_page(client, page_url=page_url)
         if discovered:
-            logger.info(
-                "unpaywall.pdf_discovered_from_landing",
-                extra={"event": "unpaywall.pdf_discovered_from_landing", "landing_url": page_url},
-            )
+            structured_log(logger, "info", "unpaywall.pdf_discovered_from_landing", landing_url=page_url)
             return discovered
     return None
 
@@ -191,27 +189,6 @@ def _email_for_request(request_email: str | None) -> str | None:
     return email or None
 
 
-def _log_resolution_summary(
-    *,
-    publication_count: int,
-    doi_input_count: int,
-    search_attempt_count: int,
-    resolved_pdf_count: int,
-    email: str,
-) -> None:
-    logger.info(
-        "unpaywall.resolve_completed",
-        extra={
-            "event": "unpaywall.resolve_completed",
-            "publication_count": publication_count,
-            "doi_input_count": doi_input_count,
-            "search_attempt_count": search_attempt_count,
-            "resolved_pdf_count": resolved_pdf_count,
-            "email_domain": email.split("@", 1)[-1] if "@" in email else None,
-        },
-    )
-
-
 async def _resolve_item_payload(
     *,
     client,
@@ -370,14 +347,7 @@ async def _safe_outcome_for_item(
             allow_crossref=allow_crossref,
         )
     except Exception as exc:  # pragma: no cover - defensive network boundary
-        logger.warning(
-            "unpaywall.resolve_item_failed",
-            extra={
-                "event": "unpaywall.resolve_item_failed",
-                "publication_id": item.publication_id,
-                "error": str(exc),
-            },
-        )
+        structured_log(logger, "warning", "unpaywall.resolve_item_failed", publication_id=item.publication_id, error=str(exc))
         return _outcome_with_failure(
             item=item,
             failure_reason=FAILURE_RESOLUTION_EXCEPTION,
@@ -439,12 +409,13 @@ async def resolve_publication_oa_outcomes(
             targets=targets,
             email=email,
         )
-    _log_resolution_summary(
+    structured_log(
+        logger, "info", "unpaywall.resolve_completed",
         publication_count=len(items),
         doi_input_count=_doi_input_count(items),
         search_attempt_count=_search_attempt_count(targets=targets),
         resolved_pdf_count=_resolved_pdf_count(outcomes),
-        email=email,
+        email_domain=email.split("@", 1)[-1] if "@" in email else None,
     )
     return outcomes
 
diff --git a/tests/unit/services/domains/arxiv/test_client.py b/tests/unit/services/domains/arxiv/test_client.py
index f1c4c51..445d3cd 100644
--- a/tests/unit/services/domains/arxiv/test_client.py
+++ b/tests/unit/services/domains/arxiv/test_client.py
@@ -147,9 +147,7 @@ async def test_client_logs_cache_hit_and_miss(
         return httpx.Response(200, text=_CLIENT_FEED_XML, request=request)
 
     def _capture_log(_msg: str, *args, **kwargs) -> None:
-        extra = kwargs.get("extra")
-        if isinstance(extra, dict):
-            logged.append(extra)
+        logged.append({"event": _msg, **(kwargs.get("extra") or {})})
 
     monkeypatch.setattr("app.services.domains.arxiv.client.logger.info", _capture_log)
     client = ArxivClient(request_fn=_request_fn, cache_enabled=True)
@@ -183,9 +181,7 @@ async def test_request_feed_skips_live_call_when_global_cooldown_is_active(
         return httpx.Response(200, text=_CLIENT_FEED_XML)
 
     def _capture_warning(_msg: str, *args, **kwargs) -> None:
-        extra = kwargs.get("extra")
-        if isinstance(extra, dict):
-            logged.append(extra)
+        logged.append({"event": _msg, **(kwargs.get("extra") or {})})
 
     monkeypatch.setattr(arxiv_client_module, "get_arxiv_cooldown_status", _cooldown_status)
     monkeypatch.setattr(arxiv_client_module, "run_with_global_arxiv_limit", _unexpected_limit_call)
diff --git a/tests/unit/services/domains/arxiv/test_rate_limit.py b/tests/unit/services/domains/arxiv/test_rate_limit.py
index 4e5623b..86ad949 100644
--- a/tests/unit/services/domains/arxiv/test_rate_limit.py
+++ b/tests/unit/services/domains/arxiv/test_rate_limit.py
@@ -95,9 +95,7 @@ async def test_arxiv_rate_limit_logs_request_scheduled_and_completed(
         return httpx.Response(200, text="ok")
 
     def _capture_log(_msg: str, *args, **kwargs) -> None:
-        extra = kwargs.get("extra")
-        if isinstance(extra, dict):
-            logged.append(extra)
+        logged.append({"event": _msg, **(kwargs.get("extra") or {})})
 
     monkeypatch.setattr("app.services.domains.arxiv.rate_limit.logger.info", _capture_log)
     await run_with_global_arxiv_limit(fetch=_fetch, source_path="search")
@@ -126,9 +124,7 @@ async def test_arxiv_rate_limit_logs_cooldown_activation(
             return httpx.Response(429, text="rate limited")
 
         def _capture_warning(_msg: str, *args, **kwargs) -> None:
-            extra = kwargs.get("extra")
-            if isinstance(extra, dict):
-                logged_warning.append(extra)
+            logged_warning.append({"event": _msg, **(kwargs.get("extra") or {})})
 
         monkeypatch.setattr("app.services.domains.arxiv.rate_limit.logger.warning", _capture_warning)
         with pytest.raises(ArxivRateLimitError):
-- 
2.49.1


From fa56168fb115a15ec68d814c279c8740bcc20841 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Thu, 26 Feb 2026 22:05:18 +0100
Subject: [PATCH 09/38] refactor: reduce log noise, improve event naming and
 console readability

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/api/routers/admin_dbops.py                 |  4 ++--
 app/api/routers/scholars.py                    |  2 +-
 app/logging_config.py                          | 11 ++++++++++-
 app/services/domains/ingestion/application.py  | 18 +++---------------
 app/services/domains/publications/pdf_queue.py |  4 ++--
 .../publications/pdf_resolution_pipeline.py    | 10 +++++-----
 app/services/domains/scholar/source.py         | 17 -----------------
 tests/unit/test_logging.py                     |  2 +-
 8 files changed, 24 insertions(+), 44 deletions(-)

diff --git a/app/api/routers/admin_dbops.py b/app/api/routers/admin_dbops.py
index 8230ab9..57498c1 100644
--- a/app/api/routers/admin_dbops.py
+++ b/app/api/routers/admin_dbops.py
@@ -232,7 +232,7 @@ async def requeue_pdf_lookup(
             message="Publication not found.",
         )
     status, message = _requeue_response_state(queued=result.queued)
-    structured_log(logger, "info", "api.admin.db.pdf_queue_requeue_requested", admin_user_id=int(admin_user.id), publication_id=int(publication_id), queued=bool(result.queued))
+    structured_log(logger, "info", "api.admin.db.pdf_requeued", admin_user_id=int(admin_user.id), publication_id=int(publication_id), queued=bool(result.queued))
     return success_payload(
         request,
         data={
@@ -340,7 +340,7 @@ async def trigger_publication_near_duplicate_repair(
             code="invalid_near_duplicate_repair_request",
             message=str(exc),
         ) from exc
-    structured_log(logger, "info", "api.admin.db.publication_near_duplicate_repair_triggered", admin_user_id=int(admin_user.id), dry_run=bool(payload.dry_run), selected_cluster_count=len(payload.selected_cluster_keys), job_id=int(result["job_id"]), status=result["status"])
+    structured_log(logger, "info", "api.admin.db.dedup_repair_triggered", admin_user_id=int(admin_user.id), dry_run=bool(payload.dry_run), selected_cluster_count=len(payload.selected_cluster_keys), job_id=int(result["job_id"]), status=result["status"])
     return success_payload(request, data=result)
 
 
diff --git a/app/api/routers/scholars.py b/app/api/routers/scholars.py
index f0784fe..c0a281b 100644
--- a/app/api/routers/scholars.py
+++ b/app/api/routers/scholars.py
@@ -575,7 +575,7 @@ async def clear_scholar_image_customization(
         profile=profile,
         upload_dir=settings.scholar_image_upload_dir,
     )
-    structured_log(logger, "info", "api.scholars.image_customization_cleared", user_id=current_user.id, scholar_profile_id=updated.id)
+    structured_log(logger, "info", "api.scholars.image_cleared", user_id=current_user.id, scholar_profile_id=updated.id)
     return success_payload(
         request,
         data=_serialize_scholar(updated),
diff --git a/app/logging_config.py b/app/logging_config.py
index 22907be..559a400 100644
--- a/app/logging_config.py
+++ b/app/logging_config.py
@@ -108,6 +108,14 @@ class JsonLogFormatter(logging.Formatter):
         return value
 
 
+_CONSOLE_SHORT_KEYS = {
+    "user_id": "user",
+    "scholar_id": "scholar",
+    "crawl_run_id": "run",
+    "run_id": "run",
+}
+
+
 class ConsoleLogFormatter(logging.Formatter):
     def __init__(self, *, redact_fields: set[str]) -> None:
         super().__init__()
@@ -140,7 +148,8 @@ class ConsoleLogFormatter(logging.Formatter):
         for key in sorted(payload.keys()):
             if key in {"timestamp", "level", "logger", "event", "exception"}:
                 continue
-            parts.append(f"{key}={payload[key]}")
+            display_key = _CONSOLE_SHORT_KEYS.get(key, key)
+            parts.append(f"{display_key}={payload[key]}")
 
         if "exception" in payload:
             parts.append(f"exception={payload['exception']}")
diff --git a/app/services/domains/ingestion/application.py b/app/services/domains/ingestion/application.py
index da37c88..4b619d7 100644
--- a/app/services/domains/ingestion/application.py
+++ b/app/services/domains/ingestion/application.py
@@ -153,7 +153,7 @@ class ScholarIngestionService:
             await db_session.commit()
             await db_session.refresh(user_settings)
             structured_log(
-                logger, "info", "ingestion.safety_cooldown_cleared",
+                logger, "info", "ingestion.cooldown_cleared",
                 user_id=user_id,
                 reason=previous.get("cooldown_reason"),
                 cooldown_until=previous.get("cooldown_until"),
@@ -962,7 +962,7 @@ class ScholarIngestionService:
             )
         elif pre_apply_state.get("cooldown_active") and not safety_state.get("cooldown_active"):
             structured_log(
-                logger, "info", "ingestion.safety_cooldown_cleared",
+                logger, "info", "ingestion.cooldown_cleared",
                 user_id=user_id,
                 crawl_run_id=int(run.id),
                 reason=pre_apply_state.get("cooldown_reason"),
@@ -1319,7 +1319,7 @@ class ScholarIngestionService:
         effective_delay = self._effective_request_delay_seconds(request_delay_seconds)
         if effective_delay != _int_or_default(request_delay_seconds, effective_delay):
             structured_log(
-                logger, "warning", "ingestion.request_delay_coerced_to_policy_floor",
+                logger, "warning", "ingestion.delay_coerced",
                 user_id=user_id,
                 requested_request_delay_seconds=_int_or_default(request_delay_seconds, 0),
                 effective_request_delay_seconds=effective_delay,
@@ -2596,13 +2596,6 @@ class ScholarIngestionService:
             db_session.add(link)
             discovered_count += 1
 
-            structured_log(
-                logger, "debug", "ingestion.publication_discovered",
-                scholar_profile_id=scholar.id,
-                publication_id=publication.id,
-                crawl_run_id=run.id,
-            )
-            
             await self._commit_discovered_publication(
                 db_session,
                 run=run,
@@ -2720,11 +2713,6 @@ class ScholarIngestionService:
         )
         db_session.add(publication)
         await db_session.flush()
-        structured_log(
-            logger, "debug", "ingestion.publication_created",
-            publication_id=publication.id,
-            cluster_id=publication.cluster_id,
-        )
         return publication
 
     @staticmethod
diff --git a/app/services/domains/publications/pdf_queue.py b/app/services/domains/publications/pdf_queue.py
index 83c9031..0313f11 100644
--- a/app/services/domains/publications/pdf_queue.py
+++ b/app/services/domains/publications/pdf_queue.py
@@ -514,9 +514,9 @@ async def _run_resolution_task(
             )
             if arxiv_rate_limited and arxiv_lookup_allowed:
                 arxiv_lookup_allowed = False
-                structured_log(logger, "warning", "publications.pdf_queue.arxiv_batch_disabled", detail="arXiv temporarily disabled for remaining batch after rate limit")
+                structured_log(logger, "warning", "pdf_queue.arxiv_batch_disabled", detail="arXiv temporarily disabled for remaining batch after rate limit")
         except OpenAlexBudgetExhaustedError:
-            structured_log(logger, "warning", "publications.pdf_queue.budget_exhausted", detail="Stopping PDF resolution batch — OpenAlex daily budget exhausted")
+            structured_log(logger, "warning", "pdf_queue.budget_exhausted", detail="Stopping PDF resolution batch — OpenAlex daily budget exhausted")
             break
 
 
diff --git a/app/services/domains/publications/pdf_resolution_pipeline.py b/app/services/domains/publications/pdf_resolution_pipeline.py
index f17d65b..37efa6b 100644
--- a/app/services/domains/publications/pdf_resolution_pipeline.py
+++ b/app/services/domains/publications/pdf_resolution_pipeline.py
@@ -45,7 +45,7 @@ async def resolve_publication_pdf_outcome_for_row(
     except ArxivRateLimitError:
         arxiv_rate_limited = True
         arxiv_outcome = None
-        structured_log(logger, "warning", "publications.pdf_resolution.arxiv_rate_limited", publication_id=int(row.publication_id))
+        structured_log(logger, "warning", "pdf_resolution.arxiv_rate_limited", publication_id=int(row.publication_id))
     if arxiv_outcome and arxiv_outcome.pdf_url:
         return PipelineOutcome(arxiv_outcome, None, arxiv_rate_limited=arxiv_rate_limited)
 
@@ -94,7 +94,7 @@ async def _openalex_outcome(
         # Re-raise so the caller's batch loop can stop hitting the API.
         raise
     except Exception as exc:
-        structured_log(logger, "warning", "publications.pdf_resolution.openalex_failed", error=str(exc))
+        structured_log(logger, "warning", "pdf_resolution.openalex_failed", error=str(exc))
     return None
 
 
@@ -107,12 +107,12 @@ async def _arxiv_outcome(
     from app.services.domains.arxiv.application import discover_arxiv_id_for_publication
 
     if not allow_lookup:
-        structured_log(logger, "info", "publications.pdf_resolution.arxiv_skipped", publication_id=int(row.publication_id), skip_reason="batch_arxiv_cooldown_active")
+        structured_log(logger, "info", "pdf_resolution.arxiv_skipped", publication_id=int(row.publication_id), skip_reason="batch_arxiv_cooldown_active")
         return None
 
     skip_reason = arxiv_skip_reason_for_item(item=row)
     if skip_reason is not None:
-        structured_log(logger, "info", "publications.pdf_resolution.arxiv_skipped", publication_id=int(row.publication_id), skip_reason=skip_reason)
+        structured_log(logger, "info", "pdf_resolution.arxiv_skipped", publication_id=int(row.publication_id), skip_reason=skip_reason)
         return None
 
     try:
@@ -130,7 +130,7 @@ async def _arxiv_outcome(
     except ArxivRateLimitError:
         raise  # propagate so orchestration can switch to non-arXiv fallback
     except Exception as exc:
-        structured_log(logger, "warning", "publications.pdf_resolution.arxiv_failed", error=str(exc))
+        structured_log(logger, "warning", "pdf_resolution.arxiv_failed", error=str(exc))
     return None
 
 
diff --git a/app/services/domains/scholar/source.py b/app/services/domains/scholar/source.py
index 50d27ca..7e34f01 100644
--- a/app/services/domains/scholar/source.py
+++ b/app/services/domains/scholar/source.py
@@ -101,13 +101,6 @@ class LiveScholarSource:
             cstart=cstart,
             pagesize=pagesize,
         )
-        structured_log(
-            logger, "debug", "scholar_source.fetch_started",
-            scholar_id=scholar_id,
-            requested_url=requested_url,
-            cstart=cstart,
-            pagesize=pagesize,
-        )
         return await self._fetch_with_global_throttle(requested_url)
 
     async def fetch_author_search_html(
@@ -120,19 +113,9 @@ class LiveScholarSource:
             query=query,
             start=start,
         )
-        structured_log(
-            logger, "debug", "scholar_source.search_fetch_started",
-            query=query,
-            requested_url=requested_url,
-            start=start,
-        )
         return await self._fetch_with_global_throttle(requested_url)
 
     async def fetch_publication_html(self, publication_url: str) -> FetchResult:
-        structured_log(
-            logger, "debug", "scholar_source.publication_fetch_started",
-            requested_url=publication_url,
-        )
         return await self._fetch_with_global_throttle(publication_url)
 
     async def _fetch_with_global_throttle(self, requested_url: str) -> FetchResult:
diff --git a/tests/unit/test_logging.py b/tests/unit/test_logging.py
index 2a08d4c..696cb2a 100644
--- a/tests/unit/test_logging.py
+++ b/tests/unit/test_logging.py
@@ -82,7 +82,7 @@ def test_structured_log_console_formatter(caplog) -> None:
     output = formatter.format(record)
 
     assert "export.failed" in output
-    assert "scholar_id=7" in output
+    assert "scholar=7" in output
 
 
 def test_structured_log_strips_metric_fields(caplog) -> None:
-- 
2.49.1


From 399276ea6977d35fa0cd632e4e73190d4bb915bc Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Thu, 26 Feb 2026 22:07:58 +0100
Subject: [PATCH 10/38] fix: use importlib import mode to resolve test module
 name collisions

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 27426bc..4990b4b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,7 +30,7 @@ dev = [
 ]
 
 [tool.pytest.ini_options]
-addopts = "-q -m \"not integration\""
+addopts = "-q -m \"not integration\" --import-mode=importlib"
 asyncio_mode = "auto"
 testpaths = ["tests"]
 markers = [
-- 
2.49.1


From bf04c77aa92642bb67402cf1ef6e753ebaf6ee4d Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Thu, 26 Feb 2026 22:11:41 +0100
Subject: [PATCH 11/38] ci: add ruff linting and mypy type checking

Add ruff and mypy to dev dependencies with configuration in pyproject.toml.
Add a lint CI job that runs ruff check, ruff format --check, and mypy.
Auto-fix import sorting and formatting across the codebase. Exclude
alembic/versions from linting (auto-generated migrations). Ignore B008
(FastAPI Depends pattern) and RUF001 (unicode in user-facing strings).

21 ruff lint errors and 50 mypy errors remain for manual review.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/workflows/ci.yml                      |   18 +
 MODERNIZATION_PLAN.md                         |  628 +++++++
 alembic/env.py                                |    6 +-
 .../20260216_0001_multi_user_schema.py        |    3 +-
 .../20260216_0002_add_user_admin_flag.py      |    4 +-
 .../20260216_0003_add_ingestion_queue.py      |    3 +-
 .../20260217_0004_queue_status_fields.py      |   11 +-
 .../20260217_0005_manual_run_idempotency.py   |    7 +-
 .../20260217_0006_scholar_profile_images.py   |    3 +-
 ...7_0007_scholar_initial_page_fingerprint.py |    3 +-
 ...19_0008_user_settings_nav_visible_pages.py |    4 +-
 ..._0009_user_settings_scrape_safety_state.py |    2 +-
 ...0260219_0010_author_search_shared_state.py |    2 +-
 .../20260220_0011_add_publication_doi.py      |    2 +-
 .../20260220_0012_add_data_repair_jobs.py     |    2 +-
 .../20260221_0013_add_publication_pdf_jobs.py |    2 +-
 ..._add_scholar_publication_favorite_state.py |    2 +-
 ...260221_0015_enforce_request_delay_floor.py |   15 +-
 ...260222_0016_add_publication_identifiers.py |    2 +-
 ...8_add_openalex_enriched_to_publications.py |   13 +-
 ...0260224_0019_add_resolving_to_runstatus.py |    6 +-
 ...60224_0020_add_openalex_last_attempt_at.py |   11 +-
 ...0021_enforce_single_active_run_per_user.py |    6 +-
 ...dd_canonical_title_hash_to_publications.py |    2 +-
 .../20260226_0023_add_arxiv_runtime_state.py  |    2 +-
 ...0226_0024_add_arxiv_query_cache_entries.py |    2 +-
 app/api/__init__.py                           |    1 -
 app/api/errors.py                             |    1 -
 app/api/routers/__init__.py                   |    1 -
 app/api/routers/admin.py                      |   32 +-
 app/api/routers/admin_dbops.py                |   82 +-
 app/api/routers/auth.py                       |   20 +-
 app/api/routers/publications.py               |   42 +-
 app/api/routers/runs.py                       |   84 +-
 app/api/routers/scholars.py                   |   70 +-
 app/api/routers/settings.py                   |    8 +-
 app/api/schemas.py                            |   14 +-
 app/auth/__init__.py                          |    1 -
 app/auth/deps.py                              |    1 -
 app/auth/runtime.py                           |    2 +-
 app/auth/security.py                          |    1 -
 app/auth/service.py                           |    4 +-
 app/auth/session.py                           |    1 -
 app/db/base.py                                |    5 +-
 app/db/models.py                              |  214 +--
 app/db/session.py                             |   10 +-
 app/http/middleware.py                        |   16 +-
 app/logging_config.py                         |    8 +-
 app/logging_context.py                        |    2 -
 app/main.py                                   |   24 +-
 app/security/__init__.py                      |    1 -
 app/security/csrf.py                          |    8 +-
 app/services/__init__.py                      |    1 -
 app/services/domains/arxiv/application.py     |    2 +-
 app/services/domains/arxiv/cache.py           |   64 +-
 app/services/domains/arxiv/client.py          |   20 +-
 app/services/domains/arxiv/gateway.py         |    2 +-
 app/services/domains/arxiv/rate_limit.py      |   52 +-
 app/services/domains/crossref/application.py  |    4 +-
 app/services/domains/dbops/__init__.py        |    2 +-
 app/services/domains/dbops/application.py     |   23 +-
 app/services/domains/dbops/integrity.py       |    4 +-
 .../domains/dbops/near_duplicate_repair.py    |    4 +-
 app/services/domains/dbops/query.py           |    4 +-
 app/services/domains/ingestion/application.py |  372 +++--
 .../domains/ingestion/fingerprints.py         |    6 +-
 app/services/domains/ingestion/queue.py       |   44 +-
 app/services/domains/ingestion/safety.py      |   20 +-
 app/services/domains/ingestion/scheduler.py   |  139 +-
 app/services/domains/openalex/client.py       |   20 +-
 app/services/domains/openalex/matching.py     |   27 +-
 app/services/domains/openalex/types.py        |   12 +-
 .../domains/portability/application.py        |    4 +-
 app/services/domains/portability/exporting.py |    8 +-
 app/services/domains/portability/normalize.py |    4 +-
 .../domains/portability/publication_import.py |   10 +-
 .../domains/portability/scholar_import.py     |    8 +-
 .../publication_identifiers/__init__.py       |    4 +-
 .../publication_identifiers/application.py    |   18 +-
 .../domains/publications/application.py       |   60 +-
 app/services/domains/publications/dedup.py    |   18 +-
 .../domains/publications/enrichment.py        |   15 +-
 app/services/domains/publications/listing.py  |    5 +-
 .../domains/publications/pdf_queue.py         |   45 +-
 .../publications/pdf_resolution_pipeline.py   |   22 +-
 app/services/domains/publications/queries.py  |    4 +-
 .../domains/publications/read_state.py        |    6 +-
 app/services/domains/runs/application.py      |   18 +-
 app/services/domains/runs/events.py           |   17 +-
 app/services/domains/runs/queue_service.py    |    4 +-
 app/services/domains/runs/runs_service.py     |    4 +-
 app/services/domains/runs/summary.py          |   10 +-
 app/services/domains/scholar/author_rows.py   |    9 +-
 app/services/domains/scholar/parser.py        |   11 -
 app/services/domains/scholar/profile_rows.py  |    3 +-
 app/services/domains/scholar/source.py        |   31 +-
 app/services/domains/scholars/application.py  |  137 +-
 app/services/domains/scholars/constants.py    |   30 +-
 app/services/domains/scholars/search_hints.py |    2 +-
 app/services/domains/scholars/validators.py   |    4 +-
 app/services/domains/settings/application.py  |   17 +-
 app/services/domains/unpaywall/application.py |   24 +-
 .../domains/unpaywall/pdf_discovery.py        |    2 +-
 app/services/domains/users/application.py     |    5 +-
 app/settings.py                               |    4 +-
 frontend/src/theme/presets/deutan-blue.js     |  313 ++++
 pyproject.toml                                |   20 +
 scripts/check_frontend_api_contract.py        |    4 +-
 tests/conftest.py                             |   12 +-
 tests/integration/helpers.py                  |    1 +
 tests/integration/test_api_v1.py              |   27 +-
 tests/integration/test_data_repair_jobs.py    |    5 +-
 tests/integration/test_deferred_enrichment.py |   40 +-
 tests/integration/test_fixture_probe_runs.py  |    3 +-
 tests/integration/test_migrations.py          |    4 +-
 .../test_run_lifecycle_consistency.py         |    6 +-
 tests/smoke/test_db_connectivity.py           |    1 -
 tests/smoke/test_migration_schema.py          |    2 +-
 .../unit/services/domains/arxiv/test_cache.py |    9 +-
 .../services/domains/arxiv/test_client.py     |   25 +-
 .../services/domains/arxiv/test_guards.py     |    4 +-
 .../services/domains/arxiv/test_parser.py     |    4 +-
 .../services/domains/arxiv/test_rate_limit.py |   14 +-
 .../services/domains/openalex/test_client.py  |   24 +-
 .../domains/openalex/test_matching.py         |   46 +-
 .../domains/publications/test_dedup.py        |   12 +-
 tests/unit/test_fingerprints.py               |   91 +-
 tests/unit/test_ingestion_arxiv_rate_limit.py |    1 +
 tests/unit/test_logging.py                    |    2 +-
 .../unit/test_publication_pdf_queue_policy.py |   18 +-
 ...est_publication_pdf_resolution_pipeline.py |    8 +-
 tests/unit/test_request_delay_policy.py       |    6 +-
 tests/unit/test_run_safety.py                 |   12 +-
 tests/unit/test_scholar_search_safety.py      |    5 +-
 tests/unit/test_unpaywall_pdf_discovery.py    |    6 +-
 tests/unit/test_unpaywall_resolution.py       |    6 +-
 uv.lock                                       | 1436 +++++++++--------
 137 files changed, 3066 insertions(+), 1900 deletions(-)
 create mode 100644 MODERNIZATION_PLAN.md
 create mode 100644 frontend/src/theme/presets/deutan-blue.js

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f82312a..b5c86ea 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,10 +20,28 @@ jobs:
       - name: Enforce env contract parity
         run: python3 scripts/check_env_contract.py
 
+  lint:
+    runs-on: ubuntu-latest
+    needs: [repo-hygiene]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - uses: astral-sh/setup-uv@v4
+      - run: uv sync --extra dev
+      - name: Ruff check
+        run: uv run ruff check .
+      - name: Ruff format check
+        run: uv run ruff format --check .
+      - name: Mypy
+        run: uv run mypy app/ --ignore-missing-imports
+
   test:
     runs-on: ubuntu-latest
     needs:
       - repo-hygiene
+      - lint
     services:
       postgres:
         image: postgres:15
diff --git a/MODERNIZATION_PLAN.md b/MODERNIZATION_PLAN.md
new file mode 100644
index 0000000..6460767
--- /dev/null
+++ b/MODERNIZATION_PLAN.md
@@ -0,0 +1,628 @@
+# Scholarr Modernization Plan — Slices 2-10
+
+> **Slice 1 is complete** (commit `7736cab`): removed 114 stale `build/` files, fixed `.gitignore`, committed pending deletions, replaced `npm install` with `npm ci` in CI.
+>
+> Each slice below is a self-contained prompt designed for an LLM executor. Execute in order — each slice depends on the prior ones being complete.
+
+---
+
+## Slice 2: Create `structured_log()` Utility
+
+**Why:** The codebase has 19 `_log_*` helper functions (422 lines) and 138 instances of duplicated `"event"` keys in logging calls. A single utility eliminates all of it.
+
+**Files to create:**
+- `app/logging_utils.py`
+
+**Files to modify:**
+- `tests/unit/test_logging.py`
+
+**Context files (read but don't modify):**
+- `app/logging_config.py` — line 88 has `"event": getattr(record, "event", record.getMessage())` which means when no `event` key is in `extra`, it falls back to `getMessage()`. This is the mechanism that makes `structured_log()` work without duplicating the event name.
+- `app/logging_context.py`
+
+**Prompt:**
+```
+You are working on the scholarr repository. The current logging pattern has a DRY problem:
+
+1. Every log call duplicates the event name as both the message and in extra["event"]:
+   `logger.info("event.name", extra={"event": "event.name", "key": value})`
+
+2. There are 19 `_log_*` helper functions (422 lines total) that just wrap logger calls with typed signatures to build extra dicts.
+
+3. Metrics data (metric_name/metric_value) is mixed into log extra dicts but has no consumer.
+
+Create `app/logging_utils.py`:
+
+```python
+"""Structured logging utility — eliminates boilerplate across domain services."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+
+def structured_log(
+    logger: logging.Logger,
+    level: str,
+    event: str,
+    /,
+    **fields: Any,
+) -> None:
+    """Emit a structured log entry.
+
+    The event name is passed as the log message. The JsonLogFormatter in
+    logging_config.py extracts it via record.getMessage() when no explicit
+    'event' key exists in extra — so we do NOT duplicate it.
+
+    Usage:
+        structured_log(logger, "info", "ingestion.run_started", user_id=1, scholar_count=5)
+    """
+    fields.pop("metric_name", None)
+    fields.pop("metric_value", None)
+
+    log_method = getattr(logger, level.lower())
+    log_method(event, extra=fields)
+```
+
+Verify that `app/logging_config.py` line 88 already handles this correctly — when no `event` key is in extra, it falls back to getMessage() which returns the event string passed as the first argument. No changes to logging_config.py should be needed.
+
+Add tests in `tests/unit/test_logging.py` (append to existing file):
+- Test that `structured_log()` produces a log record where the JsonLogFormatter outputs the event name correctly
+- Test that `structured_log()` works with ConsoleLogFormatter
+- Test that metric_name/metric_value fields are stripped from output
+- Test that extra fields (user_id, scholar_id, etc.) appear in the formatted output
+
+Commit message: "refactor: add structured_log utility to eliminate logging boilerplate"
+```
+
+---
+
+## Slice 3: Migrate Ingestion Logging to `structured_log()`
+
+**Why:** `app/services/domains/ingestion/application.py` is 3,089 lines. 8 `_log_*` helpers consume ~239 lines. 34 inline logger calls duplicate event names and include dead metric fields. This slice removes ~300 lines.
+
+**Files to modify:**
+- `app/services/domains/ingestion/application.py`
+
+**Context files:**
+- `app/logging_utils.py` (created in Slice 2)
+
+**Prompt:**
+```
+You are working on the scholarr repository. The file `app/services/domains/ingestion/application.py` (3,089 lines) has 8 `_log_*` helper functions consuming ~239 lines, plus 34 inline logger calls with duplicated `"event":` keys and mixed `metric_name`/`metric_value` fields.
+
+Migrate ALL logging in this file to use `structured_log()` from `app.logging_utils`.
+
+1. Add `from app.logging_utils import structured_log` at the top.
+
+2. Delete these 8 helper methods entirely:
+   - `_log_request_delay_coercion` (line ~123, 21 lines)
+   - `_log_run_started` (line ~310, 36 lines)
+   - `_log_scholar_parsed` (line ~383, 28 lines)
+   - `_log_alert_thresholds` (line ~1013, 47 lines)
+   - `_log_safety_transition` (line ~1093, 42 lines)
+   - `_log_run_completed` (line ~1178, 28 lines)
+   - `_attempt_log_entry` (line ~1837, 16 lines)
+   - `_page_log_entry` (line ~1999, 21 lines)
+
+3. Replace every call to these deleted helpers with an inline `structured_log()` call. Example:
+
+   Before:
+   ```python
+   self._log_run_started(
+       user_id=user_id,
+       trigger_type=trigger_type,
+       scholar_count=scholar_count,
+       ...
+   )
+   ```
+
+   After:
+   ```python
+   structured_log(
+       logger, "info", "ingestion.run_started",
+       user_id=user_id,
+       trigger_type=trigger_type.value,
+       scholar_count=scholar_count,
+       ...
+   )
+   ```
+
+4. For ALL remaining inline `logger.info/warning/debug/exception()` calls:
+   - Replace with `structured_log()` where the call uses `extra={"event": ..., ...}` pattern
+   - Do NOT convert `logger.exception()` calls — keep them but remove the duplicated `"event"` key from their extra dict
+   - Remove `metric_name` and `metric_value` from all calls
+
+5. Do NOT change any business logic. Only logging call sites.
+
+Expected outcome: ~300 lines removed. All existing tests must pass unchanged.
+
+Commit message: "refactor: migrate ingestion service logging to structured_log"
+```
+
+---
+
+## Slice 4: Migrate All Remaining Services to `structured_log()`
+
+**Why:** 11 more `_log_*` helpers remain across 8 files (183 lines total), plus inline logger calls with the same duplication pattern in ~20 files.
+
+**Files to modify (all have `_log_*` helpers to delete):**
+- `app/services/domains/ingestion/scheduler.py` — `_log_queue_item_resolved` (line ~518, 21 lines)
+- `app/services/domains/arxiv/rate_limit.py` — `_log_request_scheduled` (199), `_log_request_completed` (216), `_log_cooldown_activated` (235)
+- `app/services/domains/arxiv/client.py` — `_log_cache_event` (283), `_log_request_skipped_for_cooldown` (299)
+- `app/services/domains/publications/pdf_resolution_pipeline.py` — `_log_arxiv_skip` (148)
+- `app/services/domains/unpaywall/application.py` — `_log_resolution_summary` (194)
+- `app/api/routers/publications.py` — `_log_retry_pdf_result` (343)
+- `app/api/routers/settings.py` — `_log_settings_update` (103)
+- `app/main.py` — `_log_startup_build_marker` (53)
+
+**Files to modify (inline `extra={"event":...}` pattern only — no helpers to delete):**
+- `app/http/middleware.py`
+- `app/db/session.py`
+- `app/auth/runtime.py`
+- `app/security/csrf.py`
+- `app/api/routers/scholars.py`
+- `app/api/routers/runs.py`
+- `app/api/routers/admin_dbops.py`
+- `app/api/routers/admin.py`
+- `app/api/routers/auth.py`
+- `app/api/routers/publications.py`
+- `app/services/domains/scholars/application.py`
+- `app/services/domains/runs/events.py`
+- `app/services/domains/openalex/client.py`
+- `app/services/domains/openalex/matching.py`
+- `app/services/domains/crossref/application.py`
+- `app/services/domains/publications/dedup.py`
+- `app/services/domains/publications/enrichment.py`
+- `app/services/domains/publications/pdf_queue.py`
+- `app/services/domains/scholar/source.py`
+- `app/services/domains/arxiv/gateway.py`
+
+**Prompt:**
+```
+You are working on the scholarr repository. Slice 3 migrated `ingestion/application.py` to `structured_log()`. Now do the same for ALL remaining files.
+
+1. Delete these `_log_*` helper functions and replace their call sites with inline `structured_log()`:
+
+   - `app/services/domains/ingestion/scheduler.py:~518` — `_log_queue_item_resolved` (21 lines)
+   - `app/services/domains/arxiv/rate_limit.py:~199` — `_log_request_scheduled` (17 lines)
+   - `app/services/domains/arxiv/rate_limit.py:~216` — `_log_request_completed` (19 lines)
+   - `app/services/domains/arxiv/rate_limit.py:~235` — `_log_cooldown_activated` (13 lines)
+   - `app/services/domains/arxiv/client.py:~283` — `_log_cache_event` (16 lines)
+   - `app/services/domains/arxiv/client.py:~299` — `_log_request_skipped_for_cooldown` (13 lines)
+   - `app/services/domains/publications/pdf_resolution_pipeline.py:~148` — `_log_arxiv_skip` (11 lines)
+   - `app/services/domains/unpaywall/application.py:~194` — `_log_resolution_summary` (21 lines)
+   - `app/api/routers/publications.py:~343` — `_log_retry_pdf_result` (24 lines)
+   - `app/api/routers/settings.py:~103` — `_log_settings_update` (15 lines)
+   - `app/main.py:~53` — `_log_startup_build_marker` (13 lines)
+
+2. In ALL files under `app/` that have inline `logger.info/warning/debug("event.name", extra={"event": "event.name", ...})` calls:
+   - Replace with `structured_log(logger, "level", "event.name", key=value, ...)`
+   - Add `from app.logging_utils import structured_log` import
+   - Remove `metric_name`/`metric_value` from all calls
+   - Keep `logger.exception()` calls but remove the duplicated `"event"` key from their extra dicts
+
+3. In `app/services/domains/openalex/client.py`, the lines that log `response.text` (lines ~87, ~137):
+   - Truncate: `response.text[:500]`
+
+4. Do NOT change any business logic. Only logging call sites.
+
+Verify: `grep -rn '"event":' app/ --include="*.py" | grep -v __pycache__` should return 0 matches.
+Verify: `grep -rn 'def _log_' app/ --include="*.py"` should return 0 matches.
+
+Commit message: "refactor: migrate all remaining logging to structured_log, remove boilerplate helpers"
+```
+
+---
+
+## Slice 5: Logging Relevance Audit — Reduce Noise, Improve Readability
+
+**Why:** Self-hosted users need clear, actionable logs. Current logging has verbose debug noise (per-HTTP-request, per-publication), overly long event names, and no console display optimization.
+
+**Files to modify:**
+- `app/services/domains/scholar/source.py`
+- `app/services/domains/ingestion/application.py`
+- `app/logging_config.py`
+- Any files with event names longer than ~40 chars
+
+**Prompt:**
+```
+You are working on the scholarr repository. The logging has been migrated to `structured_log()` (slices 2-4). Now audit log RELEVANCE and READABILITY for self-hosted users running this in Docker.
+
+1. **Remove redundant debug logs:**
+   - `app/services/domains/scholar/source.py`: Remove the 3 debug-level HTTP fetch events (fetch_started, search_fetch_started, publication_fetch_started). Keep only `fetch_succeeded` at DEBUG. The HTTP middleware already logs request.started/completed.
+   - `app/services/domains/ingestion/application.py`: Remove per-publication `publication.discovered` and `publication.created` DEBUG logs. The run_completed summary already reports totals.
+
+2. **Shorten overly long event names** (search all structured_log calls in app/):
+   - `ingestion.request_delay_coerced_to_policy_floor` → `ingestion.delay_coerced`
+   - `ingestion.safety_cooldown_cleared` → `ingestion.cooldown_cleared`
+   - Any other names longer than ~40 chars — shorten while preserving meaning
+
+3. **Improve console readability** in `app/logging_config.py` `ConsoleLogFormatter.format()`:
+   - Add a short-name mapping for common context fields in console output ONLY (JSON keeps full names):
+     ```python
+     _CONSOLE_SHORT_KEYS = {
+         "user_id": "user",
+         "scholar_id": "scholar",
+         "crawl_run_id": "run",
+         "run_id": "run",
+     }
+     ```
+   - Apply in the `for key in sorted(payload.keys())` loop
+
+4. Do NOT remove any WARNING or ERROR level logs. Only remove/demote DEBUG/INFO that are redundant.
+5. Do NOT change business logic.
+
+Commit message: "refactor: reduce log noise, improve event naming and console readability"
+```
+
+---
+
+## Slice 6: Add Ruff + Mypy to CI
+
+**Why:** No Python linting or type checking in CI. Code quality regressions go undetected.
+
+**Files to modify:**
+- `pyproject.toml`
+- `.github/workflows/ci.yml`
+
+**Prompt:**
+```
+You are working on the scholarr repository. Add Python linting and type checking to CI.
+
+1. In `pyproject.toml`, add ruff configuration:
+   ```toml
+   [tool.ruff]
+   target-version = "py312"
+   line-length = 120
+
+   [tool.ruff.lint]
+   select = ["E", "F", "W", "I", "UP", "B", "SIM", "RUF"]
+   ignore = ["E501"]
+
+   [tool.ruff.lint.isort]
+   known-first-party = ["app"]
+   ```
+
+2. In `pyproject.toml`, add mypy configuration:
+   ```toml
+   [tool.mypy]
+   python_version = "3.12"
+   ignore_missing_imports = true
+   check_untyped_defs = false
+   warn_unused_ignores = true
+   ```
+
+3. In `.github/workflows/ci.yml`, add a `lint` job after `repo-hygiene` and before `test`:
+   ```yaml
+   lint:
+     runs-on: ubuntu-latest
+     needs: [repo-hygiene]
+     steps:
+       - uses: actions/checkout@v4
+       - uses: actions/setup-python@v5
+         with:
+           python-version: "3.12"
+       - uses: astral-sh/setup-uv@v4
+       - run: uv sync --extra dev
+       - name: Ruff check
+         run: uv run ruff check .
+       - name: Ruff format check
+         run: uv run ruff format --check .
+       - name: Mypy
+         run: uv run mypy app/ --ignore-missing-imports
+   ```
+
+4. Update the `test` job's `needs` to include `lint`.
+
+5. Add `ruff` and `mypy` to dev dependencies in `pyproject.toml` under `[project.optional-dependencies]`.
+
+6. Run `ruff check .` locally and fix auto-fixable issues with `ruff check --fix .`. For unfixable issues, add targeted `noqa` comments only if fixing would change behavior.
+
+Commit message: "ci: add ruff linting and mypy type checking"
+```
+
+---
+
+## Slice 7: Add CodeQL + Dependabot
+
+**Why:** No security scanning. Missed vulnerabilities, no automated dependency updates.
+
+**Files to create:**
+- `.github/workflows/codeql.yml`
+- `.github/dependabot.yml`
+
+**Prompt:**
+```
+You are working on the scholarr repository. Add security scanning.
+
+1. Create `.github/workflows/codeql.yml`:
+   ```yaml
+   name: CodeQL
+
+   on:
+     push:
+       branches: [main]
+     pull_request:
+       branches: [main]
+     schedule:
+       - cron: "30 5 * * 1"
+
+   jobs:
+     analyze:
+       runs-on: ubuntu-latest
+       permissions:
+         security-events: write
+         contents: read
+       strategy:
+         matrix:
+           language: [python, javascript]
+       steps:
+         - uses: actions/checkout@v4
+         - uses: github/codeql-action/init@v3
+           with:
+             languages: ${{ matrix.language }}
+         - uses: github/codeql-action/autobuild@v3
+         - uses: github/codeql-action/analyze@v3
+   ```
+
+2. Create `.github/dependabot.yml`:
+   ```yaml
+   version: 2
+   updates:
+     - package-ecosystem: pip
+       directory: /
+       schedule:
+         interval: weekly
+     - package-ecosystem: npm
+       directory: /frontend
+       schedule:
+         interval: weekly
+     - package-ecosystem: github-actions
+       directory: /
+       schedule:
+         interval: weekly
+   ```
+
+Commit message: "ci: add CodeQL security scanning and Dependabot"
+```
+
+---
+
+## Slice 8: Fix Version Remnants + Adopt Semantic Release
+
+**Why:** Version `0.1.0` is hardcoded in 5 places (including `crossref/application.py:294`). `0.0.1` exists in `docs/website/package.json`. No CHANGELOG, no GitHub Releases.
+
+**Files to modify:**
+- `pyproject.toml`
+- `app/services/domains/crossref/application.py`
+
+**Files to create:**
+- `.github/workflows/release.yml`
+
+**Prompt:**
+```
+You are working on the scholarr repository. Set up automated versioning with python-semantic-release.
+
+1. Fix hardcoded version in `app/services/domains/crossref/application.py` (line ~294):
+   ```python
+   # Before:
+   etiquette = Etiquette(settings.app_name, "0.1.0", "https://scholarr.local", email)
+
+   # After:
+   from importlib.metadata import version as pkg_version
+   _APP_VERSION = pkg_version("scholarr")
+   # then in function:
+   etiquette = Etiquette(settings.app_name, _APP_VERSION, "https://scholarr.local", email)
+   ```
+
+2. In `pyproject.toml`, add semantic-release config:
+   ```toml
+   [tool.semantic_release]
+   version_toml = ["pyproject.toml:project.version"]
+   version_variables = ["frontend/package.json:version"]
+   branch = "main"
+   build_command = ""
+   commit_message = "chore(release): v{version}"
+   ```
+
+3. Create `.github/workflows/release.yml`:
+   ```yaml
+   name: Release
+
+   on:
+     push:
+       branches: [main]
+
+   jobs:
+     release:
+       runs-on: ubuntu-latest
+       if: github.repository == 'JustinZeus/scholarr'
+       permissions:
+         contents: write
+         id-token: write
+       steps:
+         - uses: actions/checkout@v4
+           with:
+             fetch-depth: 0
+             token: ${{ secrets.GITHUB_TOKEN }}
+         - uses: actions/setup-python@v5
+           with:
+             python-version: "3.12"
+         - run: pip install python-semantic-release
+         - name: Semantic Release
+           id: release
+           run: semantic-release publish
+           env:
+             GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+   ```
+
+4. Add `python-semantic-release` to dev dependencies in `pyproject.toml`.
+
+Note: `docs/website/package.json` version (`0.0.1`) is addressed in Slice 9 (docs rebuild). `frontend/package-lock.json` and `uv.lock` versions auto-update on next `npm install`/`uv sync`.
+
+Commit message: "ci: adopt python-semantic-release, fix hardcoded version strings"
+```
+
+---
+
+## Slice 9: Docs — Delete and Rebuild from Scratch
+
+**Why:** Current docs have split authority (two api-contract.md files), orphaned pages, stale version (`0.0.1`), and missing critical docs (testing, deployment, configuration reference). Clean slate is faster than migration.
+
+**Files to delete:**
+- `docs/` (entire directory)
+
+**Files to create:**
+- Complete new `docs/` tree
+
+**Prompt:**
+```
+You are working on the scholarr repository. Delete the entire `docs/` directory and rebuild from scratch.
+
+Target IA:
+
+docs/
+├── index.md                          # Landing page: what is scholarr, quick links
+├── user/
+│   ├── overview.md                   # What scholarr does, key concepts
+│   ├── getting-started.md            # Install (docker compose), first run, add first scholar
+│   └── configuration.md              # ALL env vars from .env.example, organized by category
+├── developer/
+│   ├── overview.md                   # Dev quickstart
+│   ├── architecture.md               # FastAPI + SQLAlchemy + Vue 3, domain service boundaries
+│   ├── local-development.md          # docker-compose.dev.yml, hot reload, running tests
+│   ├── contributing.md               # PR process, conventional commits, code standards from agents.md
+│   ├── ingestion.md                  # Ingestion pipeline: parsing, rate limiting, safety gates
+│   ├── frontend-theme-inventory.md   # Theme tokens, Tailwind integration
+│   └── testing.md                    # Test tiers (unit/integration/smoke), markers, fixtures, how to run
+├── operations/
+│   ├── overview.md                   # Ops quickstart
+│   ├── deployment.md                 # Production Docker, scaling, health checks
+│   ├── database-runbook.md           # Backup, restore, integrity checks, migration procedures
+│   ├── scrape-safety-runbook.md      # Rate limiting, cooldowns, CAPTCHA handling
+│   └── arxiv-runbook.md              # ArXiv rate limits, cache, query patterns
+├── reference/
+│   ├── overview.md                   # Reference index
+│   ├── api.md                        # CANONICAL: envelope spec + endpoints + DTO contract
+│   ├── environment.md                # Env var quick-reference (links to user/configuration.md)
+│   └── changelog.md                  # Placeholder: "auto-generated by semantic-release"
+└── website/
+    ├── docusaurus.config.js
+    ├── sidebars.js                   # ALL pages listed, no orphans
+    ├── package.json                  # version: "0.1.0"
+    └── src/css/custom.css
+
+Content guidelines:
+- Self-contained, scannable docs (headers, bullets, tables)
+- Frontmatter: `title`, `sidebar_position`
+- `configuration.md`: read `.env.example`, organize every variable with description, type, default, example
+- `testing.md`: pytest markers from pyproject.toml (`integration`, `db`, `migrations`, `schema`, `smoke`), container-based runner from agents.md, fixture org under tests/fixtures/
+- `api.md`: merge old `developer/api-contract.md` (DTO structure) and `reference/api-contract.md` (envelope spec). Include exact envelope shapes:
+  - Success: `{"data": ..., "meta": {"request_id": "..."}}`
+  - Error: `{"error": {"code": "...", "message": "...", "details": ...}, "meta": {"request_id": "..."}}`
+  - Publication semantics (modes, pagination, identifiers)
+  - Scholar portability endpoints
+- `deployment.md`: practical Docker commands from docker-compose.yml
+- `database-runbook.md`: reference scripts/db/ (backup_full.sh, restore_dump.sh, check_integrity.py, repair_publication_links.py)
+
+Docusaurus config:
+- url: "https://justinzeus.github.io"
+- baseUrl: "/scholarr/"
+- organizationName: "JustinZeus"
+- projectName: "scholarr"
+- onBrokenLinks: "throw"
+- docs path: ".." (reads from docs/ parent)
+- Exclude: "website/**", "README.md"
+
+Commit message: "docs: rebuild documentation from scratch with clean IA"
+```
+
+---
+
+## Slice 10: Begin `ingestion/application.py` Decomposition
+
+**Why:** After logging cleanup (slices 3+5), the file is ~2,700-2,800 lines. Still the largest source file by 3x. This begins decomposition with the safest extract: safety gate logic.
+
+**Files to modify:**
+- `app/services/domains/ingestion/application.py`
+
+**Files to create:**
+- `app/services/domains/ingestion/safety.py`
+
+**Prompt:**
+```
+You are working on the scholarr repository. `app/services/domains/ingestion/application.py` is ~2,700-2,800 lines (after logging cleanup). It contains the entire ingestion orchestration in a single class.
+
+Extract the FIRST logical chunk: safety gate logic.
+
+1. Read `app/services/domains/ingestion/application.py` fully.
+
+2. Identify safety/cooldown methods:
+   - `_enforce_safety_gate`
+   - `_raise_safety_blocked_start`
+   - Cooldown activation/clearing methods
+   - Alert threshold evaluation methods
+
+3. Create `app/services/domains/ingestion/safety.py`:
+   - Move identified methods to standalone functions or a small class
+   - Accept explicit parameters (no implicit self.xxx state)
+   - Keep same function signatures where possible
+
+4. Update `application.py` to import from `safety.py`.
+
+5. Run full test suite: `docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app pytest tests/`
+   All tests must pass unchanged.
+
+Constraints from `agents.md`:
+- Max 50 lines per function
+- No flat files in `app/services/` root — all within `app/services/domains/ingestion/`
+- Fail fast, early returns, guard clauses
+
+Commit message: "refactor: extract ingestion safety gate logic to dedicated module"
+```
+
+---
+
+## Verification (after all slices)
+
+Run these checks to confirm everything is clean:
+
+```bash
+# 1. No tracked build artifacts
+git ls-files build/ | wc -l  # expect: 0
+
+# 2. No duplicated event keys in logging
+grep -rn '"event":' app/ --include="*.py" | grep -v __pycache__ | wc -l  # expect: 0
+
+# 3. No _log_ helper functions remain
+grep -rn 'def _log_' app/ --include="*.py" | wc -l  # expect: 0
+
+# 4. No stale version strings
+grep -rn '0\.0\.1' . --include="*.py" --include="*.json" --include="*.toml" \
+  | grep -v node_modules | grep -v .venv | grep -v uv.lock | wc -l  # expect: 0
+
+# 5. Docs build
+npm --prefix docs/website run build  # expect: success, no broken links
+
+# 6. All tests pass
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app pytest tests/
+```
+
+---
+
+## Slice Summary
+
+| # | Slice | Files Changed | Estimated Impact |
+|---|-------|---------------|------------------|
+| ~~1~~ | ~~Repo hygiene~~ | ~~120 files~~ | ~~-18,380 lines~~ **DONE** |
+| 2 | `structured_log()` utility | 2 files | +50 lines |
+| 3 | Migrate ingestion logging | 1 file | -300 lines |
+| 4 | Migrate remaining logging | ~20 files | -180 lines |
+| 5 | Logging noise/readability | ~5 files | -30 lines, better output |
+| 6 | Ruff + mypy in CI | 2 files | +50 lines config |
+| 7 | CodeQL + Dependabot | 2 files | +40 lines config |
+| 8 | Version fix + semantic-release | 3 files | +40 lines config |
+| 9 | Docs rebuild | full replacement | ~20 new files |
+| 10 | Ingestion decomposition | 2 files | net zero (move) |
diff --git a/alembic/env.py b/alembic/env.py
index 17575e4..127078d 100644
--- a/alembic/env.py
+++ b/alembic/env.py
@@ -1,13 +1,13 @@
-from logging.config import fileConfig
 import os
+from logging.config import fileConfig
 
-from alembic import context
 from sqlalchemy import pool
 from sqlalchemy.engine import Connection
 from sqlalchemy.ext.asyncio import async_engine_from_config
 
-from app.db.base import metadata
+from alembic import context
 from app.db import models  # noqa: F401
+from app.db.base import metadata
 
 config = context.config
 
diff --git a/alembic/versions/20260216_0001_multi_user_schema.py b/alembic/versions/20260216_0001_multi_user_schema.py
index 221bbf7..6c9375e 100644
--- a/alembic/versions/20260216_0001_multi_user_schema.py
+++ b/alembic/versions/20260216_0001_multi_user_schema.py
@@ -8,10 +8,11 @@ Create Date: 2026-02-16 17:10:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "20260216_0001"
 down_revision: str | Sequence[str] | None = None
diff --git a/alembic/versions/20260216_0002_add_user_admin_flag.py b/alembic/versions/20260216_0002_add_user_admin_flag.py
index e60de0f..5ea932d 100644
--- a/alembic/versions/20260216_0002_add_user_admin_flag.py
+++ b/alembic/versions/20260216_0002_add_user_admin_flag.py
@@ -7,9 +7,10 @@ Create Date: 2026-02-16 17:40:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "20260216_0002"
 down_revision: str | Sequence[str] | None = "20260216_0001"
@@ -31,4 +32,3 @@ def upgrade() -> None:
 
 def downgrade() -> None:
     op.drop_column("users", "is_admin")
-
diff --git a/alembic/versions/20260216_0003_add_ingestion_queue.py b/alembic/versions/20260216_0003_add_ingestion_queue.py
index cc03867..4c81fa0 100644
--- a/alembic/versions/20260216_0003_add_ingestion_queue.py
+++ b/alembic/versions/20260216_0003_add_ingestion_queue.py
@@ -7,9 +7,10 @@ Create Date: 2026-02-16 23:45:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "20260216_0003"
 down_revision: str | Sequence[str] | None = "20260216_0002"
diff --git a/alembic/versions/20260217_0004_queue_status_fields.py b/alembic/versions/20260217_0004_queue_status_fields.py
index 68da9dd..f6c29e6 100644
--- a/alembic/versions/20260217_0004_queue_status_fields.py
+++ b/alembic/versions/20260217_0004_queue_status_fields.py
@@ -7,9 +7,10 @@ Create Date: 2026-02-17 10:15:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "20260217_0004"
 down_revision: str | Sequence[str] | None = "20260216_0003"
@@ -22,9 +23,7 @@ def upgrade() -> None:
     inspector = sa.inspect(bind)
     columns = {column["name"] for column in inspector.get_columns("ingestion_queue_items")}
     indexes = {index["name"] for index in inspector.get_indexes("ingestion_queue_items")}
-    checks = {
-        constraint["name"] for constraint in inspector.get_check_constraints("ingestion_queue_items")
-    }
+    checks = {constraint["name"] for constraint in inspector.get_check_constraints("ingestion_queue_items")}
 
     if "status" not in columns:
         op.add_column(
@@ -80,9 +79,7 @@ def downgrade() -> None:
     inspector = sa.inspect(bind)
     columns = {column["name"] for column in inspector.get_columns("ingestion_queue_items")}
     indexes = {index["name"] for index in inspector.get_indexes("ingestion_queue_items")}
-    checks = {
-        constraint["name"] for constraint in inspector.get_check_constraints("ingestion_queue_items")
-    }
+    checks = {constraint["name"] for constraint in inspector.get_check_constraints("ingestion_queue_items")}
 
     if "ix_ingestion_queue_status_next_attempt" in indexes:
         op.drop_index("ix_ingestion_queue_status_next_attempt", table_name="ingestion_queue_items")
diff --git a/alembic/versions/20260217_0005_manual_run_idempotency.py b/alembic/versions/20260217_0005_manual_run_idempotency.py
index 0375569..ad0269b 100644
--- a/alembic/versions/20260217_0005_manual_run_idempotency.py
+++ b/alembic/versions/20260217_0005_manual_run_idempotency.py
@@ -7,9 +7,10 @@ Create Date: 2026-02-17 16:20:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "20260217_0005"
 down_revision: str | Sequence[str] | None = "20260217_0004"
@@ -70,9 +71,7 @@ def upgrade() -> None:
             "crawl_runs",
             ["user_id", "idempotency_key"],
             unique=True,
-            postgresql_where=sa.text(
-                "idempotency_key IS NOT NULL AND trigger_type = 'manual'::run_trigger_type"
-            ),
+            postgresql_where=sa.text("idempotency_key IS NOT NULL AND trigger_type = 'manual'::run_trigger_type"),
         )
 
 
diff --git a/alembic/versions/20260217_0006_scholar_profile_images.py b/alembic/versions/20260217_0006_scholar_profile_images.py
index 08035c8..f736737 100644
--- a/alembic/versions/20260217_0006_scholar_profile_images.py
+++ b/alembic/versions/20260217_0006_scholar_profile_images.py
@@ -7,9 +7,10 @@ Create Date: 2026-02-17 18:30:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "20260217_0006"
 down_revision: str | Sequence[str] | None = "20260217_0005"
diff --git a/alembic/versions/20260217_0007_scholar_initial_page_fingerprint.py b/alembic/versions/20260217_0007_scholar_initial_page_fingerprint.py
index dcfd0f7..6022c4c 100644
--- a/alembic/versions/20260217_0007_scholar_initial_page_fingerprint.py
+++ b/alembic/versions/20260217_0007_scholar_initial_page_fingerprint.py
@@ -7,9 +7,10 @@ Create Date: 2026-02-17 18:55:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "20260217_0007"
 down_revision: str | Sequence[str] | None = "20260217_0006"
diff --git a/alembic/versions/20260219_0008_user_settings_nav_visible_pages.py b/alembic/versions/20260219_0008_user_settings_nav_visible_pages.py
index df481fd..ef38677 100644
--- a/alembic/versions/20260219_0008_user_settings_nav_visible_pages.py
+++ b/alembic/versions/20260219_0008_user_settings_nav_visible_pages.py
@@ -7,10 +7,10 @@ Create Date: 2026-02-19 14:58:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "20260219_0008"
@@ -21,7 +21,7 @@ depends_on: str | Sequence[str] | None = None
 
 TABLE_NAME = "user_settings"
 DEFAULT_NAV_VISIBLE_PAGES_SQL = (
-    "'[\"dashboard\",\"scholars\",\"publications\",\"settings\",\"style-guide\",\"runs\",\"users\"]'::jsonb"
+    '\'["dashboard","scholars","publications","settings","style-guide","runs","users"]\'::jsonb'
 )
 
 
diff --git a/alembic/versions/20260219_0009_user_settings_scrape_safety_state.py b/alembic/versions/20260219_0009_user_settings_scrape_safety_state.py
index 9ea658b..175b6b7 100644
--- a/alembic/versions/20260219_0009_user_settings_scrape_safety_state.py
+++ b/alembic/versions/20260219_0009_user_settings_scrape_safety_state.py
@@ -7,10 +7,10 @@ Create Date: 2026-02-19 21:20:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "20260219_0009"
diff --git a/alembic/versions/20260219_0010_author_search_shared_state.py b/alembic/versions/20260219_0010_author_search_shared_state.py
index bc2b97d..0a07a42 100644
--- a/alembic/versions/20260219_0010_author_search_shared_state.py
+++ b/alembic/versions/20260219_0010_author_search_shared_state.py
@@ -7,10 +7,10 @@ Create Date: 2026-02-19 22:20:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "20260219_0010"
diff --git a/alembic/versions/20260220_0011_add_publication_doi.py b/alembic/versions/20260220_0011_add_publication_doi.py
index bb9a813..c286a00 100644
--- a/alembic/versions/20260220_0011_add_publication_doi.py
+++ b/alembic/versions/20260220_0011_add_publication_doi.py
@@ -7,9 +7,9 @@ Create Date: 2026-02-20 13:35:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
 
 revision: str = "20260220_0011"
 down_revision: str | Sequence[str] | None = "20260219_0010"
diff --git a/alembic/versions/20260220_0012_add_data_repair_jobs.py b/alembic/versions/20260220_0012_add_data_repair_jobs.py
index 242876d..6e7b53f 100644
--- a/alembic/versions/20260220_0012_add_data_repair_jobs.py
+++ b/alembic/versions/20260220_0012_add_data_repair_jobs.py
@@ -7,10 +7,10 @@ Create Date: 2026-02-20 23:35:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
 
 revision: str = "20260220_0012"
 down_revision: str | Sequence[str] | None = "20260220_0011"
diff --git a/alembic/versions/20260221_0013_add_publication_pdf_jobs.py b/alembic/versions/20260221_0013_add_publication_pdf_jobs.py
index 63db6b2..d7046d9 100644
--- a/alembic/versions/20260221_0013_add_publication_pdf_jobs.py
+++ b/alembic/versions/20260221_0013_add_publication_pdf_jobs.py
@@ -7,9 +7,9 @@ Create Date: 2026-02-21 12:25:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
 
 revision: str = "20260221_0013"
 down_revision: str | Sequence[str] | None = "20260220_0012"
diff --git a/alembic/versions/20260221_0014_add_scholar_publication_favorite_state.py b/alembic/versions/20260221_0014_add_scholar_publication_favorite_state.py
index 1fa8f29..7c06d52 100644
--- a/alembic/versions/20260221_0014_add_scholar_publication_favorite_state.py
+++ b/alembic/versions/20260221_0014_add_scholar_publication_favorite_state.py
@@ -7,9 +7,9 @@ Create Date: 2026-02-21 14:35:00
 
 from __future__ import annotations
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision = "20260221_0014"
diff --git a/alembic/versions/20260221_0015_enforce_request_delay_floor.py b/alembic/versions/20260221_0015_enforce_request_delay_floor.py
index 688ce0a..122f055 100644
--- a/alembic/versions/20260221_0015_enforce_request_delay_floor.py
+++ b/alembic/versions/20260221_0015_enforce_request_delay_floor.py
@@ -9,9 +9,9 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "20260221_0015"
@@ -30,11 +30,7 @@ LEGACY_CHECK_NAME_MIN_2 = "ck_user_settings_request_delay_seconds_min_2"
 def _check_constraints() -> set[str]:
     bind = op.get_bind()
     inspector = sa.inspect(bind)
-    return {
-        str(item.get("name"))
-        for item in inspector.get_check_constraints(TABLE_NAME)
-        if item.get("name")
-    }
+    return {str(item.get("name")) for item in inspector.get_check_constraints(TABLE_NAME) if item.get("name")}
 
 
 def _drop_check_if_exists(name: str) -> None:
@@ -48,12 +44,7 @@ def _drop_check_if_exists(name: str) -> None:
 
 
 def upgrade() -> None:
-    op.execute(
-        sa.text(
-            "UPDATE user_settings SET request_delay_seconds = 2 "
-            "WHERE request_delay_seconds < 2"
-        )
-    )
+    op.execute(sa.text("UPDATE user_settings SET request_delay_seconds = 2 WHERE request_delay_seconds < 2"))
 
     _drop_check_if_exists(CHECK_NAME_MIN_1)
     _drop_check_if_exists(LEGACY_CHECK_NAME_MIN_1)
diff --git a/alembic/versions/20260222_0016_add_publication_identifiers.py b/alembic/versions/20260222_0016_add_publication_identifiers.py
index cd824a2..9730a2d 100644
--- a/alembic/versions/20260222_0016_add_publication_identifiers.py
+++ b/alembic/versions/20260222_0016_add_publication_identifiers.py
@@ -7,9 +7,9 @@ Create Date: 2026-02-22 12:45:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
 
 revision: str = "20260222_0016"
 down_revision: str | Sequence[str] | None = "20260221_0015"
diff --git a/alembic/versions/20260224_0018_add_openalex_enriched_to_publications.py b/alembic/versions/20260224_0018_add_openalex_enriched_to_publications.py
index 1d7ecad..ee669fe 100644
--- a/alembic/versions/20260224_0018_add_openalex_enriched_to_publications.py
+++ b/alembic/versions/20260224_0018_add_openalex_enriched_to_publications.py
@@ -5,26 +5,29 @@ Revises: fa0c5e3262d5
 Create Date: 2026-02-24 19:10:00.000000
 
 """
+
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
 
 # revision identifiers, used by Alembic.
-revision: str = '20260224_0018'
-down_revision: str | Sequence[str] | None = 'fa0c5e3262d5'
+revision: str = "20260224_0018"
+down_revision: str | Sequence[str] | None = "fa0c5e3262d5"
 branch_labels: str | Sequence[str] | None = None
 depends_on: str | Sequence[str] | None = None
 
 
 def upgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column('publications', sa.Column('openalex_enriched', sa.Boolean(), server_default=sa.text('false'), nullable=False))
+    op.add_column(
+        "publications", sa.Column("openalex_enriched", sa.Boolean(), server_default=sa.text("false"), nullable=False)
+    )
     # ### end Alembic commands ###
 
 
 def downgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column('publications', 'openalex_enriched')
+    op.drop_column("publications", "openalex_enriched")
     # ### end Alembic commands ###
diff --git a/alembic/versions/20260224_0019_add_resolving_to_runstatus.py b/alembic/versions/20260224_0019_add_resolving_to_runstatus.py
index 645a32b..163747c 100644
--- a/alembic/versions/20260224_0019_add_resolving_to_runstatus.py
+++ b/alembic/versions/20260224_0019_add_resolving_to_runstatus.py
@@ -5,14 +5,14 @@ Revises: 20260224_0018
 Create Date: 2026-02-24 22:20:00.000000
 
 """
+
 from collections.abc import Sequence
 
 from alembic import op
 
-
 # revision identifiers, used by Alembic.
-revision: str = '20260224_0019'
-down_revision: str | Sequence[str] | None = '20260224_0018'
+revision: str = "20260224_0019"
+down_revision: str | Sequence[str] | None = "20260224_0018"
 branch_labels: str | Sequence[str] | None = None
 depends_on: str | Sequence[str] | None = None
 
diff --git a/alembic/versions/20260224_0020_add_openalex_last_attempt_at.py b/alembic/versions/20260224_0020_add_openalex_last_attempt_at.py
index 024f547..1b239f6 100644
--- a/alembic/versions/20260224_0020_add_openalex_last_attempt_at.py
+++ b/alembic/versions/20260224_0020_add_openalex_last_attempt_at.py
@@ -5,22 +5,23 @@ Revises: 20260224_0019
 Create Date: 2026-02-24 22:50:00.000000
 
 """
+
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
 
 # revision identifiers, used by Alembic.
-revision: str = '20260224_0020'
-down_revision: str | Sequence[str] | None = '20260224_0019'
+revision: str = "20260224_0020"
+down_revision: str | Sequence[str] | None = "20260224_0019"
 branch_labels: str | Sequence[str] | None = None
 depends_on: str | Sequence[str] | None = None
 
 
 def upgrade() -> None:
-    op.add_column('publications', sa.Column('openalex_last_attempt_at', sa.DateTime(timezone=True), nullable=True))
+    op.add_column("publications", sa.Column("openalex_last_attempt_at", sa.DateTime(timezone=True), nullable=True))
 
 
 def downgrade() -> None:
-    op.drop_column('publications', 'openalex_last_attempt_at')
+    op.drop_column("publications", "openalex_last_attempt_at")
diff --git a/alembic/versions/20260225_0021_enforce_single_active_run_per_user.py b/alembic/versions/20260225_0021_enforce_single_active_run_per_user.py
index daaa2a6..f5b20f2 100644
--- a/alembic/versions/20260225_0021_enforce_single_active_run_per_user.py
+++ b/alembic/versions/20260225_0021_enforce_single_active_run_per_user.py
@@ -7,9 +7,9 @@ Create Date: 2026-02-25 09:10:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "20260225_0021"
@@ -56,9 +56,7 @@ def upgrade() -> None:
             "crawl_runs",
             ["user_id"],
             unique=True,
-            postgresql_where=sa.text(
-                "status IN ('running'::run_status, 'resolving'::run_status)"
-            ),
+            postgresql_where=sa.text("status IN ('running'::run_status, 'resolving'::run_status)"),
         )
 
 
diff --git a/alembic/versions/20260225_0022_add_canonical_title_hash_to_publications.py b/alembic/versions/20260225_0022_add_canonical_title_hash_to_publications.py
index f73d280..97ba39d 100644
--- a/alembic/versions/20260225_0022_add_canonical_title_hash_to_publications.py
+++ b/alembic/versions/20260225_0022_add_canonical_title_hash_to_publications.py
@@ -7,9 +7,9 @@ Create Date: 2026-02-25 10:00:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "20260225_0022"
diff --git a/alembic/versions/20260226_0023_add_arxiv_runtime_state.py b/alembic/versions/20260226_0023_add_arxiv_runtime_state.py
index b75cd0e..b9efd0d 100644
--- a/alembic/versions/20260226_0023_add_arxiv_runtime_state.py
+++ b/alembic/versions/20260226_0023_add_arxiv_runtime_state.py
@@ -7,9 +7,9 @@ Create Date: 2026-02-26 12:40:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "20260226_0023"
diff --git a/alembic/versions/20260226_0024_add_arxiv_query_cache_entries.py b/alembic/versions/20260226_0024_add_arxiv_query_cache_entries.py
index fe2c0bc..8fddda4 100644
--- a/alembic/versions/20260226_0024_add_arxiv_query_cache_entries.py
+++ b/alembic/versions/20260226_0024_add_arxiv_query_cache_entries.py
@@ -7,10 +7,10 @@ Create Date: 2026-02-26 14:20:00.000000
 
 from collections.abc import Sequence
 
-from alembic import op
 import sqlalchemy as sa
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "20260226_0024"
diff --git a/app/api/__init__.py b/app/api/__init__.py
index 3ce55a6..9d48db4 100644
--- a/app/api/__init__.py
+++ b/app/api/__init__.py
@@ -1,2 +1 @@
 from __future__ import annotations
-
diff --git a/app/api/errors.py b/app/api/errors.py
index 976ccb8..d926690 100644
--- a/app/api/errors.py
+++ b/app/api/errors.py
@@ -82,4 +82,3 @@ def register_api_exception_handlers(app: FastAPI) -> None:
             message="Request validation failed.",
             details=exc.errors(),
         )
-
diff --git a/app/api/routers/__init__.py b/app/api/routers/__init__.py
index 3ce55a6..9d48db4 100644
--- a/app/api/routers/__init__.py
+++ b/app/api/routers/__init__.py
@@ -1,2 +1 @@
 from __future__ import annotations
-
diff --git a/app/api/routers/admin.py b/app/api/routers/admin.py
index b1f99b8..416b084 100644
--- a/app/api/routers/admin.py
+++ b/app/api/routers/admin.py
@@ -86,7 +86,14 @@ async def create_user(
             message=str(exc),
         ) from exc
 
-    structured_log(logger, "info", "api.admin.user_created", admin_user_id=int(admin_user.id), target_user_id=int(created_user.id), target_is_admin=bool(created_user.is_admin))
+    structured_log(
+        logger,
+        "info",
+        "api.admin.user_created",
+        admin_user_id=int(admin_user.id),
+        target_user_id=int(created_user.id),
+        target_is_admin=bool(created_user.is_admin),
+    )
     return success_payload(
         request,
         data=_serialize_user(created_user),
@@ -111,11 +118,7 @@ async def set_user_active(
             code="user_not_found",
             message="User not found.",
         )
-    if (
-        int(target_user.id) == int(admin_user.id)
-        and bool(target_user.is_active)
-        and not bool(payload.is_active)
-    ):
+    if int(target_user.id) == int(admin_user.id) and bool(target_user.is_active) and not bool(payload.is_active):
         raise ApiException(
             status_code=400,
             code="cannot_deactivate_self",
@@ -126,7 +129,14 @@ async def set_user_active(
         user=target_user,
         is_active=bool(payload.is_active),
     )
-    structured_log(logger, "info", "api.admin.user_active_updated", admin_user_id=int(admin_user.id), target_user_id=int(updated_user.id), is_active=bool(updated_user.is_active))
+    structured_log(
+        logger,
+        "info",
+        "api.admin.user_active_updated",
+        admin_user_id=int(admin_user.id),
+        target_user_id=int(updated_user.id),
+        is_active=bool(updated_user.is_active),
+    )
     return success_payload(
         request,
         data=_serialize_user(updated_user),
@@ -166,7 +176,13 @@ async def reset_user_password(
         user=target_user,
         password_hash=auth_service.hash_password(validated_password),
     )
-    structured_log(logger, "info", "api.admin.user_password_reset", admin_user_id=int(admin_user.id), target_user_id=int(target_user.id))
+    structured_log(
+        logger,
+        "info",
+        "api.admin.user_password_reset",
+        admin_user_id=int(admin_user.id),
+        target_user_id=int(target_user.id),
+    )
     return success_payload(
         request,
         data={"message": f"Password reset: {target_user.email}"},
diff --git a/app/api/routers/admin_dbops.py b/app/api/routers/admin_dbops.py
index 57498c1..f465268 100644
--- a/app/api/routers/admin_dbops.py
+++ b/app/api/routers/admin_dbops.py
@@ -10,14 +10,14 @@ from app.api.errors import ApiException
 from app.api.responses import success_payload
 from app.api.schemas import (
     AdminDbIntegrityEnvelope,
-    AdminPdfQueueBulkEnqueueEnvelope,
-    AdminPdfQueueRequeueEnvelope,
-    AdminPdfQueueEnvelope,
     AdminDbRepairJobsEnvelope,
-    AdminRepairPublicationNearDuplicatesEnvelope,
-    AdminRepairPublicationNearDuplicatesRequest,
+    AdminPdfQueueBulkEnqueueEnvelope,
+    AdminPdfQueueEnvelope,
+    AdminPdfQueueRequeueEnvelope,
     AdminRepairPublicationLinksEnvelope,
     AdminRepairPublicationLinksRequest,
+    AdminRepairPublicationNearDuplicatesEnvelope,
+    AdminRepairPublicationNearDuplicatesRequest,
 )
 from app.db.models import DataRepairJob, User
 from app.db.session import get_db_session
@@ -25,8 +25,8 @@ from app.logging_utils import structured_log
 from app.services.domains.dbops import (
     collect_integrity_report,
     list_repair_jobs,
-    run_publication_near_duplicate_repair,
     run_publication_link_repair,
+    run_publication_near_duplicate_repair,
 )
 from app.services.domains.publications import application as publication_service
 
@@ -136,7 +136,15 @@ async def get_integrity_report(
     admin_user: User = Depends(get_api_admin_user),
 ):
     report = await collect_integrity_report(db_session)
-    structured_log(logger, "info", "api.admin.db.integrity_checked", admin_user_id=int(admin_user.id), status=report.get("status"), failure_count=len(report.get("failures", [])), warning_count=len(report.get("warnings", [])))
+    structured_log(
+        logger,
+        "info",
+        "api.admin.db.integrity_checked",
+        admin_user_id=int(admin_user.id),
+        status=report.get("status"),
+        failure_count=len(report.get("failures", [])),
+        warning_count=len(report.get("warnings", [])),
+    )
     return success_payload(request, data=report)
 
 
@@ -151,7 +159,14 @@ async def get_repair_jobs(
     admin_user: User = Depends(get_api_admin_user),
 ):
     jobs = await list_repair_jobs(db_session, limit=limit)
-    structured_log(logger, "info", "api.admin.db.repair_jobs_listed", admin_user_id=int(admin_user.id), limit=int(limit), job_count=len(jobs))
+    structured_log(
+        logger,
+        "info",
+        "api.admin.db.repair_jobs_listed",
+        admin_user_id=int(admin_user.id),
+        limit=int(limit),
+        job_count=len(jobs),
+    )
     return success_payload(
         request,
         data={"jobs": [_serialize_repair_job(job) for job in jobs]},
@@ -186,7 +201,9 @@ async def get_pdf_queue(
         status=normalized_status,
     )
     structured_log(
-        logger, "info", "api.admin.db.pdf_queue_listed",
+        logger,
+        "info",
+        "api.admin.db.pdf_queue_listed",
         admin_user_id=int(admin_user.id),
         page=int(resolved_page),
         page_size=int(resolved_limit),
@@ -232,7 +249,14 @@ async def requeue_pdf_lookup(
             message="Publication not found.",
         )
     status, message = _requeue_response_state(queued=result.queued)
-    structured_log(logger, "info", "api.admin.db.pdf_requeued", admin_user_id=int(admin_user.id), publication_id=int(publication_id), queued=bool(result.queued))
+    structured_log(
+        logger,
+        "info",
+        "api.admin.db.pdf_requeued",
+        admin_user_id=int(admin_user.id),
+        publication_id=int(publication_id),
+        queued=bool(result.queued),
+    )
     return success_payload(
         request,
         data={
@@ -260,7 +284,15 @@ async def requeue_all_missing_pdfs(
         request_email=admin_user.email,
         limit=limit,
     )
-    structured_log(logger, "info", "api.admin.db.pdf_queue_requeue_all", admin_user_id=int(admin_user.id), limit=int(limit), requested_count=int(result.requested_count), queued_count=int(result.queued_count))
+    structured_log(
+        logger,
+        "info",
+        "api.admin.db.pdf_queue_requeue_all",
+        admin_user_id=int(admin_user.id),
+        limit=int(limit),
+        requested_count=int(result.requested_count),
+        queued_count=int(result.queued_count),
+    )
     return success_payload(
         request,
         data={
@@ -301,7 +333,9 @@ async def trigger_publication_link_repair(
             message=str(exc),
         ) from exc
     structured_log(
-        logger, "info", "api.admin.db.publication_link_repair_triggered",
+        logger,
+        "info",
+        "api.admin.db.publication_link_repair_triggered",
         admin_user_id=int(admin_user.id),
         scope_mode=payload.scope_mode,
         target_user_id=int(payload.user_id) if payload.user_id is not None else None,
@@ -340,7 +374,16 @@ async def trigger_publication_near_duplicate_repair(
             code="invalid_near_duplicate_repair_request",
             message=str(exc),
         ) from exc
-    structured_log(logger, "info", "api.admin.db.dedup_repair_triggered", admin_user_id=int(admin_user.id), dry_run=bool(payload.dry_run), selected_cluster_count=len(payload.selected_cluster_keys), job_id=int(result["job_id"]), status=result["status"])
+    structured_log(
+        logger,
+        "info",
+        "api.admin.db.dedup_repair_triggered",
+        admin_user_id=int(admin_user.id),
+        dry_run=bool(payload.dry_run),
+        selected_cluster_count=len(payload.selected_cluster_keys),
+        job_id=int(result["job_id"]),
+        status=result["status"],
+    )
     return success_payload(request, data=result)
 
 
@@ -381,12 +424,17 @@ async def drop_all_publications(
     await db_session.execute(delete(PublicationPdfJobEvent))
     await db_session.execute(delete(PublicationPdfJob))
     await db_session.execute(delete(Publication))
-    await db_session.execute(
-        update(ScholarProfile).values(baseline_completed=False)
-    )
+    await db_session.execute(update(ScholarProfile).values(baseline_completed=False))
     await db_session.commit()
 
-    structured_log(logger, "warning", "api.admin.db.all_publications_dropped", admin_user_id=int(admin_user.id), admin_email=admin_user.email, deleted_count=int(total_publications))
+    structured_log(
+        logger,
+        "warning",
+        "api.admin.db.all_publications_dropped",
+        admin_user_id=int(admin_user.id),
+        admin_email=admin_user.email,
+        deleted_count=int(total_publications),
+    )
     return success_payload(
         request,
         data={
diff --git a/app/api/routers/auth.py b/app/api/routers/auth.py
index 3faffa6..9b9f053 100644
--- a/app/api/routers/auth.py
+++ b/app/api/routers/auth.py
@@ -5,8 +5,8 @@ import logging
 from fastapi import APIRouter, Depends, Request
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.api.errors import ApiException
 from app.api.deps import get_api_current_user
+from app.api.errors import ApiException
 from app.api.responses import success_payload
 from app.api.schemas import (
     AuthMeEnvelope,
@@ -16,14 +16,14 @@ from app.api.schemas import (
     LoginRequest,
     MessageEnvelope,
 )
-from app.auth.deps import get_auth_service, get_login_rate_limiter
-from app.logging_utils import structured_log
-from app.auth.rate_limit import SlidingWindowRateLimiter
 from app.auth import runtime as auth_runtime
+from app.auth.deps import get_auth_service, get_login_rate_limiter
+from app.auth.rate_limit import SlidingWindowRateLimiter
 from app.auth.service import AuthService
 from app.auth.session import set_session_user
 from app.db.models import User
 from app.db.session import get_db_session
+from app.logging_utils import structured_log
 from app.security.csrf import ensure_csrf_token
 from app.services.domains.users import application as user_service
 
@@ -37,7 +37,13 @@ def _login_limiter_key_and_email(request: Request, payload: LoginRequest) -> tup
 
 
 def _raise_rate_limited(normalized_email: str, retry_after_seconds: int) -> None:
-    structured_log(logger, "warning", "api.auth.login_rate_limited", email=normalized_email, retry_after_seconds=retry_after_seconds)
+    structured_log(
+        logger,
+        "warning",
+        "api.auth.login_rate_limited",
+        email=normalized_email,
+        retry_after_seconds=retry_after_seconds,
+    )
     raise ApiException(
         status_code=429,
         code="rate_limited",
@@ -200,7 +206,9 @@ async def logout(
 ):
     current_user = await auth_runtime.get_authenticated_user(request, db_session)
     auth_runtime.invalidate_session(request)
-    structured_log(logger, "info", "api.auth.logout", user_id=int(current_user.id) if current_user is not None else None)
+    structured_log(
+        logger, "info", "api.auth.logout", user_id=int(current_user.id) if current_user is not None else None
+    )
     return success_payload(
         request,
         data={
diff --git a/app/api/routers/publications.py b/app/api/routers/publications.py
index 7048d6b..107f531 100644
--- a/app/api/routers/publications.py
+++ b/app/api/routers/publications.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
 import logging
+from datetime import UTC, datetime
 from typing import Literal
 
 from fastapi import APIRouter, Depends, Path, Query, Request
@@ -183,7 +183,7 @@ def _resolve_publications_snapshot(
     snapshot: str | None,
 ) -> tuple[datetime, str]:
     if snapshot is None:
-        now_utc = datetime.now(timezone.utc)
+        now_utc = datetime.now(UTC)
         return now_utc, now_utc.isoformat()
     try:
         parsed = datetime.fromisoformat(snapshot)
@@ -194,8 +194,8 @@ def _resolve_publications_snapshot(
             message="Invalid publications snapshot cursor.",
         ) from exc
     if parsed.tzinfo is None:
-        parsed = parsed.replace(tzinfo=timezone.utc)
-    normalized = parsed.astimezone(timezone.utc)
+        parsed = parsed.replace(tzinfo=UTC)
+    normalized = parsed.astimezone(UTC)
     return normalized, normalized.isoformat()
 
 
@@ -420,7 +420,9 @@ async def mark_all_publications_read(
         db_session,
         user_id=current_user.id,
     )
-    structured_log(logger, "info", "api.publications.mark_all_read", user_id=current_user.id, updated_count=updated_count)
+    structured_log(
+        logger, "info", "api.publications.mark_all_read", user_id=current_user.id, updated_count=updated_count
+    )
     return success_payload(
         request,
         data={
@@ -440,18 +442,20 @@ async def mark_selected_publications_read(
     db_session: AsyncSession = Depends(get_db_session),
     current_user: User = Depends(get_api_current_user),
 ):
-    selection_pairs = sorted(
-        {
-            (int(item.scholar_profile_id), int(item.publication_id))
-            for item in payload.selections
-        }
-    )
+    selection_pairs = sorted({(int(item.scholar_profile_id), int(item.publication_id)) for item in payload.selections})
     updated_count = await publication_service.mark_selected_as_read_for_user(
         db_session,
         user_id=current_user.id,
         selections=selection_pairs,
     )
-    structured_log(logger, "info", "api.publications.mark_selected_read", user_id=current_user.id, requested_count=len(selection_pairs), updated_count=updated_count)
+    structured_log(
+        logger,
+        "info",
+        "api.publications.mark_selected_read",
+        user_id=current_user.id,
+        requested_count=len(selection_pairs),
+        updated_count=updated_count,
+    )
     return success_payload(
         request,
         data={
@@ -486,7 +490,9 @@ async def retry_publication_pdf(
         pdf_status=current.pdf_status,
     )
     structured_log(
-        logger, "info", "api.publications.retry_pdf",
+        logger,
+        "info",
+        "api.publications.retry_pdf",
         user_id=current_user.id,
         scholar_profile_id=payload.scholar_profile_id,
         publication_id=publication_id,
@@ -523,7 +529,15 @@ async def toggle_publication_favorite(
         publication_id=publication_id,
         is_favorite=payload.is_favorite,
     )
-    structured_log(logger, "info", "api.publications.favorite", user_id=current_user.id, scholar_profile_id=payload.scholar_profile_id, publication_id=publication_id, is_favorite=bool(payload.is_favorite))
+    structured_log(
+        logger,
+        "info",
+        "api.publications.favorite",
+        user_id=current_user.id,
+        scholar_profile_id=payload.scholar_profile_id,
+        publication_id=publication_id,
+        is_favorite=bool(payload.is_favorite),
+    )
     return success_payload(
         request,
         data={
diff --git a/app/api/routers/runs.py b/app/api/routers/runs.py
index f6e6644..c25a127 100644
--- a/app/api/routers/runs.py
+++ b/app/api/routers/runs.py
@@ -5,13 +5,14 @@ import re
 from typing import Any
 
 from fastapi import APIRouter, Depends, Query, Request
+from fastapi.responses import StreamingResponse
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.deps import get_api_current_user
 from app.api.errors import ApiException
 from app.api.responses import success_payload
-from fastapi.responses import StreamingResponse
+from app.api.runtime_deps import get_ingestion_service
 from app.api.schemas import (
     ManualRunEnvelope,
     QueueClearEnvelope,
@@ -29,7 +30,6 @@ from app.services.domains.runs import application as run_service
 from app.services.domains.runs.events import event_generator
 from app.services.domains.settings import application as user_settings_service
 from app.settings import settings
-from app.api.runtime_deps import get_ingestion_service
 
 logger = logging.getLogger(__name__)
 
@@ -77,10 +77,7 @@ def _normalize_idempotency_key(raw_value: str | None) -> str | None:
         raise ApiException(
             status_code=400,
             code="invalid_idempotency_key",
-            message=(
-                "Invalid Idempotency-Key. Use 8-128 characters from: "
-                "A-Z a-z 0-9 . _ : -"
-            ),
+            message=("Invalid Idempotency-Key. Use 8-128 characters from: A-Z a-z 0-9 . _ : -"),
         )
     return candidate
 
@@ -130,11 +127,7 @@ def _normalize_attempt_log(value: Any) -> list[dict[str, Any]]:
                 "cstart": _int_value(item.get("cstart"), 0),
                 "state": _str_value(item.get("state")),
                 "state_reason": _str_value(item.get("state_reason")),
-                "status_code": (
-                    _int_value(item.get("status_code"))
-                    if item.get("status_code") is not None
-                    else None
-                ),
+                "status_code": (_int_value(item.get("status_code")) if item.get("status_code") is not None else None),
                 "fetch_error": _str_value(item.get("fetch_error")),
             }
         )
@@ -155,19 +148,12 @@ def _normalize_page_logs(value: Any) -> list[dict[str, Any]]:
                 "cstart": _int_value(item.get("cstart"), 0),
                 "state": _str_value(item.get("state")) or "unknown",
                 "state_reason": _str_value(item.get("state_reason")),
-                "status_code": (
-                    _int_value(item.get("status_code"))
-                    if item.get("status_code") is not None
-                    else None
-                ),
+                "status_code": (_int_value(item.get("status_code")) if item.get("status_code") is not None else None),
                 "publication_count": _int_value(item.get("publication_count"), 0),
                 "attempt_count": _int_value(item.get("attempt_count"), 0),
                 "has_show_more_button": _bool_value(item.get("has_show_more_button"), False),
                 "articles_range": _str_value(item.get("articles_range")),
-                "warning_codes": [
-                    str(code)
-                    for code in (warning_codes if isinstance(warning_codes, list) else [])
-                ],
+                "warning_codes": [str(code) for code in (warning_codes if isinstance(warning_codes, list) else [])],
             }
         )
     return normalized
@@ -179,19 +165,11 @@ def _normalize_debug(value: Any) -> dict[str, Any] | None:
     marker_counts = value.get("marker_counts_nonzero")
     warning_codes = value.get("warning_codes")
     return {
-        "status_code": (
-            _int_value(value.get("status_code"))
-            if value.get("status_code") is not None
-            else None
-        ),
+        "status_code": (_int_value(value.get("status_code")) if value.get("status_code") is not None else None),
         "final_url": _str_value(value.get("final_url")),
         "fetch_error": _str_value(value.get("fetch_error")),
         "body_sha256": _str_value(value.get("body_sha256")),
-        "body_length": (
-            _int_value(value.get("body_length"))
-            if value.get("body_length") is not None
-            else None
-        ),
+        "body_length": (_int_value(value.get("body_length")) if value.get("body_length") is not None else None),
         "has_show_more_button": (
             _bool_value(value.get("has_show_more_button"), False)
             if value.get("has_show_more_button") is not None
@@ -199,10 +177,7 @@ def _normalize_debug(value: Any) -> dict[str, Any] | None:
         ),
         "articles_range": _str_value(value.get("articles_range")),
         "state_reason": _str_value(value.get("state_reason")),
-        "warning_codes": [
-            str(code)
-            for code in (warning_codes if isinstance(warning_codes, list) else [])
-        ],
+        "warning_codes": [str(code) for code in (warning_codes if isinstance(warning_codes, list) else [])],
         "marker_counts_nonzero": {
             str(key): _int_value(count, 0)
             for key, count in (marker_counts.items() if isinstance(marker_counts, dict) else [])
@@ -241,9 +216,7 @@ def _normalize_scholar_result(value: Any) -> dict[str, Any]:
         "publication_count": _int_value(value.get("publication_count"), 0),
         "start_cstart": _int_value(value.get("start_cstart"), 0),
         "continuation_cstart": (
-            _int_value(value.get("continuation_cstart"))
-            if value.get("continuation_cstart") is not None
-            else None
+            _int_value(value.get("continuation_cstart")) if value.get("continuation_cstart") is not None else None
         ),
         "continuation_enqueued": _bool_value(value.get("continuation_enqueued"), False),
         "continuation_cleared": _bool_value(value.get("continuation_cleared"), False),
@@ -289,7 +262,9 @@ async def _load_safety_state(
         await db_session.commit()
         await db_session.refresh(user_settings)
         structured_log(
-            logger, "info", "api.runs.safety_cooldown_cleared",
+            logger,
+            "info",
+            "api.runs.safety_cooldown_cleared",
             user_id=user_id,
             reason=previous_safety_state.get("cooldown_reason"),
             cooldown_until=previous_safety_state.get("cooldown_until"),
@@ -299,7 +274,9 @@ async def _load_safety_state(
 
 def _raise_manual_runs_disabled(*, user_id: int, safety_state: dict[str, Any]) -> None:
     structured_log(
-        logger, "warning", "api.runs.manual_blocked_policy",
+        logger,
+        "warning",
+        "api.runs.manual_blocked_policy",
         user_id=user_id,
         policy={"manual_run_allowed": False},
         safety_state=safety_state,
@@ -463,7 +440,9 @@ async def _execute_manual_run(
 
 def _raise_manual_blocked_safety(*, exc, user_id: int) -> None:
     structured_log(
-        logger, "info", "api.runs.manual_blocked_safety",
+        logger,
+        "info",
+        "api.runs.manual_blocked_safety",
         user_id=user_id,
         reason=exc.safety_state.get("cooldown_reason"),
         cooldown_until=exc.safety_state.get("cooldown_until"),
@@ -613,12 +592,12 @@ async def cancel_run(
     scholar_results = error_log.get("scholar_results")
     if not isinstance(scholar_results, list):
         scholar_results = []
-        
+
     safety_state = await _load_safety_state(
         db_session,
         user_id=current_user.id,
     )
-    
+
     return success_payload(
         request,
         data={
@@ -657,7 +636,7 @@ async def run_manual(
 
     try:
         user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=current_user.id)
-        
+
         # Initialize run (creates the record and performs safety checks)
         run, scholars, start_cstart_map = await ingest_service.initialize_run(
             db_session,
@@ -673,13 +652,14 @@ async def run_manual(
             alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
             alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
         )
-        
+
         await db_session.commit()
-        
+
         # Kick off background execution
-        from app.db.session import get_session_factory
         import asyncio
-        
+
+        from app.db.session import get_session_factory
+
         asyncio.create_task(
             ingest_service.execute_run(
                 session_factory=get_session_factory(),
@@ -700,7 +680,7 @@ async def run_manual(
                 idempotency_key=idempotency_key,
             )
         )
-        
+
         return success_payload(
             request,
             data={
@@ -714,7 +694,7 @@ async def run_manual(
                 "reused_existing_run": False,
                 "idempotency_key": idempotency_key,
                 "safety_state": await _load_safety_state(db_session, user_id=current_user.id),
-            }
+            },
         )
     except ingestion_service.RunBlockedBySafetyPolicyError as exc:
         await db_session.rollback()
@@ -740,7 +720,6 @@ async def run_manual(
         _raise_manual_failed(exc=exc, user_id=current_user.id)
 
 
-
 @router.get(
     "/queue/items",
     response_model=QueueListEnvelope,
@@ -891,7 +870,4 @@ async def stream_run_events(
             code="run_not_found",
             message="Run not found.",
         )
-    return StreamingResponse(
-        event_generator(run_id),
-        media_type="text/event-stream"
-    )
+    return StreamingResponse(event_generator(run_id), media_type="text/event-stream")
diff --git a/app/api/routers/scholars.py b/app/api/routers/scholars.py
index c0a281b..fcdd1c4 100644
--- a/app/api/routers/scholars.py
+++ b/app/api/routers/scholars.py
@@ -27,8 +27,8 @@ from app.logging_utils import structured_log
 from app.services.domains.ingestion import queue as ingestion_queue_service
 from app.services.domains.portability import application as import_export_service
 from app.services.domains.scholar import rate_limit as scholar_rate_limit
-from app.services.domains.scholars import application as scholar_service
 from app.services.domains.scholar.source import ScholarSource
+from app.services.domains.scholars import application as scholar_service
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
@@ -82,14 +82,18 @@ async def _enqueue_initial_scrape_job_for_scholar(
     except Exception:
         await db_session.rollback()
         structured_log(
-            logger, "warning", "api.scholars.initial_scrape_enqueue_failed",
+            logger,
+            "warning",
+            "api.scholars.initial_scrape_enqueue_failed",
             user_id=user_id,
             scholar_profile_id=profile.id,
         )
         return False
 
     structured_log(
-        logger, "info", "api.scholars.initial_scrape_enqueued",
+        logger,
+        "info",
+        "api.scholars.initial_scrape_enqueued",
         user_id=user_id,
         scholar_profile_id=profile.id,
         reason=INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON,
@@ -120,9 +124,7 @@ def _serialize_scholar(profile) -> dict[str, object]:
         "is_enabled": bool(profile.is_enabled),
         "baseline_completed": bool(profile.baseline_completed),
         "last_run_dt": profile.last_run_dt,
-        "last_run_status": (
-            profile.last_run_status.value if profile.last_run_status is not None else None
-        ),
+        "last_run_status": (profile.last_run_status.value if profile.last_run_status is not None else None),
     }
 
 
@@ -139,7 +141,9 @@ async def _hydrate_scholar_metadata_if_needed(
     should_skip, remaining_seconds = _is_create_hydration_rate_limited()
     if should_skip:
         structured_log(
-            logger, "info", "api.scholars.create_metadata_hydration_skipped",
+            logger,
+            "info",
+            "api.scholars.create_metadata_hydration_skipped",
             reason="scholar_request_throttle_active",
             user_id=user_id,
             scholar_profile_id=profile.id,
@@ -158,14 +162,18 @@ async def _hydrate_scholar_metadata_if_needed(
         )
     except TimeoutError:
         structured_log(
-            logger, "info", "api.scholars.create_metadata_hydration_skipped",
+            logger,
+            "info",
+            "api.scholars.create_metadata_hydration_skipped",
             reason="create_timeout",
             user_id=user_id,
             scholar_profile_id=profile.id,
         )
     except Exception:
         structured_log(
-            logger, "warning", "api.scholars.create_metadata_hydration_failed",
+            logger,
+            "warning",
+            "api.scholars.create_metadata_hydration_failed",
             user_id=user_id,
             scholar_profile_id=profile.id,
         )
@@ -185,9 +193,7 @@ def _search_kwargs() -> dict[str, object]:
         "cooldown_block_threshold": settings.scholar_name_search_cooldown_block_threshold,
         "cooldown_seconds": settings.scholar_name_search_cooldown_seconds,
         "retry_alert_threshold": settings.scholar_name_search_alert_retry_count_threshold,
-        "cooldown_rejection_alert_threshold": (
-            settings.scholar_name_search_alert_cooldown_rejections_threshold
-        ),
+        "cooldown_rejection_alert_threshold": (settings.scholar_name_search_alert_cooldown_rejections_threshold),
     }
 
 
@@ -299,8 +305,7 @@ async def import_scholars_and_publications(
             status_code=400,
             code="invalid_import_schema_version",
             message=(
-                "Import schema version is not supported. "
-                f"Expected {import_export_service.EXPORT_SCHEMA_VERSION}."
+                f"Import schema version is not supported. Expected {import_export_service.EXPORT_SCHEMA_VERSION}."
             ),
         )
     try:
@@ -393,7 +398,15 @@ async def search_scholars(
             message=str(exc),
         ) from exc
 
-    structured_log(logger, "info", "api.scholars.search.completed", user_id=current_user.id, query=query.strip(), candidate_count=len(parsed.candidates), state=parsed.state.value)
+    structured_log(
+        logger,
+        "info",
+        "api.scholars.search.completed",
+        user_id=current_user.id,
+        query=query.strip(),
+        candidate_count=len(parsed.candidates),
+        state=parsed.state.value,
+    )
     return success_payload(
         request,
         data=_search_response_data(query, parsed),
@@ -422,7 +435,14 @@ async def toggle_scholar(
             message="Scholar not found.",
         )
     updated = await scholar_service.toggle_scholar_enabled(db_session, profile=profile)
-    structured_log(logger, "info", "api.scholars.toggled", user_id=current_user.id, scholar_profile_id=updated.id, is_enabled=updated.is_enabled)
+    structured_log(
+        logger,
+        "info",
+        "api.scholars.toggled",
+        user_id=current_user.id,
+        scholar_profile_id=updated.id,
+        is_enabled=updated.is_enabled,
+    )
     return success_payload(
         request,
         data=_serialize_scholar(updated),
@@ -455,7 +475,9 @@ async def delete_scholar(
         profile=profile,
         upload_dir=settings.scholar_image_upload_dir,
     )
-    structured_log(logger, "info", "api.scholars.deleted", user_id=current_user.id, scholar_profile_id=scholar_profile_id)
+    structured_log(
+        logger, "info", "api.scholars.deleted", user_id=current_user.id, scholar_profile_id=scholar_profile_id
+    )
     return success_payload(
         request,
         data={"message": "Scholar deleted."},
@@ -499,7 +521,9 @@ async def update_scholar_image_url(
             message=str(exc),
         ) from exc
 
-    structured_log(logger, "info", "api.scholars.image_url_updated", user_id=current_user.id, scholar_profile_id=updated.id)
+    structured_log(
+        logger, "info", "api.scholars.image_url_updated", user_id=current_user.id, scholar_profile_id=updated.id
+    )
     return success_payload(
         request,
         data=_serialize_scholar(updated),
@@ -541,7 +565,15 @@ async def upload_scholar_image(
         ) from exc
 
     image_size = len(image_bytes)
-    structured_log(logger, "info", "api.scholars.image_uploaded", user_id=current_user.id, scholar_profile_id=updated.id, content_type=image.content_type, size_bytes=image_size)
+    structured_log(
+        logger,
+        "info",
+        "api.scholars.image_uploaded",
+        user_id=current_user.id,
+        scholar_profile_id=updated.id,
+        content_type=image.content_type,
+        size_bytes=image_size,
+    )
     return success_payload(
         request,
         data=_serialize_scholar(updated),
diff --git a/app/api/routers/settings.py b/app/api/routers/settings.py
index e0c3f26..55e6a51 100644
--- a/app/api/routers/settings.py
+++ b/app/api/routers/settings.py
@@ -85,7 +85,9 @@ async def _clear_expired_cooldown_with_log(
     await db_session.commit()
     await db_session.refresh(user_settings)
     structured_log(
-        logger, "info", "api.settings.safety_cooldown_cleared",
+        logger,
+        "info",
+        "api.settings.safety_cooldown_cleared",
         user_id=user_id,
         reason=previous_safety_state.get("cooldown_reason"),
         cooldown_until=previous_safety_state.get("cooldown_until"),
@@ -164,7 +166,9 @@ async def update_settings(
         user_settings=updated,
     )
     structured_log(
-        logger, "info", "api.settings.updated",
+        logger,
+        "info",
+        "api.settings.updated",
         user_id=current_user.id,
         auto_run_enabled=updated.auto_run_enabled,
         run_interval_minutes=updated.run_interval_minutes,
diff --git a/app/api/schemas.py b/app/api/schemas.py
index e3b9ac7..0b7db35 100644
--- a/app/api/schemas.py
+++ b/app/api/schemas.py
@@ -671,7 +671,7 @@ class AdminRepairPublicationLinksRequest(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     @model_validator(mode="after")
-    def validate_scope(self) -> "AdminRepairPublicationLinksRequest":
+    def validate_scope(self) -> AdminRepairPublicationLinksRequest:
         if self.scope_mode == "single_user" and self.user_id is None:
             raise ValueError("user_id is required when scope_mode=single_user.")
         if self.scope_mode == "all_users" and self.user_id is not None:
@@ -680,10 +680,7 @@ class AdminRepairPublicationLinksRequest(BaseModel):
             expected = "REPAIR ALL USERS"
             provided = (self.confirmation_text or "").strip()
             if provided != expected:
-                raise ValueError(
-                    "confirmation_text must equal 'REPAIR ALL USERS' "
-                    "when applying a repair to all users."
-                )
+                raise ValueError("confirmation_text must equal 'REPAIR ALL USERS' when applying a repair to all users.")
         return self
 
 
@@ -735,7 +732,7 @@ class AdminRepairPublicationNearDuplicatesRequest(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     @model_validator(mode="after")
-    def validate_apply_mode(self) -> "AdminRepairPublicationNearDuplicatesRequest":
+    def validate_apply_mode(self) -> AdminRepairPublicationNearDuplicatesRequest:
         if self.dry_run:
             return self
         if not self.selected_cluster_keys:
@@ -744,8 +741,7 @@ class AdminRepairPublicationNearDuplicatesRequest(BaseModel):
         provided = (self.confirmation_text or "").strip()
         if provided != expected:
             raise ValueError(
-                "confirmation_text must equal 'MERGE SELECTED DUPLICATES' "
-                "when applying near-duplicate merges."
+                "confirmation_text must equal 'MERGE SELECTED DUPLICATES' when applying near-duplicate merges."
             )
         return self
 
@@ -787,7 +783,7 @@ class SettingsData(BaseModel):
     nav_visible_pages: list[str]
     policy: SettingsPolicyData
     safety_state: ScrapeSafetyStateData
-    
+
     openalex_api_key: str | None = None
     crossref_api_token: str | None = None
     crossref_api_mailto: str | None = None
diff --git a/app/auth/__init__.py b/app/auth/__init__.py
index 79644a4..b2c2619 100644
--- a/app/auth/__init__.py
+++ b/app/auth/__init__.py
@@ -1,2 +1 @@
 """Authentication package for scholarr."""
-
diff --git a/app/auth/deps.py b/app/auth/deps.py
index 50424ae..ec7613c 100644
--- a/app/auth/deps.py
+++ b/app/auth/deps.py
@@ -24,4 +24,3 @@ def get_login_rate_limiter() -> SlidingWindowRateLimiter:
         max_attempts=settings.login_rate_limit_attempts,
         window_seconds=settings.login_rate_limit_window_seconds,
     )
-
diff --git a/app/auth/runtime.py b/app/auth/runtime.py
index c379cd3..077b7a1 100644
--- a/app/auth/runtime.py
+++ b/app/auth/runtime.py
@@ -6,8 +6,8 @@ from fastapi import Request
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.auth.session import clear_session_user, get_session_user, set_session_user
-from app.logging_utils import structured_log
 from app.db.models import User
+from app.logging_utils import structured_log
 from app.security.csrf import CSRF_SESSION_KEY
 from app.services.domains.users import application as user_service
 
diff --git a/app/auth/security.py b/app/auth/security.py
index f89b122..befcd7c 100644
--- a/app/auth/security.py
+++ b/app/auth/security.py
@@ -16,4 +16,3 @@ class PasswordService:
             return bool(self._hasher.verify(password_hash, password))
         except (InvalidHashError, VerificationError):
             return False
-
diff --git a/app/auth/service.py b/app/auth/service.py
index 9772358..e13e3fe 100644
--- a/app/auth/service.py
+++ b/app/auth/service.py
@@ -21,9 +21,7 @@ class AuthService:
         normalized_email = email.strip().lower()
         if not normalized_email or not password:
             return None
-        result = await db_session.execute(
-            select(User).where(User.email == normalized_email)
-        )
+        result = await db_session.execute(select(User).where(User.email == normalized_email))
         user = result.scalar_one_or_none()
         if user is None or not user.is_active:
             return None
diff --git a/app/auth/session.py b/app/auth/session.py
index 8c83197..cf52836 100644
--- a/app/auth/session.py
+++ b/app/auth/session.py
@@ -4,7 +4,6 @@ from dataclasses import dataclass
 
 from starlette.requests import Request
 
-
 SESSION_USER_ID_KEY = "auth_user_id"
 SESSION_USER_EMAIL_KEY = "auth_user_email"
 SESSION_USER_IS_ADMIN_KEY = "auth_user_is_admin"
diff --git a/app/db/base.py b/app/db/base.py
index 6fa2049..78cb78d 100644
--- a/app/db/base.py
+++ b/app/db/base.py
@@ -1,9 +1,8 @@
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 
 from sqlalchemy import MetaData, event
 from sqlalchemy.orm import DeclarativeBase
 
-
 NAMING_CONVENTION = {
     "ix": "ix_%(column_0_label)s",
     "uq": "uq_%(table_name)s_%(column_0_name)s",
@@ -21,7 +20,7 @@ class Base(DeclarativeBase):
 def _set_updated_at_before_update(_mapper, _connection, target) -> None:
     # Keep audit timestamps current for ORM-managed updates.
     if hasattr(target, "updated_at"):
-        target.updated_at = datetime.now(timezone.utc)
+        target.updated_at = datetime.now(UTC)
 
 
 metadata = Base.metadata
diff --git a/app/db/models.py b/app/db/models.py
index 6a51811..66c6ff8 100644
--- a/app/db/models.py
+++ b/app/db/models.py
@@ -62,18 +62,10 @@ class User(Base):
     id: Mapped[int] = mapped_column(primary_key=True)
     email: Mapped[str] = mapped_column(String(255), nullable=False, unique=True)
     password_hash: Mapped[str] = mapped_column(String(255), nullable=False)
-    is_active: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("true")
-    )
-    is_admin: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("false")
-    )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    is_active: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("true"))
+    is_admin: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class UserSetting(Base):
@@ -89,18 +81,10 @@ class UserSetting(Base):
         ),
     )
 
-    user_id: Mapped[int] = mapped_column(
-        ForeignKey("users.id", ondelete="CASCADE"), primary_key=True
-    )
-    auto_run_enabled: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("false")
-    )
-    run_interval_minutes: Mapped[int] = mapped_column(
-        Integer, nullable=False, server_default=text("1440")
-    )
-    request_delay_seconds: Mapped[int] = mapped_column(
-        Integer, nullable=False, server_default=text("10")
-    )
+    user_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), primary_key=True)
+    auto_run_enabled: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+    run_interval_minutes: Mapped[int] = mapped_column(Integer, nullable=False, server_default=text("1440"))
+    request_delay_seconds: Mapped[int] = mapped_column(Integer, nullable=False, server_default=text("10"))
     nav_visible_pages: Mapped[list[str]] = mapped_column(
         JSONB,
         nullable=False,
@@ -115,17 +99,13 @@ class UserSetting(Base):
     )
     scrape_cooldown_until: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
     scrape_cooldown_reason: Mapped[str | None] = mapped_column(String(64))
-    
+
     openalex_api_key: Mapped[str | None] = mapped_column(String(255))
     crossref_api_token: Mapped[str | None] = mapped_column(String(255))
     crossref_api_mailto: Mapped[str | None] = mapped_column(String(255))
 
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class ScholarProfile(Base):
@@ -136,9 +116,7 @@ class ScholarProfile(Base):
     )
 
     id: Mapped[int] = mapped_column(primary_key=True)
-    user_id: Mapped[int] = mapped_column(
-        ForeignKey("users.id", ondelete="CASCADE"), nullable=False
-    )
+    user_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
     scholar_id: Mapped[str] = mapped_column(String(64), nullable=False)
     display_name: Mapped[str | None] = mapped_column(String(255))
     profile_image_url: Mapped[str | None] = mapped_column(Text)
@@ -146,22 +124,14 @@ class ScholarProfile(Base):
     profile_image_upload_path: Mapped[str | None] = mapped_column(Text)
     last_initial_page_fingerprint_sha256: Mapped[str | None] = mapped_column(String(64))
     last_initial_page_checked_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    is_enabled: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("true")
-    )
-    baseline_completed: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("false")
-    )
+    is_enabled: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("true"))
+    baseline_completed: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
     last_run_dt: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
     last_run_status: Mapped[RunStatus | None] = mapped_column(
         RUN_STATUS_DB_ENUM,
     )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class CrawlRun(Base):
@@ -172,51 +142,29 @@ class CrawlRun(Base):
             "uq_crawl_runs_user_active",
             "user_id",
             unique=True,
-            postgresql_where=text(
-                "status IN ('running'::run_status, 'resolving'::run_status)"
-            ),
+            postgresql_where=text("status IN ('running'::run_status, 'resolving'::run_status)"),
         ),
         Index(
             "uq_crawl_runs_user_manual_idempotency_key",
             "user_id",
             "idempotency_key",
             unique=True,
-            postgresql_where=text(
-                "idempotency_key IS NOT NULL AND trigger_type = 'manual'::run_trigger_type"
-            ),
+            postgresql_where=text("idempotency_key IS NOT NULL AND trigger_type = 'manual'::run_trigger_type"),
         ),
     )
 
     id: Mapped[int] = mapped_column(primary_key=True)
-    user_id: Mapped[int] = mapped_column(
-        ForeignKey("users.id", ondelete="CASCADE"), nullable=False
-    )
-    trigger_type: Mapped[RunTriggerType] = mapped_column(
-        RUN_TRIGGER_TYPE_DB_ENUM, nullable=False
-    )
-    status: Mapped[RunStatus] = mapped_column(
-        RUN_STATUS_DB_ENUM, nullable=False
-    )
-    start_dt: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    user_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
+    trigger_type: Mapped[RunTriggerType] = mapped_column(RUN_TRIGGER_TYPE_DB_ENUM, nullable=False)
+    status: Mapped[RunStatus] = mapped_column(RUN_STATUS_DB_ENUM, nullable=False)
+    start_dt: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
     end_dt: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    scholar_count: Mapped[int] = mapped_column(
-        Integer, nullable=False, server_default=text("0")
-    )
-    new_pub_count: Mapped[int] = mapped_column(
-        Integer, nullable=False, server_default=text("0")
-    )
+    scholar_count: Mapped[int] = mapped_column(Integer, nullable=False, server_default=text("0"))
+    new_pub_count: Mapped[int] = mapped_column(Integer, nullable=False, server_default=text("0"))
     idempotency_key: Mapped[str | None] = mapped_column(String(128))
-    error_log: Mapped[dict] = mapped_column(
-        JSONB, nullable=False, server_default=text("'{}'::jsonb")
-    )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    error_log: Mapped[dict] = mapped_column(JSONB, nullable=False, server_default=text("'{}'::jsonb"))
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class Publication(Base):
@@ -237,28 +185,16 @@ class Publication(Base):
     title_raw: Mapped[str] = mapped_column(Text, nullable=False)
     title_normalized: Mapped[str] = mapped_column(Text, nullable=False)
     year: Mapped[int | None] = mapped_column(Integer)
-    citation_count: Mapped[int] = mapped_column(
-        Integer, nullable=False, server_default=text("0")
-    )
+    citation_count: Mapped[int] = mapped_column(Integer, nullable=False, server_default=text("0"))
     author_text: Mapped[str | None] = mapped_column(Text)
     venue_text: Mapped[str | None] = mapped_column(Text)
     pub_url: Mapped[str | None] = mapped_column(Text)
     pdf_url: Mapped[str | None] = mapped_column(Text)
-    canonical_title_hash: Mapped[str | None] = mapped_column(
-        String(64), nullable=True, index=True
-    )
-    openalex_enriched: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("false")
-    )
-    openalex_last_attempt_at: Mapped[datetime | None] = mapped_column(
-        DateTime(timezone=True), nullable=True
-    )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    canonical_title_hash: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
+    openalex_enriched: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+    openalex_last_attempt_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class PublicationIdentifier(Base):
@@ -300,12 +236,8 @@ class PublicationIdentifier(Base):
         server_default=text("0"),
     )
     evidence_url: Mapped[str | None] = mapped_column(Text)
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class PublicationPdfJob(Base):
@@ -343,12 +275,8 @@ class PublicationPdfJob(Base):
     last_requested_by_user_id: Mapped[int | None] = mapped_column(
         ForeignKey("users.id", ondelete="SET NULL"),
     )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class PublicationPdfJobEvent(Base):
@@ -372,9 +300,7 @@ class PublicationPdfJobEvent(Base):
     source: Mapped[str | None] = mapped_column(String(32))
     failure_reason: Mapped[str | None] = mapped_column(String(64))
     message: Mapped[str | None] = mapped_column(Text)
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class ScholarPublication(Base):
@@ -392,18 +318,10 @@ class ScholarPublication(Base):
         ForeignKey("publications.id", ondelete="CASCADE"),
         primary_key=True,
     )
-    is_read: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("false")
-    )
-    is_favorite: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, server_default=text("false")
-    )
-    first_seen_run_id: Mapped[int | None] = mapped_column(
-        ForeignKey("crawl_runs.id", ondelete="SET NULL")
-    )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    is_read: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+    is_favorite: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+    first_seen_run_id: Mapped[int | None] = mapped_column(ForeignKey("crawl_runs.id", ondelete="SET NULL"))
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class IngestionQueueItem(Base):
@@ -458,12 +376,8 @@ class IngestionQueueItem(Base):
     last_error: Mapped[str | None] = mapped_column(Text)
     dropped_reason: Mapped[str | None] = mapped_column(String(128))
     dropped_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class DataRepairJob(Base):
@@ -503,12 +417,8 @@ class DataRepairJob(Base):
     error_text: Mapped[str | None] = mapped_column(Text)
     started_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
     finished_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class AuthorSearchRuntimeState(Base):
@@ -532,12 +442,8 @@ class AuthorSearchRuntimeState(Base):
         nullable=False,
         server_default=text("false"),
     )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class ArxivRuntimeState(Base):
@@ -546,12 +452,8 @@ class ArxivRuntimeState(Base):
     state_key: Mapped[str] = mapped_column(String(64), primary_key=True)
     next_allowed_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
     cooldown_until: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class ArxivQueryCacheEntry(Base):
@@ -570,12 +472,8 @@ class ArxivQueryCacheEntry(Base):
         DateTime(timezone=True),
         nullable=False,
     )
-    cached_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    cached_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
 
 
 class AuthorSearchCacheEntry(Base):
@@ -594,9 +492,5 @@ class AuthorSearchCacheEntry(Base):
         DateTime(timezone=True),
         nullable=False,
     )
-    cached_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
+    cached_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
diff --git a/app/db/session.py b/app/db/session.py
index 2223216..6d286ca 100644
--- a/app/db/session.py
+++ b/app/db/session.py
@@ -1,6 +1,6 @@
-from collections.abc import AsyncIterator
 import logging
 import os
+from collections.abc import AsyncIterator
 
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import (
@@ -32,7 +32,9 @@ def _normalized_pool_mode(raw_mode: str) -> str:
     if mode in {"null", "queue"}:
         return mode
     structured_log(
-        logger, "warning", "db.invalid_pool_mode_fallback",
+        logger,
+        "warning",
+        "db.invalid_pool_mode_fallback",
         database_pool_mode=raw_mode,
         fallback_mode="queue",
     )
@@ -55,7 +57,9 @@ def get_engine() -> AsyncEngine:
 
         _engine = create_async_engine(settings.database_url, **engine_kwargs)
         structured_log(
-            logger, "info", "db.engine_initialized",
+            logger,
+            "info",
+            "db.engine_initialized",
             pool_mode=pool_mode,
         )
     return _engine
diff --git a/app/http/middleware.py b/app/http/middleware.py
index 1cbea46..00223e0 100644
--- a/app/http/middleware.py
+++ b/app/http/middleware.py
@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from secrets import token_urlsafe
 import logging
 import time
+from secrets import token_urlsafe
 
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.requests import Request
@@ -63,7 +63,9 @@ class RequestLoggingMiddleware(BaseHTTPMiddleware):
         should_log = self._log_requests and not self._is_skipped_path(request.url.path)
         if should_log:
             structured_log(
-                logger, "debug", "request.started",
+                logger,
+                "debug",
+                "request.started",
                 method=request.method,
                 path=request.url.path,
             )
@@ -86,7 +88,9 @@ class RequestLoggingMiddleware(BaseHTTPMiddleware):
             response.headers[REQUEST_ID_HEADER] = request_id
             if should_log:
                 structured_log(
-                    logger, "debug", "request.completed",
+                    logger,
+                    "debug",
+                    "request.completed",
                     method=request.method,
                     path=request.url.path,
                     status_code=response.status_code,
@@ -164,11 +168,7 @@ class SecurityHeadersMiddleware(BaseHTTPMiddleware):
 
         csp_policy = self._csp_policy_for_path(request.url.path)
         if self._csp_enabled and csp_policy:
-            csp_header = (
-                "Content-Security-Policy-Report-Only"
-                if self._csp_report_only
-                else "Content-Security-Policy"
-            )
+            csp_header = "Content-Security-Policy-Report-Only" if self._csp_report_only else "Content-Security-Policy"
             response.headers.setdefault(csp_header, csp_policy)
 
         hsts = self._strict_transport_security_value()
diff --git a/app/logging_config.py b/app/logging_config.py
index 559a400..805fcbf 100644
--- a/app/logging_config.py
+++ b/app/logging_config.py
@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
 import json
 import logging
 import sys
+from datetime import UTC, datetime
 from typing import Any
 
 from app.logging_context import get_request_id
@@ -102,7 +102,9 @@ class JsonLogFormatter(logging.Formatter):
         if key.lower() in self._redact_fields:
             return "[REDACTED]"
         if isinstance(value, dict):
-            return {nested_key: self._redact_value(nested_key, nested_value) for nested_key, nested_value in value.items()}
+            return {
+                nested_key: self._redact_value(nested_key, nested_value) for nested_key, nested_value in value.items()
+            }
         if isinstance(value, (list, tuple)):
             return [self._redact_value(key, item) for item in value]
         return value
@@ -177,7 +179,7 @@ def _normalize_level(level: str) -> int:
 
 
 def _format_timestamp(created_ts: float) -> str:
-    dt = datetime.fromtimestamp(created_ts, tz=timezone.utc)
+    dt = datetime.fromtimestamp(created_ts, tz=UTC)
     return dt.strftime("%Y-%m-%d %H:%M:%SZ")
 
 
diff --git a/app/logging_context.py b/app/logging_context.py
index ee578fb..a45136b 100644
--- a/app/logging_context.py
+++ b/app/logging_context.py
@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from contextvars import ContextVar
 
-
 _request_id_ctx: ContextVar[str | None] = ContextVar("request_id", default=None)
 
 
@@ -12,4 +11,3 @@ def get_request_id() -> str | None:
 
 def set_request_id(value: str | None) -> None:
     _request_id_ctx.set(value)
-
diff --git a/app/main.py b/app/main.py
index 522a552..e83cc16 100644
--- a/app/main.py
+++ b/app/main.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from contextlib import asynccontextmanager
 import logging
+from contextlib import asynccontextmanager
 from pathlib import Path
 
 from fastapi import FastAPI, HTTPException
@@ -12,9 +12,7 @@ from starlette.middleware.sessions import SessionMiddleware
 from app.api.errors import register_api_exception_handlers
 from app.api.media import router as media_router
 from app.api.router import router as api_router
-from app.api.runtime_deps import get_ingestion_service, get_scholar_source
-from app.db.session import check_database
-from app.db.session import close_engine
+from app.db.session import check_database, close_engine
 from app.http.middleware import (
     RequestLoggingMiddleware,
     SecurityHeadersMiddleware,
@@ -54,19 +52,25 @@ scheduler_service = SchedulerService(
 @asynccontextmanager
 async def lifespan(_: FastAPI):
     structured_log(
-        logger, "info", "app.startup_build_marker",
+        logger,
+        "info",
+        "app.startup_build_marker",
         build_marker=BUILD_MARKER,
         frontend_enabled=settings.frontend_enabled,
         scheduler_enabled=settings.scheduler_enabled,
         log_format=settings.log_format,
     )
-    
-    from app.db.session import get_session_factory
+
     from sqlalchemy import text
+
+    from app.db.session import get_session_factory
+
     try:
         session_factory = get_session_factory()
         async with session_factory() as session:
-            await session.execute(text("UPDATE crawl_runs SET status = 'failed' WHERE status::text IN ('running', 'resolving')"))
+            await session.execute(
+                text("UPDATE crawl_runs SET status = 'failed' WHERE status::text IN ('running', 'resolving')")
+            )
             await session.commit()
             structured_log(logger, "info", "app.startup_orphaned_runs_cleaned")
     except Exception as e:
@@ -107,9 +111,7 @@ app.add_middleware(
     content_security_policy_report_only=settings.security_csp_report_only,
     strict_transport_security_enabled=settings.security_strict_transport_security_enabled,
     strict_transport_security_max_age=settings.security_strict_transport_security_max_age,
-    strict_transport_security_include_subdomains=(
-        settings.security_strict_transport_security_include_subdomains
-    ),
+    strict_transport_security_include_subdomains=(settings.security_strict_transport_security_include_subdomains),
     strict_transport_security_preload=settings.security_strict_transport_security_preload,
 )
 app.include_router(api_router)
diff --git a/app/security/__init__.py b/app/security/__init__.py
index 4033692..3cf1e91 100644
--- a/app/security/__init__.py
+++ b/app/security/__init__.py
@@ -1,2 +1 @@
 """Security middleware and helpers for scholarr."""
-
diff --git a/app/security/csrf.py b/app/security/csrf.py
index d2ed1c5..00119a9 100644
--- a/app/security/csrf.py
+++ b/app/security/csrf.py
@@ -38,7 +38,9 @@ class CSRFMiddleware(BaseHTTPMiddleware):
         session_token = request.session.get(CSRF_SESSION_KEY)
         if not session_token:
             structured_log(
-                logger, "warning", "csrf.missing_session_token",
+                logger,
+                "warning",
+                "csrf.missing_session_token",
                 method=request.method,
                 path=request.url.path,
             )
@@ -56,7 +58,9 @@ class CSRFMiddleware(BaseHTTPMiddleware):
 
         if not request_token or not compare_digest(str(session_token), str(request_token)):
             structured_log(
-                logger, "warning", "csrf.invalid_token",
+                logger,
+                "warning",
+                "csrf.invalid_token",
                 method=request.method,
                 path=request.url.path,
             )
diff --git a/app/services/__init__.py b/app/services/__init__.py
index 167f869..6093d3d 100644
--- a/app/services/__init__.py
+++ b/app/services/__init__.py
@@ -1,2 +1 @@
 """Service layer for scholarr application workflows."""
-
diff --git a/app/services/domains/arxiv/application.py b/app/services/domains/arxiv/application.py
index 8b99096..255795f 100644
--- a/app/services/domains/arxiv/application.py
+++ b/app/services/domains/arxiv/application.py
@@ -1,11 +1,11 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
+
 from app.services.domains.arxiv.gateway import (
     build_arxiv_query,
     get_arxiv_gateway,
 )
-from app.services.domains.arxiv.errors import ArxivRateLimitError
 
 if TYPE_CHECKING:
     from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
diff --git a/app/services/domains/arxiv/cache.py b/app/services/domains/arxiv/cache.py
index de16416..c0aa143 100644
--- a/app/services/domains/arxiv/cache.py
+++ b/app/services/domains/arxiv/cache.py
@@ -1,11 +1,11 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Awaitable, Callable, Mapping
-from dataclasses import asdict
-from datetime import datetime, timedelta, timezone
 import hashlib
 import json
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import asdict
+from datetime import UTC, datetime, timedelta
 from typing import Any
 
 from sqlalchemy import delete, func, select
@@ -33,15 +33,12 @@ async def get_cached_feed(
 ) -> ArxivFeed | None:
     timestamp = _as_utc(now_utc)
     session_factory = get_session_factory()
-    async with session_factory() as db_session:
-        async with db_session.begin():
-            result = await db_session.execute(
-                select(ArxivQueryCacheEntry).where(
-                    ArxivQueryCacheEntry.query_fingerprint == query_fingerprint
-                )
-            )
-            entry = result.scalar_one_or_none()
-            return await _validate_cached_entry(db_session, entry=entry, now_utc=timestamp)
+    async with session_factory() as db_session, db_session.begin():
+        result = await db_session.execute(
+            select(ArxivQueryCacheEntry).where(ArxivQueryCacheEntry.query_fingerprint == query_fingerprint)
+        )
+        entry = result.scalar_one_or_none()
+        return await _validate_cached_entry(db_session, entry=entry, now_utc=timestamp)
 
 
 async def set_cached_feed(
@@ -54,16 +51,15 @@ async def set_cached_feed(
 ) -> None:
     timestamp = _as_utc(now_utc)
     session_factory = get_session_factory()
-    async with session_factory() as db_session:
-        async with db_session.begin():
-            await _write_cached_entry(
-                db_session,
-                query_fingerprint=query_fingerprint,
-                feed=feed,
-                ttl_seconds=ttl_seconds,
-                max_entries=max_entries,
-                now_utc=timestamp,
-            )
+    async with session_factory() as db_session, db_session.begin():
+        await _write_cached_entry(
+            db_session,
+            query_fingerprint=query_fingerprint,
+            feed=feed,
+            ttl_seconds=ttl_seconds,
+            max_entries=max_entries,
+            now_utc=timestamp,
+        )
 
 
 async def run_with_inflight_dedupe(
@@ -142,9 +138,7 @@ async def _write_cached_entry(
 ) -> None:
     ttl = max(float(ttl_seconds), 0.0)
     result = await db_session.execute(
-        select(ArxivQueryCacheEntry).where(
-            ArxivQueryCacheEntry.query_fingerprint == query_fingerprint
-        )
+        select(ArxivQueryCacheEntry).where(ArxivQueryCacheEntry.query_fingerprint == query_fingerprint)
     )
     existing = result.scalar_one_or_none()
     if ttl <= 0.0:
@@ -177,30 +171,22 @@ async def _prune_cache_entries(
     now_utc: datetime,
     max_entries: int,
 ) -> None:
-    await db_session.execute(
-        delete(ArxivQueryCacheEntry).where(ArxivQueryCacheEntry.expires_at <= now_utc)
-    )
+    await db_session.execute(delete(ArxivQueryCacheEntry).where(ArxivQueryCacheEntry.expires_at <= now_utc))
     bounded_max_entries = int(max_entries)
     if bounded_max_entries <= 0:
         return
-    count_result = await db_session.execute(
-        select(func.count()).select_from(ArxivQueryCacheEntry)
-    )
+    count_result = await db_session.execute(select(func.count()).select_from(ArxivQueryCacheEntry))
     entry_count = int(count_result.scalar_one() or 0)
     overflow = max(0, entry_count - bounded_max_entries)
     if overflow <= 0:
         return
     stale_result = await db_session.execute(
-        select(ArxivQueryCacheEntry.query_fingerprint)
-        .order_by(ArxivQueryCacheEntry.cached_at.asc())
-        .limit(overflow)
+        select(ArxivQueryCacheEntry.query_fingerprint).order_by(ArxivQueryCacheEntry.cached_at.asc()).limit(overflow)
     )
     stale_keys = [str(row[0]) for row in stale_result.all()]
     if stale_keys:
         await db_session.execute(
-            delete(ArxivQueryCacheEntry).where(
-                ArxivQueryCacheEntry.query_fingerprint.in_(stale_keys)
-            )
+            delete(ArxivQueryCacheEntry).where(ArxivQueryCacheEntry.query_fingerprint.in_(stale_keys))
         )
 
 
@@ -275,9 +261,9 @@ def _as_string_list(value: object) -> list[str]:
 
 def _as_utc(value: datetime | None) -> datetime:
     if value is None:
-        return datetime.now(timezone.utc)
+        return datetime.now(UTC)
     if value.tzinfo is None:
-        return value.replace(tzinfo=timezone.utc)
+        return value.replace(tzinfo=UTC)
     return value
 
 
diff --git a/app/services/domains/arxiv/client.py b/app/services/domains/arxiv/client.py
index 7bbf87c..7318271 100644
--- a/app/services/domains/arxiv/client.py
+++ b/app/services/domains/arxiv/client.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
 import logging
+from collections.abc import Awaitable, Callable
 
 import httpx
 
@@ -103,9 +103,13 @@ class ArxivClient:
         if self._cache_enabled:
             cached = await get_cached_feed(query_fingerprint=query_fingerprint)
             if cached is not None:
-                structured_log(logger, "info", "arxiv.cache_hit", query_fingerprint=query_fingerprint, source_path=source_path)
+                structured_log(
+                    logger, "info", "arxiv.cache_hit", query_fingerprint=query_fingerprint, source_path=source_path
+                )
                 return cached
-            structured_log(logger, "info", "arxiv.cache_miss", query_fingerprint=query_fingerprint, source_path=source_path)
+            structured_log(
+                logger, "info", "arxiv.cache_miss", query_fingerprint=query_fingerprint, source_path=source_path
+            )
         return await run_with_inflight_dedupe(
             query_fingerprint=query_fingerprint,
             fetch_feed=lambda: self._fetch_live_feed(
@@ -216,13 +220,13 @@ async def _request_arxiv_feed(
     cooldown_status = await get_arxiv_cooldown_status()
     if cooldown_status.is_active:
         structured_log(
-            logger, "warning", "arxiv.request_skipped_cooldown",
+            logger,
+            "warning",
+            "arxiv.request_skipped_cooldown",
             source_path=source_path,
             cooldown_remaining_seconds=float(cooldown_status.remaining_seconds),
         )
-        raise ArxivRateLimitError(
-            f"arXiv global cooldown active ({cooldown_status.remaining_seconds:.0f}s remaining)"
-        )
+        raise ArxivRateLimitError(f"arXiv global cooldown active ({cooldown_status.remaining_seconds:.0f}s remaining)")
 
     async def _fetch() -> httpx.Response:
         timeout_value = _timeout_seconds(timeout_seconds)
@@ -272,5 +276,3 @@ def _source_path_from_params(params: dict[str, object]) -> str:
     if "id_list" in params:
         return ARXIV_SOURCE_PATH_LOOKUP_IDS
     return ARXIV_SOURCE_PATH_UNKNOWN
-
-
diff --git a/app/services/domains/arxiv/gateway.py b/app/services/domains/arxiv/gateway.py
index 67d9543..5c13b35 100644
--- a/app/services/domains/arxiv/gateway.py
+++ b/app/services/domains/arxiv/gateway.py
@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import logging
 import re
-from typing import TYPE_CHECKING, Protocol
 import unicodedata
+from typing import TYPE_CHECKING, Protocol
 
 from app.logging_utils import structured_log
 from app.services.domains.arxiv.client import ArxivClient
diff --git a/app/services/domains/arxiv/rate_limit.py b/app/services/domains/arxiv/rate_limit.py
index 52e2c3f..ddc5cab 100644
--- a/app/services/domains/arxiv/rate_limit.py
+++ b/app/services/domains/arxiv/rate_limit.py
@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-import logging
+from datetime import UTC, datetime, timedelta
 
 import httpx
 from sqlalchemy import select, text
@@ -47,13 +47,11 @@ async def run_with_global_arxiv_limit(
 
 
 async def get_arxiv_cooldown_status(*, now_utc: datetime | None = None) -> ArxivCooldownStatus:
-    timestamp = _normalize_datetime(now_utc) or datetime.now(timezone.utc)
+    timestamp = _normalize_datetime(now_utc) or datetime.now(UTC)
     session_factory = get_session_factory()
     async with session_factory() as db_session:
         result = await db_session.execute(
-            select(ArxivRuntimeState.cooldown_until).where(
-                ArxivRuntimeState.state_key == ARXIV_RUNTIME_STATE_KEY
-            )
+            select(ArxivRuntimeState.cooldown_until).where(ArxivRuntimeState.state_key == ARXIV_RUNTIME_STATE_KEY)
         )
     cooldown_until = _normalize_datetime(result.scalar_one_or_none())
     remaining_seconds = _cooldown_remaining_seconds(cooldown_until, now_utc=timestamp)
@@ -85,10 +83,14 @@ async def _run_serialized_fetch(
                 source_path=source_path,
             )
             structured_log(
-                logger, "info", "arxiv.request_completed",
+                logger,
+                "info",
+                "arxiv.request_completed",
                 status_code=int(response.status_code),
                 wait_seconds=wait_seconds,
-                cooldown_remaining_seconds=_cooldown_remaining_seconds(runtime_state.cooldown_until, now_utc=datetime.now(timezone.utc)),
+                cooldown_remaining_seconds=_cooldown_remaining_seconds(
+                    runtime_state.cooldown_until, now_utc=datetime.now(UTC)
+                ),
                 source_path=source_path,
             )
             return response, hit_rate_limit
@@ -106,9 +108,7 @@ async def _acquire_arxiv_lock(db_session: AsyncSession) -> None:
 
 async def _load_runtime_state_for_update(db_session: AsyncSession) -> ArxivRuntimeState:
     result = await db_session.execute(
-        select(ArxivRuntimeState)
-        .where(ArxivRuntimeState.state_key == ARXIV_RUNTIME_STATE_KEY)
-        .with_for_update()
+        select(ArxivRuntimeState).where(ArxivRuntimeState.state_key == ARXIV_RUNTIME_STATE_KEY).with_for_update()
     )
     state = result.scalar_one_or_none()
     if state is not None:
@@ -124,13 +124,27 @@ async def _wait_for_allowed_slot_or_raise(
     *,
     source_path: str,
 ) -> float:
-    now_utc = datetime.now(timezone.utc)
+    now_utc = datetime.now(UTC)
     cooldown_seconds = _cooldown_remaining_seconds(runtime_state.cooldown_until, now_utc=now_utc)
     if cooldown_seconds > 0:
-        structured_log(logger, "info", "arxiv.request_scheduled", wait_seconds=0.0, source_path=source_path, cooldown_remaining_seconds=cooldown_seconds)
+        structured_log(
+            logger,
+            "info",
+            "arxiv.request_scheduled",
+            wait_seconds=0.0,
+            source_path=source_path,
+            cooldown_remaining_seconds=cooldown_seconds,
+        )
         raise ArxivRateLimitError(f"arXiv global cooldown active ({cooldown_seconds:.0f}s remaining)")
     wait_seconds = _next_allowed_wait_seconds(runtime_state.next_allowed_at, now_utc=now_utc)
-    structured_log(logger, "info", "arxiv.request_scheduled", wait_seconds=wait_seconds, source_path=source_path, cooldown_remaining_seconds=0.0)
+    structured_log(
+        logger,
+        "info",
+        "arxiv.request_scheduled",
+        wait_seconds=wait_seconds,
+        source_path=source_path,
+        cooldown_remaining_seconds=0.0,
+    )
     if wait_seconds > 0:
         await asyncio.sleep(wait_seconds)
     return wait_seconds
@@ -142,13 +156,15 @@ def _record_post_response_state(
     response_status: int,
     source_path: str,
 ) -> bool:
-    now_utc = datetime.now(timezone.utc)
+    now_utc = datetime.now(UTC)
     runtime_state.next_allowed_at = now_utc + timedelta(seconds=_min_interval_seconds())
     if response_status == 429:
         cooldown_seconds = _cooldown_seconds()
         runtime_state.cooldown_until = now_utc + timedelta(seconds=cooldown_seconds)
         structured_log(
-            logger, "warning", "arxiv.cooldown_activated",
+            logger,
+            "warning",
+            "arxiv.cooldown_activated",
             cooldown_remaining_seconds=cooldown_seconds,
             source_path=source_path,
         )
@@ -176,7 +192,7 @@ def _normalize_datetime(value: datetime | None) -> datetime | None:
     if value is None:
         return None
     if value.tzinfo is None:
-        return value.replace(tzinfo=timezone.utc)
+        return value.replace(tzinfo=UTC)
     return value
 
 
@@ -186,5 +202,3 @@ def _min_interval_seconds() -> float:
 
 def _cooldown_seconds() -> float:
     return max(float(settings.arxiv_rate_limit_cooldown_seconds), 0.0)
-
-
diff --git a/app/services/domains/crossref/application.py b/app/services/domains/crossref/application.py
index 7212101..9b7076c 100644
--- a/app/services/domains/crossref/application.py
+++ b/app/services/domains/crossref/application.py
@@ -9,8 +9,8 @@ from typing import TYPE_CHECKING
 
 from crossref.restful import Etiquette, Works
 
-from app.services.domains.doi.normalize import normalize_doi
 from app.logging_utils import structured_log
+from app.services.domains.doi.normalize import normalize_doi
 from app.settings import settings
 
 if TYPE_CHECKING:
@@ -38,7 +38,7 @@ def _rate_limit_wait(min_interval_seconds: float) -> None:
 
 
 def _normalized_tokens(value: str) -> list[str]:
-    lowered = value.lower().replace("’", "'").replace("“", "\"").replace("”", "\"")
+    lowered = value.lower().replace("’", "'").replace("“", '"').replace("”", '"')
     lowered = NON_ALNUM_RE.sub(" ", lowered)
     return [token for token in TOKEN_RE.findall(lowered) if len(token) >= 3]
 
diff --git a/app/services/domains/dbops/__init__.py b/app/services/domains/dbops/__init__.py
index cdc5177..0439955 100644
--- a/app/services/domains/dbops/__init__.py
+++ b/app/services/domains/dbops/__init__.py
@@ -1,8 +1,8 @@
 from app.services.domains.dbops.application import run_publication_link_repair
+from app.services.domains.dbops.integrity import collect_integrity_report
 from app.services.domains.dbops.near_duplicate_repair import (
     run_publication_near_duplicate_repair,
 )
-from app.services.domains.dbops.integrity import collect_integrity_report
 from app.services.domains.dbops.query import list_repair_jobs
 
 __all__ = [
diff --git a/app/services/domains/dbops/application.py b/app/services/domains/dbops/application.py
index e7ace77..7c59033 100644
--- a/app/services/domains/dbops/application.py
+++ b/app/services/domains/dbops/application.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from typing import Any
 
 from sqlalchemy import delete, exists, func, select, update
@@ -8,7 +8,6 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import DataRepairJob, IngestionQueueItem, Publication, ScholarProfile, ScholarPublication
 
-
 REPAIR_STATUS_PLANNED = "planned"
 REPAIR_STATUS_RUNNING = "running"
 REPAIR_STATUS_COMPLETED = "completed"
@@ -18,7 +17,7 @@ SCOPE_MODE_ALL_USERS = "all_users"
 
 
 def _utcnow() -> datetime:
-    return datetime.now(timezone.utc)
+    return datetime.now(UTC)
 
 
 def _normalize_scope_mode(scope_mode: str) -> str:
@@ -105,11 +104,7 @@ async def _count_orphan_publications(db_session: AsyncSession) -> int:
     stmt = (
         select(func.count())
         .select_from(Publication)
-        .where(
-            ~exists(
-                select(1).where(ScholarPublication.publication_id == Publication.id)
-            )
-        )
+        .where(~exists(select(1).where(ScholarPublication.publication_id == Publication.id)))
     )
     result = await db_session.execute(stmt)
     return int(result.scalar_one() or 0)
@@ -158,9 +153,7 @@ def _job_summary(
 
 async def _delete_links_for_targets(db_session: AsyncSession, *, target_scholar_profile_ids: list[int]) -> int:
     result = await db_session.execute(
-        delete(ScholarPublication).where(
-            ScholarPublication.scholar_profile_id.in_(target_scholar_profile_ids)
-        )
+        delete(ScholarPublication).where(ScholarPublication.scholar_profile_id.in_(target_scholar_profile_ids))
     )
     return int(result.rowcount or 0)
 
@@ -171,9 +164,7 @@ async def _delete_queue_for_targets(
     user_id: int | None,
     target_scholar_profile_ids: list[int],
 ) -> int:
-    stmt = delete(IngestionQueueItem).where(
-        IngestionQueueItem.scholar_profile_id.in_(target_scholar_profile_ids)
-    )
+    stmt = delete(IngestionQueueItem).where(IngestionQueueItem.scholar_profile_id.in_(target_scholar_profile_ids))
     if user_id is not None:
         stmt = stmt.where(IngestionQueueItem.user_id == user_id)
     result = await db_session.execute(stmt)
@@ -203,9 +194,7 @@ async def _reset_scholar_tracking_state(
 
 async def _delete_orphan_publications(db_session: AsyncSession) -> int:
     result = await db_session.execute(
-        delete(Publication).where(
-            ~exists(select(1).where(ScholarPublication.publication_id == Publication.id))
-        )
+        delete(Publication).where(~exists(select(1).where(ScholarPublication.publication_id == Publication.id)))
     )
     return int(result.rowcount or 0)
 
diff --git a/app/services/domains/dbops/integrity.py b/app/services/domains/dbops/integrity.py
index 4d9c43c..f05d9a3 100644
--- a/app/services/domains/dbops/integrity.py
+++ b/app/services/domains/dbops/integrity.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from typing import Any
 
 from sqlalchemy import func, select, text
@@ -168,7 +168,7 @@ async def collect_integrity_report(db_session: AsyncSession) -> dict[str, Any]:
 
     return {
         "status": _status_from_issues(failures=failures, warnings=warnings),
-        "checked_at": datetime.now(timezone.utc).isoformat(),
+        "checked_at": datetime.now(UTC).isoformat(),
         "failures": failures,
         "warnings": warnings,
         "checks": checks,
diff --git a/app/services/domains/dbops/near_duplicate_repair.py b/app/services/domains/dbops/near_duplicate_repair.py
index ab86c70..f7ebac8 100644
--- a/app/services/domains/dbops/near_duplicate_repair.py
+++ b/app/services/domains/dbops/near_duplicate_repair.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from typing import Any
 
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -17,7 +17,7 @@ NEAR_DUP_DEFAULT_MAX_CLUSTERS = 25
 
 
 def _utcnow() -> datetime:
-    return datetime.now(timezone.utc)
+    return datetime.now(UTC)
 
 
 def _normalized_cluster_keys(values: list[str] | None) -> list[str]:
diff --git a/app/services/domains/dbops/query.py b/app/services/domains/dbops/query.py
index 2e95e31..f65c582 100644
--- a/app/services/domains/dbops/query.py
+++ b/app/services/domains/dbops/query.py
@@ -16,7 +16,5 @@ async def list_repair_jobs(
     limit: int = 50,
 ) -> list[DataRepairJob]:
     bounded = _bounded_limit(limit)
-    result = await db_session.execute(
-        select(DataRepairJob).order_by(DataRepairJob.created_at.desc()).limit(bounded)
-    )
+    result = await db_session.execute(select(DataRepairJob).order_by(DataRepairJob.created_at.desc()).limit(bounded))
     return list(result.scalars())
diff --git a/app/services/domains/ingestion/application.py b/app/services/domains/ingestion/application.py
index 4b619d7..1098c1b 100644
--- a/app/services/domains/ingestion/application.py
+++ b/app/services/domains/ingestion/application.py
@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 import asyncio
-from datetime import datetime, timedelta, timezone
 import hashlib
 import logging
 import re
+from datetime import UTC, datetime, timedelta
 from typing import Any
 
 from sqlalchemy import or_, select, text
@@ -19,6 +19,11 @@ from app.db.models import (
     ScholarProfile,
     ScholarPublication,
 )
+from app.logging_utils import structured_log
+from app.services.domains.arxiv.errors import ArxivRateLimitError
+from app.services.domains.doi.normalize import first_doi_from_texts
+from app.services.domains.ingestion import queue as queue_service
+from app.services.domains.ingestion import safety as run_safety_service
 from app.services.domains.ingestion.constants import (
     FAILED_STATES,
     FAILURE_BUCKET_BLOCKED,
@@ -30,9 +35,6 @@ from app.services.domains.ingestion.constants import (
     RESUMABLE_PARTIAL_REASONS,
     RUN_LOCK_NAMESPACE,
 )
-from app.services.domains.arxiv.errors import ArxivRateLimitError
-from app.services.domains.doi.normalize import first_doi_from_texts
-from app.services.domains.publication_identifiers import application as identifier_service
 from app.services.domains.ingestion.fingerprints import (
     _build_body_excerpt,
     _dedupe_publication_candidates,
@@ -43,8 +45,6 @@ from app.services.domains.ingestion.fingerprints import (
     canonical_title_for_dedup,
     normalize_title,
 )
-from app.services.domains.ingestion import queue as queue_service
-from app.services.domains.ingestion import safety as run_safety_service
 from app.services.domains.ingestion.types import (
     PagedLoopState,
     PagedParseResult,
@@ -56,17 +56,17 @@ from app.services.domains.ingestion.types import (
     RunProgress,
     ScholarProcessingOutcome,
 )
-from app.services.domains.settings import application as user_settings_service
+from app.services.domains.publication_identifiers import application as identifier_service
 from app.services.domains.runs.events import run_events
 from app.services.domains.scholar.parser import (
-    ParseState,
     ParsedProfilePage,
+    ParseState,
     PublicationCandidate,
     ScholarParserError,
     parse_profile_page,
 )
 from app.services.domains.scholar.source import FetchResult, ScholarSource
-from app.logging_utils import structured_log
+from app.services.domains.settings import application as user_settings_service
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
@@ -147,18 +147,20 @@ class ScholarIngestionService:
         user_id: int,
         trigger_type: RunTriggerType,
     ) -> None:
-        now_utc = datetime.now(timezone.utc)
+        now_utc = datetime.now(UTC)
         previous = run_safety_service.get_safety_event_context(user_settings, now_utc=now_utc)
         if run_safety_service.clear_expired_cooldown(user_settings, now_utc=now_utc):
             await db_session.commit()
             await db_session.refresh(user_settings)
             structured_log(
-                logger, "info", "ingestion.cooldown_cleared",
+                logger,
+                "info",
+                "ingestion.cooldown_cleared",
                 user_id=user_id,
                 reason=previous.get("cooldown_reason"),
                 cooldown_until=previous.get("cooldown_until"),
             )
-            now_utc = datetime.now(timezone.utc)
+            now_utc = datetime.now(UTC)
         if run_safety_service.is_cooldown_active(user_settings, now_utc=now_utc):
             await self._raise_safety_blocked_start(
                 db_session,
@@ -183,7 +185,9 @@ class ScholarIngestionService:
         )
         await db_session.commit()
         structured_log(
-            logger, "warning", "ingestion.safety_policy_blocked_run_start",
+            logger,
+            "warning",
+            "ingestion.safety_policy_blocked_run_start",
             user_id=user_id,
             trigger_type=trigger_type.value,
             reason=safety_state.get("cooldown_reason"),
@@ -204,14 +208,9 @@ class ScholarIngestionService:
         start_cstart_by_scholar_id: dict[int, int] | None,
     ) -> tuple[set[int] | None, dict[int, int]]:
         filtered_scholar_ids = (
-            {int(value) for value in scholar_profile_ids}
-            if scholar_profile_ids is not None
-            else None
+            {int(value) for value in scholar_profile_ids} if scholar_profile_ids is not None else None
         )
-        start_cstart_map = {
-            int(key): max(0, int(value))
-            for key, value in (start_cstart_by_scholar_id or {}).items()
-        }
+        start_cstart_map = {int(key): max(0, int(value)) for key, value in (start_cstart_by_scholar_id or {}).items()}
         return filtered_scholar_ids, start_cstart_map
 
     async def _load_target_scholars(
@@ -521,7 +520,9 @@ class ScholarIngestionService:
             page_logs=paged_parse_result.page_logs,
         )
         structured_log(
-            logger, "warning", "ingestion.scholar_parse_failed",
+            logger,
+            "warning",
+            "ingestion.scholar_parse_failed",
             scholar_profile_id=scholar.id,
             scholar_id=scholar.scholar_id,
             state=paged_parse_result.parsed_page.state.value,
@@ -679,7 +680,7 @@ class ScholarIngestionService:
         max_pages_per_scholar: int,
         page_size: int,
     ) -> tuple[datetime, PagedParseResult, dict[str, Any]]:
-        run_dt = datetime.now(timezone.utc)
+        run_dt = datetime.now(UTC)
         paged_parse_result = await self._fetch_and_parse_all_pages_with_retry(
             scholar=scholar,
             run=run,
@@ -698,7 +699,9 @@ class ScholarIngestionService:
         self._apply_first_page_profile_metadata(scholar=scholar, paged_parse_result=paged_parse_result, run_dt=run_dt)
         parsed_page = paged_parse_result.parsed_page
         structured_log(
-            logger, "info", "ingestion.scholar_parsed",
+            logger,
+            "info",
+            "ingestion.scholar_parsed",
             user_id=user_id,
             crawl_run_id=run.id,
             scholar_profile_id=scholar.id,
@@ -796,9 +799,7 @@ class ScholarIngestionService:
             scholar_results=progress.scholar_results,
             scholar_profile_id=scholar_profile_id,
         )
-        next_succeeded, next_failed, next_partial = ScholarIngestionService._result_counters(
-            outcome.result_entry
-        )
+        next_succeeded, next_failed, next_partial = ScholarIngestionService._result_counters(outcome.result_entry)
         if prior_index is None:
             progress.scholar_results.append(outcome.result_entry)
             ScholarIngestionService._adjust_progress_counts(
@@ -809,9 +810,7 @@ class ScholarIngestionService:
             )
             return
         previous_entry = progress.scholar_results[prior_index]
-        prev_succeeded, prev_failed, prev_partial = ScholarIngestionService._result_counters(
-            previous_entry
-        )
+        prev_succeeded, prev_failed, prev_partial = ScholarIngestionService._result_counters(previous_entry)
         progress.scholar_results[prior_index] = outcome.result_entry
         ScholarIngestionService._adjust_progress_counts(
             progress=progress,
@@ -829,7 +828,7 @@ class ScholarIngestionService:
         exc: Exception,
     ) -> ScholarProcessingOutcome:
         scholar.last_run_status = RunStatus.FAILED
-        scholar.last_run_dt = datetime.now(timezone.utc)
+        scholar.last_run_dt = datetime.now(UTC)
         logger.exception(
             "ingestion.scholar_unexpected_failure",
             extra={
@@ -933,7 +932,7 @@ class ScholarIngestionService:
     ) -> None:
         pre_apply_state = run_safety_service.get_safety_event_context(
             user_settings,
-            now_utc=datetime.now(timezone.utc),
+            now_utc=datetime.now(UTC),
         )
         safety_state, cooldown_trigger_reason = run_safety_service.apply_run_safety_outcome(
             user_settings,
@@ -944,11 +943,13 @@ class ScholarIngestionService:
             network_failure_threshold=alert_summary.network_failure_threshold,
             blocked_cooldown_seconds=settings.ingestion_safety_cooldown_blocked_seconds,
             network_cooldown_seconds=settings.ingestion_safety_cooldown_network_seconds,
-            now_utc=datetime.now(timezone.utc),
+            now_utc=datetime.now(UTC),
         )
         if cooldown_trigger_reason is not None:
             structured_log(
-                logger, "warning", "ingestion.safety_cooldown_entered",
+                logger,
+                "warning",
+                "ingestion.safety_cooldown_entered",
                 user_id=user_id,
                 crawl_run_id=int(run.id),
                 reason=cooldown_trigger_reason,
@@ -962,7 +963,9 @@ class ScholarIngestionService:
             )
         elif pre_apply_state.get("cooldown_active") and not safety_state.get("cooldown_active"):
             structured_log(
-                logger, "info", "ingestion.cooldown_cleared",
+                logger,
+                "info",
+                "ingestion.cooldown_cleared",
                 user_id=user_id,
                 crawl_run_id=int(run.id),
                 reason=pre_apply_state.get("cooldown_reason"),
@@ -979,7 +982,7 @@ class ScholarIngestionService:
         alert_summary: RunAlertSummary,
         idempotency_key: str | None,
     ) -> None:
-        run.end_dt = datetime.now(timezone.utc)
+        run.end_dt = datetime.now(UTC)
         if run.status != RunStatus.CANCELED:
             run.status = self._resolve_run_status(
                 scholar_count=len(scholars),
@@ -1062,7 +1065,26 @@ class ScholarIngestionService:
             new_publication_count=run.new_pub_count,
         )
 
-    async def _initialize_run_for_user(self, db_session: AsyncSession, *, user_id: int, trigger_type: RunTriggerType, scholar_profile_ids: set[int] | None, start_cstart_by_scholar_id: dict[int, int] | None, request_delay_seconds: int, network_error_retries: int, retry_backoff_seconds: float, rate_limit_retries: int, rate_limit_backoff_seconds: float, max_pages_per_scholar: int, page_size: int, idempotency_key: str | None, alert_blocked_failure_threshold: int, alert_network_failure_threshold: int, alert_retry_scheduled_threshold: int) -> tuple[Any, CrawlRun, list[ScholarProfile], dict[int, int]]:
+    async def _initialize_run_for_user(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_id: int,
+        trigger_type: RunTriggerType,
+        scholar_profile_ids: set[int] | None,
+        start_cstart_by_scholar_id: dict[int, int] | None,
+        request_delay_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+        max_pages_per_scholar: int,
+        page_size: int,
+        idempotency_key: str | None,
+        alert_blocked_failure_threshold: int,
+        alert_network_failure_threshold: int,
+        alert_retry_scheduled_threshold: int,
+    ) -> tuple[Any, CrawlRun, list[ScholarProfile], dict[int, int]]:
         user_settings = await self._load_user_settings_for_run(
             db_session,
             user_id=user_id,
@@ -1116,7 +1138,9 @@ class ScholarIngestionService:
         alert_retry_scheduled_threshold: int,
     ) -> CrawlRun:
         structured_log(
-            logger, "info", "ingestion.run_started",
+            logger,
+            "info",
+            "ingestion.run_started",
             user_id=user_id,
             trigger_type=trigger_type.value,
             scholar_count=len(scholars),
@@ -1143,9 +1167,7 @@ class ScholarIngestionService:
         except IntegrityError as exc:
             if _is_active_run_integrity_error(exc):
                 await db_session.rollback()
-                raise RunAlreadyInProgressError(
-                    f"Run already in progress for user_id={user_id}."
-                ) from exc
+                raise RunAlreadyInProgressError(f"Run already in progress for user_id={user_id}.") from exc
             raise
         return run
 
@@ -1177,8 +1199,11 @@ class ScholarIngestionService:
             await db_session.refresh(run)
             if run.status == RunStatus.CANCELED:
                 structured_log(
-                    logger, "info", "ingestion.run_canceled",
-                    run_id=run.id, user_id=user_id,
+                    logger,
+                    "info",
+                    "ingestion.run_canceled",
+                    run_id=run.id,
+                    user_id=user_id,
                 )
                 return progress
             await self._wait_between_scholars(index=index, request_delay_seconds=request_delay_seconds)
@@ -1217,8 +1242,11 @@ class ScholarIngestionService:
             await db_session.refresh(run)
             if run.status == RunStatus.CANCELED:
                 structured_log(
-                    logger, "info", "ingestion.run_canceled",
-                    run_id=run.id, user_id=user_id,
+                    logger,
+                    "info",
+                    "ingestion.run_canceled",
+                    run_id=run.id,
+                    user_id=user_id,
                 )
                 break
             await self._wait_between_scholars(index=index, request_delay_seconds=request_delay_seconds)
@@ -1263,7 +1291,9 @@ class ScholarIngestionService:
         )
         if alert_summary.alert_flags["blocked_failure_threshold_exceeded"]:
             structured_log(
-                logger, "warning", "ingestion.alert_blocked_failure_threshold_exceeded",
+                logger,
+                "warning",
+                "ingestion.alert_blocked_failure_threshold_exceeded",
                 user_id=user_id,
                 crawl_run_id=int(run.id),
                 blocked_failure_count=alert_summary.blocked_failure_count,
@@ -1271,7 +1301,9 @@ class ScholarIngestionService:
             )
         if alert_summary.alert_flags["network_failure_threshold_exceeded"]:
             structured_log(
-                logger, "warning", "ingestion.alert_network_failure_threshold_exceeded",
+                logger,
+                "warning",
+                "ingestion.alert_network_failure_threshold_exceeded",
                 user_id=user_id,
                 crawl_run_id=int(run.id),
                 network_failure_count=alert_summary.network_failure_count,
@@ -1279,7 +1311,9 @@ class ScholarIngestionService:
             )
         if alert_summary.alert_flags["retry_scheduled_threshold_exceeded"]:
             structured_log(
-                logger, "warning", "ingestion.alert_retry_scheduled_threshold_exceeded",
+                logger,
+                "warning",
+                "ingestion.alert_retry_scheduled_threshold_exceeded",
                 user_id=user_id,
                 crawl_run_id=int(run.id),
                 retries_scheduled_count=failure_summary.retries_scheduled_count,
@@ -1319,7 +1353,9 @@ class ScholarIngestionService:
         effective_delay = self._effective_request_delay_seconds(request_delay_seconds)
         if effective_delay != _int_or_default(request_delay_seconds, effective_delay):
             structured_log(
-                logger, "warning", "ingestion.delay_coerced",
+                logger,
+                "warning",
+                "ingestion.delay_coerced",
                 user_id=user_id,
                 requested_request_delay_seconds=_int_or_default(request_delay_seconds, 0),
                 effective_request_delay_seconds=effective_delay,
@@ -1332,8 +1368,12 @@ class ScholarIngestionService:
             request_delay_seconds=effective_delay,
             network_error_retries=network_error_retries,
             retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries if rate_limit_retries is not None else settings.ingestion_rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds if rate_limit_backoff_seconds is not None else settings.ingestion_rate_limit_backoff_seconds,
+            rate_limit_retries=rate_limit_retries
+            if rate_limit_retries is not None
+            else settings.ingestion_rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds
+            if rate_limit_backoff_seconds is not None
+            else settings.ingestion_rate_limit_backoff_seconds,
             max_pages_per_scholar=max_pages_per_scholar,
             page_size=page_size,
         )
@@ -1383,13 +1423,17 @@ class ScholarIngestionService:
                 run, user_settings, attached_scholars = await self._prepare_execute_run(
                     db_session, run_id=run_id, user_id=user_id, scholars=scholars
                 )
-                
+
                 paging_kwargs = self._paging_kwargs(
                     request_delay_seconds=request_delay_seconds,
                     network_error_retries=network_error_retries,
                     retry_backoff_seconds=retry_backoff_seconds,
-                    rate_limit_retries=rate_limit_retries if rate_limit_retries is not None else settings.ingestion_rate_limit_retries,
-                    rate_limit_backoff_seconds=rate_limit_backoff_seconds if rate_limit_backoff_seconds is not None else settings.ingestion_rate_limit_backoff_seconds,
+                    rate_limit_retries=rate_limit_retries
+                    if rate_limit_retries is not None
+                    else settings.ingestion_rate_limit_retries,
+                    rate_limit_backoff_seconds=rate_limit_backoff_seconds
+                    if rate_limit_backoff_seconds is not None
+                    else settings.ingestion_rate_limit_backoff_seconds,
                     max_pages_per_scholar=max_pages_per_scholar,
                     page_size=page_size,
                 )
@@ -1427,7 +1471,9 @@ class ScholarIngestionService:
                     run.status = RunStatus.RESOLVING
                 await db_session.commit()
                 structured_log(
-                    logger, "info", "ingestion.run_completed",
+                    logger,
+                    "info",
+                    "ingestion.run_completed",
                     user_id=user_id,
                     crawl_run_id=run.id,
                     status=run.status.value,
@@ -1471,7 +1517,8 @@ class ScholarIngestionService:
 
         scholar_ids = [s.id for s in scholars]
         scholars_result = await db_session.execute(
-            select(ScholarProfile).where(ScholarProfile.id.in_(scholar_ids))
+            select(ScholarProfile)
+            .where(ScholarProfile.id.in_(scholar_ids))
             .order_by(ScholarProfile.created_at.asc(), ScholarProfile.id.asc())
         )
         return run, user_settings, list(scholars_result.scalars().all())
@@ -1481,7 +1528,7 @@ class ScholarIngestionService:
             run_to_fail = await cleanup_session.get(CrawlRun, run_id)
             if run_to_fail:
                 run_to_fail.status = RunStatus.FAILED
-                run_to_fail.end_dt = datetime.now(timezone.utc)
+                run_to_fail.end_dt = datetime.now(UTC)
                 run_to_fail.error_log["terminal_exception"] = str(exc)
                 await cleanup_session.commit()
 
@@ -1568,17 +1615,21 @@ class ScholarIngestionService:
             alert_network_failure_threshold=alert_network_failure_threshold,
             alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
         )
-        
+
         paging_kwargs = self._paging_kwargs(
             request_delay_seconds=self._effective_request_delay_seconds(request_delay_seconds),
             network_error_retries=network_error_retries,
             retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries if rate_limit_retries is not None else settings.ingestion_rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds if rate_limit_backoff_seconds is not None else settings.ingestion_rate_limit_backoff_seconds,
+            rate_limit_retries=rate_limit_retries
+            if rate_limit_retries is not None
+            else settings.ingestion_rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds
+            if rate_limit_backoff_seconds is not None
+            else settings.ingestion_rate_limit_backoff_seconds,
             max_pages_per_scholar=max_pages_per_scholar,
             page_size=page_size,
         )
-        
+
         threshold_kwargs = self._threshold_kwargs(
             alert_blocked_failure_threshold=alert_blocked_failure_threshold,
             alert_network_failure_threshold=alert_network_failure_threshold,
@@ -1628,7 +1679,9 @@ class ScholarIngestionService:
         await db_session.commit()
 
         structured_log(
-            logger, "info", "ingestion.run_completed",
+            logger,
+            "info",
+            "ingestion.run_completed",
             user_id=user_id,
             crawl_run_id=run.id,
             status=run.status.value,
@@ -1663,8 +1716,7 @@ class ScholarIngestionService:
                 return await self._source.fetch_profile_html(scholar_id)
             return FetchResult(
                 requested_url=(
-                    "https://scholar.google.com/citations"
-                    f"?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
+                    f"https://scholar.google.com/citations?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
                 ),
                 status_code=None,
                 final_url=None,
@@ -1682,8 +1734,7 @@ class ScholarIngestionService:
             )
             return FetchResult(
                 requested_url=(
-                    "https://scholar.google.com/citations"
-                    f"?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
+                    f"https://scholar.google.com/citations?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
                 ),
                 status_code=None,
                 final_url=None,
@@ -1702,7 +1753,10 @@ class ScholarIngestionService:
     ) -> bool:
         if parsed_page.state == ParseState.NETWORK_ERROR:
             return network_attempt_count <= network_error_retries
-        if parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA and parsed_page.state_reason == "blocked_http_429_rate_limited":
+        if (
+            parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA
+            and parsed_page.state_reason == "blocked_http_429_rate_limited"
+        ):
             return rate_limit_attempt_count <= rate_limit_retries
         return False
 
@@ -1725,7 +1779,9 @@ class ScholarIngestionService:
             attempt_label = network_attempt_count
 
         structured_log(
-            logger, "warning", "ingestion.scholar_retry_scheduled",
+            logger,
+            "warning",
+            "ingestion.scholar_retry_scheduled",
             scholar_id=scholar_id,
             cstart=cstart,
             attempt_count=attempt_label,
@@ -1759,24 +1815,29 @@ class ScholarIngestionService:
                 page_size=page_size,
             )
             parsed_page = self._parse_profile_page_or_layout_error(fetch_result=fetch_result)
-            
+
             if parsed_page.state == ParseState.NETWORK_ERROR:
                 network_attempts += 1
                 total_attempts = network_attempts
-            elif parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA and parsed_page.state_reason == "blocked_http_429_rate_limited":
+            elif (
+                parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA
+                and parsed_page.state_reason == "blocked_http_429_rate_limited"
+            ):
                 rate_limit_attempts += 1
                 total_attempts = rate_limit_attempts
             else:
                 total_attempts = network_attempts + rate_limit_attempts + 1
 
-            attempt_log.append({
-                "attempt": total_attempts,
-                "cstart": cstart,
-                "state": parsed_page.state.value,
-                "state_reason": parsed_page.state_reason,
-                "status_code": fetch_result.status_code,
-                "fetch_error": fetch_result.error,
-            })
+            attempt_log.append(
+                {
+                    "attempt": total_attempts,
+                    "cstart": cstart,
+                    "state": parsed_page.state.value,
+                    "state_reason": parsed_page.state_reason,
+                    "status_code": fetch_result.status_code,
+                    "fetch_error": fetch_result.error,
+                }
+            )
 
             if not self._should_retry_page_fetch(
                 parsed_page=parsed_page,
@@ -1995,18 +2056,20 @@ class ScholarIngestionService:
     ) -> None:
         state.pages_attempted += 1
         state.attempt_log.extend(page_attempt_log)
-        state.page_logs.append({
-            "page": state.pages_attempted,
-            "cstart": state.current_cstart,
-            "state": parsed_page.state.value,
-            "state_reason": parsed_page.state_reason,
-            "status_code": fetch_result.status_code,
-            "publication_count": len(parsed_page.publications),
-            "articles_range": parsed_page.articles_range,
-            "has_show_more_button": parsed_page.has_show_more_button,
-            "warning_codes": parsed_page.warnings,
-            "attempt_count": len(page_attempt_log),
-        })
+        state.page_logs.append(
+            {
+                "page": state.pages_attempted,
+                "cstart": state.current_cstart,
+                "state": parsed_page.state.value,
+                "state_reason": parsed_page.state_reason,
+                "status_code": fetch_result.status_code,
+                "publication_count": len(parsed_page.publications),
+                "articles_range": parsed_page.articles_range,
+                "has_show_more_button": parsed_page.has_show_more_button,
+                "warning_codes": parsed_page.warnings,
+                "attempt_count": len(page_attempt_log),
+            }
+        )
         state.fetch_result = fetch_result
         state.parsed_page = parsed_page
 
@@ -2052,18 +2115,20 @@ class ScholarIngestionService:
         )
         first_page_fingerprint_sha256 = build_initial_page_fingerprint(parsed_page)
         attempt_log = list(first_attempt_log)
-        page_logs = [{
-            "page": 1,
-            "cstart": start_cstart,
-            "state": parsed_page.state.value,
-            "state_reason": parsed_page.state_reason,
-            "status_code": fetch_result.status_code,
-            "publication_count": len(parsed_page.publications),
-            "articles_range": parsed_page.articles_range,
-            "has_show_more_button": parsed_page.has_show_more_button,
-            "warning_codes": parsed_page.warnings,
-            "attempt_count": len(first_attempt_log),
-        }]
+        page_logs = [
+            {
+                "page": 1,
+                "cstart": start_cstart,
+                "state": parsed_page.state.value,
+                "state_reason": parsed_page.state_reason,
+                "status_code": fetch_result.status_code,
+                "publication_count": len(parsed_page.publications),
+                "articles_range": parsed_page.articles_range,
+                "has_show_more_button": parsed_page.has_show_more_button,
+                "warning_codes": parsed_page.warnings,
+                "attempt_count": len(first_attempt_log),
+            }
+        ]
         return fetch_result, parsed_page, first_page_fingerprint_sha256, attempt_log, page_logs
 
     async def _paginate_loop(
@@ -2098,7 +2163,9 @@ class ScholarIngestionService:
             await db_session.refresh(run)
             if run.status == RunStatus.CANCELED:
                 structured_log(
-                    logger, "info", "ingestion.pagination_canceled",
+                    logger,
+                    "info",
+                    "ingestion.pagination_canceled",
                     run_id=run.id,
                 )
                 self._set_truncated_state(
@@ -2217,12 +2284,17 @@ class ScholarIngestionService:
         rate_limit_backoff_seconds: float,
         max_pages: int,
         page_size: int,
-        previous_initial_page_fingerprint_sha256: str | None = None
+        previous_initial_page_fingerprint_sha256: str | None = None,
     ) -> PagedParseResult:
         bounded_max_pages = max(1, int(max_pages))
         bounded_page_size = max(1, int(page_size))
-        fetch_result, parsed_page, first_page_fingerprint_sha256, attempt_log, page_logs = (
-            await self._fetch_initial_page_context(
+        (
+            fetch_result,
+            parsed_page,
+            first_page_fingerprint_sha256,
+            attempt_log,
+            page_logs,
+        ) = await self._fetch_initial_page_context(
             scholar_id=scholar.scholar_id,
             start_cstart=start_cstart,
             bounded_page_size=bounded_page_size,
@@ -2230,7 +2302,7 @@ class ScholarIngestionService:
             retry_backoff_seconds=retry_backoff_seconds,
             rate_limit_retries=rate_limit_retries,
             rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-        ))
+        )
         shortcut_result = self._short_circuit_initial_page(
             start_cstart=start_cstart,
             previous_initial_page_fingerprint_sha256=previous_initial_page_fingerprint_sha256,
@@ -2275,9 +2347,7 @@ class ScholarIngestionService:
         *,
         run_id: int,
     ) -> bool:
-        check_result = await db_session.execute(
-            select(CrawlRun.status).where(CrawlRun.id == run_id)
-        )
+        check_result = await db_session.execute(select(CrawlRun.status).where(CrawlRun.id == run_id))
         status = check_result.scalar_one_or_none()
         if status is None:
             raise RuntimeError(f"Missing crawl_run for run_id={run_id}.")
@@ -2302,12 +2372,10 @@ class ScholarIngestionService:
         )
         from app.services.domains.openalex.matching import find_best_match
 
-        run_result = await db_session.execute(
-            select(CrawlRun.user_id).where(CrawlRun.id == run_id)
-        )
+        run_result = await db_session.execute(select(CrawlRun.user_id).where(CrawlRun.id == run_id))
         user_id = run_result.scalar_one()
 
-        now = datetime.now(timezone.utc)
+        now = datetime.now(UTC)
         cooldown_threshold = now - timedelta(days=7)
 
         stmt = (
@@ -2355,21 +2423,28 @@ class ScholarIngestionService:
                 )
             except OpenAlexBudgetExhaustedError:
                 structured_log(
-                    logger, "warning", "ingestion.openalex_budget_exhausted",
+                    logger,
+                    "warning",
+                    "ingestion.openalex_budget_exhausted",
                     run_id=run_id,
                 )
                 break  # Stop all enrichment — budget won't reset until midnight UTC
             except OpenAlexRateLimitError:
                 structured_log(
-                    logger, "warning", "ingestion.openalex_rate_limited",
+                    logger,
+                    "warning",
+                    "ingestion.openalex_rate_limited",
                     run_id=run_id,
                 )
                 await asyncio.sleep(60)
                 continue
             except Exception as e:
                 structured_log(
-                    logger, "warning", "ingestion.openalex_enrichment_failed",
-                    error=str(e), run_id=run_id,
+                    logger,
+                    "warning",
+                    "ingestion.openalex_enrichment_failed",
+                    error=str(e),
+                    run_id=run_id,
                 )
                 continue
 
@@ -2406,7 +2481,9 @@ class ScholarIngestionService:
         merge_count = await sweep_identifier_duplicates(db_session)
         if merge_count:
             structured_log(
-                logger, "info", "ingestion.identifier_dedup_sweep",
+                logger,
+                "info",
+                "ingestion.identifier_dedup_sweep",
                 merged_count=merge_count,
                 run_id=run_id,
             )
@@ -2444,7 +2521,9 @@ class ScholarIngestionService:
             return True
         except ArxivRateLimitError:
             structured_log(
-                logger, "warning", "ingestion.arxiv_rate_limited",
+                logger,
+                "warning",
+                "ingestion.arxiv_rate_limited",
                 run_id=run_id,
                 publication_id=int(publication.id),
                 detail="arXiv temporarily disabled for remaining enrichment pass",
@@ -2498,17 +2577,18 @@ class ScholarIngestionService:
 
         from app.services.domains.openalex.client import OpenAlexClient
         from app.services.domains.openalex.matching import find_best_match
-        
+
         client = OpenAlexClient(api_key=settings.openalex_api_key, mailto=settings.crossref_api_mailto)
-        
+
         # Batch requests by 25 to stay within URL length limits
         batch_size = 25
         enriched: list[PublicationCandidate] = []
-        
+
         import re
+
         for i in range(0, len(publications), batch_size):
-            batch = publications[i:i + batch_size]
-            
+            batch = publications[i : i + batch_size]
+
             titles = []
             for p in batch:
                 if not p.title:
@@ -2519,29 +2599,27 @@ class ScholarIngestionService:
                 safe_title = " ".join(safe_title.split())
                 if safe_title:
                     titles.append(safe_title)
-            
+
             if not titles:
                 enriched.extend(batch)
                 continue
-            
+
             query = "|".join(t for t in titles)
             try:
-                openalex_works = await client.get_works_by_filter(
-                    {"title.search": query}, limit=batch_size * 3
-                )
+                openalex_works = await client.get_works_by_filter({"title.search": query}, limit=batch_size * 3)
             except Exception as e:
                 logger.warning(
                     "ingestion.openalex_enrichment_failed",
-                    extra={"error": str(e), "batch_size": len(batch), "scholar_id": scholar.id}
+                    extra={"error": str(e), "batch_size": len(batch), "scholar_id": scholar.id},
                 )
                 openalex_works = []
-                
+
             for p in batch:
                 match = find_best_match(
                     target_title=p.title,
                     target_year=p.year,
                     target_authors=p.authors_text or (scholar.display_name or scholar.scholar_id),
-                    candidates=openalex_works
+                    candidates=openalex_works,
                 )
                 if match:
                     new_p = PublicationCandidate(
@@ -2627,7 +2705,7 @@ class ScholarIngestionService:
                 "pub_url": publication.pub_url,
                 "scholar_profile_id": scholar.id,
                 "scholar_label": scholar.display_name or scholar.scholar_id,
-                "first_seen_at": datetime.now(timezone.utc).isoformat(),
+                "first_seen_at": datetime.now(UTC).isoformat(),
                 "new_publication_count": int(run.new_pub_count or 0),
             },
         )
@@ -2647,9 +2725,7 @@ class ScholarIngestionService:
     ) -> Publication | None:
         if not cluster_id:
             return None
-        result = await db_session.execute(
-            select(Publication).where(Publication.cluster_id == cluster_id)
-        )
+        result = await db_session.execute(select(Publication).where(Publication.cluster_id == cluster_id))
         return result.scalar_one_or_none()
 
     async def _find_publication_by_fingerprint(
@@ -2658,9 +2734,7 @@ class ScholarIngestionService:
         *,
         fingerprint: str,
     ) -> Publication | None:
-        result = await db_session.execute(
-            select(Publication).where(Publication.fingerprint_sha256 == fingerprint)
-        )
+        result = await db_session.execute(select(Publication).where(Publication.fingerprint_sha256 == fingerprint))
         return result.scalar_one_or_none()
 
     @staticmethod
@@ -2685,9 +2759,7 @@ class ScholarIngestionService:
         canonical_title_hash: str,
     ) -> Publication | None:
         result = await db_session.execute(
-            select(Publication).where(
-                Publication.canonical_title_hash == canonical_title_hash
-            )
+            select(Publication).where(Publication.canonical_title_hash == canonical_title_hash)
         )
         return result.scalar_one_or_none()
 
@@ -2816,9 +2888,7 @@ class ScholarIngestionService:
     ) -> tuple[str | None, int]:
         if outcome == "partial":
             reason = (pagination_truncated_reason or "").strip()
-            if reason in RESUMABLE_PARTIAL_REASONS or reason.startswith(
-                RESUMABLE_PARTIAL_REASON_PREFIXES
-            ):
+            if reason in RESUMABLE_PARTIAL_REASONS or reason.startswith(RESUMABLE_PARTIAL_REASON_PREFIXES):
                 return reason, queue_service.normalize_cstart(
                     continuation_cstart if continuation_cstart is not None else fallback_cstart
                 )
@@ -2852,13 +2922,9 @@ class ScholarIngestionService:
             "has_show_more_button": parsed_page.has_show_more_button,
             "has_operation_error_banner": parsed_page.has_operation_error_banner,
             "warning_codes": parsed_page.warnings,
-            "marker_counts_nonzero": {
-                key: value for key, value in parsed_page.marker_counts.items() if value > 0
-            },
+            "marker_counts_nonzero": {key: value for key, value in parsed_page.marker_counts.items() if value > 0},
             "body_length": len(fetch_result.body),
-            "body_sha256": hashlib.sha256(fetch_result.body.encode("utf-8")).hexdigest()
-            if fetch_result.body
-            else None,
+            "body_sha256": hashlib.sha256(fetch_result.body.encode("utf-8")).hexdigest() if fetch_result.body else None,
             "body_excerpt": _build_body_excerpt(fetch_result.body),
             "attempt_log": attempt_log,
         }
@@ -2876,9 +2942,7 @@ class ScholarIngestionService:
         user_id: int,
     ) -> bool:
         result = await db_session.execute(
-            text(
-                "SELECT pg_try_advisory_xact_lock(:namespace, :user_key)"
-            ),
+            text("SELECT pg_try_advisory_xact_lock(:namespace, :user_key)"),
             {
                 "namespace": RUN_LOCK_NAMESPACE,
                 "user_key": int(user_id),
diff --git a/app/services/domains/ingestion/fingerprints.py b/app/services/domains/ingestion/fingerprints.py
index 9f67f0f..7c3156d 100644
--- a/app/services/domains/ingestion/fingerprints.py
+++ b/app/services/domains/ingestion/fingerprints.py
@@ -3,8 +3,8 @@ from __future__ import annotations
 import hashlib
 import json
 import re
-from typing import Any
 import unicodedata
+from typing import Any
 from urllib.parse import urljoin
 
 from app.services.domains.ingestion.constants import (
@@ -14,7 +14,7 @@ from app.services.domains.ingestion.constants import (
     TITLE_ALNUM_RE,
     WORD_RE,
 )
-from app.services.domains.scholar.parser import ParseState, ParsedProfilePage, PublicationCandidate
+from app.services.domains.scholar.parser import ParsedProfilePage, ParseState, PublicationCandidate
 
 # Scholar-specific noise patterns stripped before canonical comparison.
 # Applied in order; each targets a different Scholar metadata injection style.
@@ -381,4 +381,4 @@ def _build_body_excerpt(body: str, *, max_chars: int = 220) -> str | None:
         return None
     if len(flattened) <= max_chars:
         return flattened
-    return f"{flattened[:max_chars - 1]}..."
+    return f"{flattened[: max_chars - 1]}..."
diff --git a/app/services/domains/ingestion/queue.py b/app/services/domains/ingestion/queue.py
index 7494420..2016f63 100644
--- a/app/services/domains/ingestion/queue.py
+++ b/app/services/domains/ingestion/queue.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -115,7 +115,7 @@ async def upsert_job(
     run_id: int | None,
     delay_seconds: int,
 ) -> IngestionQueueItem:
-    now = datetime.now(timezone.utc)
+    now = datetime.now(UTC)
     next_attempt_dt = now + timedelta(seconds=max(0, int(delay_seconds)))
     item = await _get_item_for_user_scholar(
         db_session,
@@ -171,9 +171,7 @@ async def delete_job_by_id(
     *,
     job_id: int,
 ) -> bool:
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
+    result = await db_session.execute(select(IngestionQueueItem).where(IngestionQueueItem.id == job_id))
     item = result.scalar_one_or_none()
     if item is None:
         return False
@@ -222,10 +220,8 @@ async def increment_attempt_count(
     *,
     job_id: int,
 ) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
+    now = datetime.now(UTC)
+    result = await db_session.execute(select(IngestionQueueItem).where(IngestionQueueItem.id == job_id))
     item = result.scalar_one_or_none()
     if item is None:
         return None
@@ -239,10 +235,8 @@ async def reset_attempt_count(
     *,
     job_id: int,
 ) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
+    now = datetime.now(UTC)
+    result = await db_session.execute(select(IngestionQueueItem).where(IngestionQueueItem.id == job_id))
     item = result.scalar_one_or_none()
     if item is None:
         return None
@@ -259,10 +253,8 @@ async def reschedule_job(
     reason: str,
     error: str | None = None,
 ) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
+    now = datetime.now(UTC)
+    result = await db_session.execute(select(IngestionQueueItem).where(IngestionQueueItem.id == job_id))
     item = result.scalar_one_or_none()
     if item is None:
         return None
@@ -282,10 +274,8 @@ async def mark_retrying(
     job_id: int,
     reason: str | None = None,
 ) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
+    now = datetime.now(UTC)
+    result = await db_session.execute(select(IngestionQueueItem).where(IngestionQueueItem.id == job_id))
     item = result.scalar_one_or_none()
     if item is None:
         return None
@@ -305,10 +295,8 @@ async def mark_dropped(
     reason: str,
     error: str | None = None,
 ) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
+    now = datetime.now(UTC)
+    result = await db_session.execute(select(IngestionQueueItem).where(IngestionQueueItem.id == job_id))
     item = result.scalar_one_or_none()
     if item is None:
         return None
@@ -329,10 +317,8 @@ async def mark_queued_now(
     reason: str,
     reset_attempt_count: bool = False,
 ) -> IngestionQueueItem | None:
-    now = datetime.now(timezone.utc)
-    result = await db_session.execute(
-        select(IngestionQueueItem).where(IngestionQueueItem.id == job_id)
-    )
+    now = datetime.now(UTC)
+    result = await db_session.execute(select(IngestionQueueItem).where(IngestionQueueItem.id == job_id))
     item = result.scalar_one_or_none()
     if item is None:
         return None
diff --git a/app/services/domains/ingestion/safety.py b/app/services/domains/ingestion/safety.py
index debb8c5..a8385a9 100644
--- a/app/services/domains/ingestion/safety.py
+++ b/app/services/domains/ingestion/safety.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from typing import Any
 
 from app.db.models import UserSetting
@@ -18,7 +18,7 @@ _COUNTER_LAST_EVALUATED_RUN_ID = "last_evaluated_run_id"
 
 
 def _utcnow() -> datetime:
-    return datetime.now(timezone.utc)
+    return datetime.now(UTC)
 
 
 def _safe_int(value: Any, default: int = 0) -> int:
@@ -41,8 +41,8 @@ def _normalize_datetime(value: datetime | None) -> datetime | None:
     if value is None:
         return None
     if value.tzinfo is None:
-        return value.replace(tzinfo=timezone.utc)
-    return value.astimezone(timezone.utc)
+        return value.replace(tzinfo=UTC)
+    return value.astimezone(UTC)
 
 
 def _state_dict(settings: UserSetting) -> dict[str, Any]:
@@ -100,9 +100,7 @@ def _recommended_action(reason: str | None) -> str | None:
             "increase request delay, and avoid repeated manual retries."
         )
     if reason == COOLDOWN_REASON_NETWORK_FAILURE_THRESHOLD:
-        return (
-            "Network failures crossed the threshold. Verify connectivity and retry after cooldown."
-        )
+        return "Network failures crossed the threshold. Verify connectivity and retry after cooldown."
     return None
 
 
@@ -159,14 +157,10 @@ def _update_run_counters(
     counters[_COUNTER_LAST_NETWORK_FAILURE_COUNT] = bounded_network_failures
     counters[_COUNTER_LAST_EVALUATED_RUN_ID] = int(run_id)
     counters[_COUNTER_CONSECUTIVE_BLOCKED_RUNS] = (
-        int(counters[_COUNTER_CONSECUTIVE_BLOCKED_RUNS]) + 1
-        if bounded_blocked_failures > 0
-        else 0
+        int(counters[_COUNTER_CONSECUTIVE_BLOCKED_RUNS]) + 1 if bounded_blocked_failures > 0 else 0
     )
     counters[_COUNTER_CONSECUTIVE_NETWORK_RUNS] = (
-        int(counters[_COUNTER_CONSECUTIVE_NETWORK_RUNS]) + 1
-        if bounded_network_failures > 0
-        else 0
+        int(counters[_COUNTER_CONSECUTIVE_NETWORK_RUNS]) + 1 if bounded_network_failures > 0 else 0
     )
     return bounded_blocked_failures, bounded_network_failures
 
diff --git a/app/services/domains/ingestion/scheduler.py b/app/services/domains/ingestion/scheduler.py
index 1f2267a..4aa8bc0 100644
--- a/app/services/domains/ingestion/scheduler.py
+++ b/app/services/domains/ingestion/scheduler.py
@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import asyncio
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
 import logging
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
 
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -17,24 +17,22 @@ from app.db.models import (
     UserSetting,
 )
 from app.db.session import get_session_factory
+from app.logging_utils import structured_log
 from app.services.domains.ingestion import queue as queue_service
 from app.services.domains.ingestion.application import (
     RunAlreadyInProgressError,
     RunBlockedBySafetyPolicyError,
     ScholarIngestionService,
 )
-from app.logging_utils import structured_log
-from app.services.domains.settings import application as user_settings_service
 from app.services.domains.scholar.source import LiveScholarSource
+from app.services.domains.settings import application as user_settings_service
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
 
 
 def _request_delay_floor_seconds() -> int:
-    return user_settings_service.resolve_request_delay_minimum(
-        settings.ingestion_min_request_delay_seconds
-    )
+    return user_settings_service.resolve_request_delay_minimum(settings.ingestion_min_request_delay_seconds)
 
 
 def _effective_request_delay_seconds(value: int | None) -> int:
@@ -96,7 +94,9 @@ class SchedulerService:
             return
         self._task = asyncio.create_task(self._run_loop(), name="scholarr-scheduler")
         structured_log(
-            logger, "info", "scheduler.started",
+            logger,
+            "info",
+            "scheduler.started",
             tick_seconds=self._tick_seconds,
             network_error_retries=self._network_error_retries,
             retry_backoff_seconds=self._retry_backoff_seconds,
@@ -137,13 +137,13 @@ class SchedulerService:
     async def _tick_once(self) -> None:
         if self._continuation_queue_enabled:
             await self._drain_continuation_queue()
-        
+
         await self._drain_pdf_queue()
 
         candidates = await self._load_candidates()
         if not candidates:
             return
-        now = datetime.now(timezone.utc)
+        now = datetime.now(UTC)
         for candidate in candidates:
             if not await self._is_due(candidate, now=now):
                 continue
@@ -170,10 +170,12 @@ class SchedulerService:
     def _candidate_from_row(row: tuple, *, now_utc: datetime) -> _AutoRunCandidate | None:
         user_id, run_interval_minutes, request_delay_seconds, cooldown_until, cooldown_reason = row
         if cooldown_until is not None and cooldown_until.tzinfo is None:
-            cooldown_until = cooldown_until.replace(tzinfo=timezone.utc)
+            cooldown_until = cooldown_until.replace(tzinfo=UTC)
         if cooldown_until is not None and cooldown_until > now_utc:
             structured_log(
-                logger, "info", "scheduler.run_skipped_safety_cooldown_precheck",
+                logger,
+                "info",
+                "scheduler.run_skipped_safety_cooldown_precheck",
                 user_id=int(user_id),
                 reason=cooldown_reason,
                 cooldown_until=cooldown_until,
@@ -192,7 +194,7 @@ class SchedulerService:
         if not settings.ingestion_automation_allowed:
             return []
         rows = await self._load_candidate_rows()
-        now_utc = datetime.now(timezone.utc)
+        now_utc = datetime.now(UTC)
         candidates: list[_AutoRunCandidate] = []
         for row in rows:
             candidate = self._candidate_from_row(row, now_utc=now_utc)
@@ -216,9 +218,7 @@ class SchedulerService:
         if last_run is None:
             return True
 
-        next_due_dt = last_run + timedelta(
-            minutes=candidate.run_interval_minutes
-        )
+        next_due_dt = last_run + timedelta(minutes=candidate.run_interval_minutes)
         return now >= next_due_dt
 
     async def _run_candidate_ingestion(
@@ -252,7 +252,9 @@ class SchedulerService:
             except RunBlockedBySafetyPolicyError as exc:
                 await session.rollback()
                 structured_log(
-                    logger, "info", "scheduler.run_skipped_safety_cooldown",
+                    logger,
+                    "info",
+                    "scheduler.run_skipped_safety_cooldown",
                     user_id=candidate.user_id,
                     reason=exc.safety_state.get("cooldown_reason"),
                     cooldown_until=exc.safety_state.get("cooldown_until"),
@@ -269,7 +271,9 @@ class SchedulerService:
         if run_summary is None:
             return
         structured_log(
-            logger, "info", "scheduler.run_completed",
+            logger,
+            "info",
+            "scheduler.run_completed",
             user_id=candidate.user_id,
             run_id=run_summary.crawl_run_id,
             status=run_summary.status.value,
@@ -278,7 +282,7 @@ class SchedulerService:
         )
 
     async def _drain_continuation_queue(self) -> None:
-        now = datetime.now(timezone.utc)
+        now = datetime.now(UTC)
         session_factory = get_session_factory()
         async with session_factory() as session:
             jobs = await queue_service.list_due_jobs(
@@ -305,7 +309,9 @@ class SchedulerService:
             await session.commit()
         if dropped is not None:
             structured_log(
-                logger, "warning", "scheduler.queue_item_dropped_max_attempts",
+                logger,
+                "warning",
+                "scheduler.queue_item_dropped_max_attempts",
                 queue_item_id=job.id,
                 user_id=job.user_id,
                 scholar_profile_id=job.scholar_profile_id,
@@ -352,7 +358,9 @@ class SchedulerService:
             await session.commit()
         if dropped is not None:
             structured_log(
-                logger, "info", "scheduler.queue_item_dropped_scholar_unavailable",
+                logger,
+                "info",
+                "scheduler.queue_item_dropped_scholar_unavailable",
                 queue_item_id=job.id,
                 user_id=job.user_id,
                 scholar_profile_id=job.scholar_profile_id,
@@ -371,8 +379,11 @@ class SchedulerService:
             )
             await recovery_session.commit()
         structured_log(
-            logger, "info", "scheduler.queue_item_deferred_lock",
-            queue_item_id=job.id, user_id=job.user_id,
+            logger,
+            "info",
+            "scheduler.queue_item_deferred_lock",
+            queue_item_id=job.id,
+            user_id=job.user_id,
         )
 
     async def _reschedule_queue_job_safety_cooldown(
@@ -395,7 +406,9 @@ class SchedulerService:
             )
             await recovery_session.commit()
         structured_log(
-            logger, "info", "scheduler.queue_item_deferred_safety_cooldown",
+            logger,
+            "info",
+            "scheduler.queue_item_deferred_safety_cooldown",
             queue_item_id=job.id,
             user_id=job.user_id,
             reason=exc.safety_state.get("cooldown_reason"),
@@ -423,8 +436,12 @@ class SchedulerService:
                 )
                 await recovery_session.commit()
                 structured_log(
-                    logger, "warning", "scheduler.queue_item_dropped_after_exception",
-                    queue_item_id=job.id, user_id=job.user_id, attempt_count=queue_item.attempt_count,
+                    logger,
+                    "warning",
+                    "scheduler.queue_item_dropped_after_exception",
+                    queue_item_id=job.id,
+                    user_id=job.user_id,
+                    attempt_count=queue_item.attempt_count,
                 )
                 return
             delay_seconds = queue_service.compute_backoff_seconds(
@@ -489,15 +506,23 @@ class SchedulerService:
                 await session.commit()
                 if queue_item is None:
                     structured_log(
-                        logger, "info", "scheduler.queue_item_resolved",
-                        queue_item_id=job.id, user_id=job.user_id,
-                        run_id=run_summary.crawl_run_id, status=run_summary.status.value,
+                        logger,
+                        "info",
+                        "scheduler.queue_item_resolved",
+                        queue_item_id=job.id,
+                        user_id=job.user_id,
+                        run_id=run_summary.crawl_run_id,
+                        status=run_summary.status.value,
                     )
                     return
                 structured_log(
-                    logger, "info", "scheduler.queue_item_progressed",
-                    queue_item_id=job.id, user_id=job.user_id,
-                    run_id=run_summary.crawl_run_id, status=run_summary.status.value,
+                    logger,
+                    "info",
+                    "scheduler.queue_item_progressed",
+                    queue_item_id=job.id,
+                    user_id=job.user_id,
+                    run_id=run_summary.crawl_run_id,
+                    status=run_summary.status.value,
                     attempt_count=int(queue_item.attempt_count),
                 )
                 return
@@ -505,28 +530,50 @@ class SchedulerService:
             if queue_item is None:
                 await session.commit()
                 structured_log(
-                    logger, "info", "scheduler.queue_item_resolved",
-                    queue_item_id=job.id, user_id=job.user_id,
-                    run_id=run_summary.crawl_run_id, status=run_summary.status.value,
+                    logger,
+                    "info",
+                    "scheduler.queue_item_resolved",
+                    queue_item_id=job.id,
+                    user_id=job.user_id,
+                    run_id=run_summary.crawl_run_id,
+                    status=run_summary.status.value,
                 )
                 return
             if int(queue_item.attempt_count) >= self._continuation_max_attempts:
                 await queue_service.mark_dropped(session, job_id=job.id, reason="max_attempts_after_run")
                 await session.commit()
                 structured_log(
-                    logger, "warning", "scheduler.queue_item_dropped_max_attempts_after_run",
-                    queue_item_id=job.id, user_id=job.user_id,
+                    logger,
+                    "warning",
+                    "scheduler.queue_item_dropped_max_attempts_after_run",
+                    queue_item_id=job.id,
+                    user_id=job.user_id,
                     attempt_count=queue_item.attempt_count,
-                    run_id=run_summary.crawl_run_id, status=run_summary.status.value,
+                    run_id=run_summary.crawl_run_id,
+                    status=run_summary.status.value,
                 )
                 return
-            delay_seconds = queue_service.compute_backoff_seconds(base_seconds=self._continuation_base_delay_seconds, attempt_count=int(queue_item.attempt_count), max_seconds=self._continuation_max_delay_seconds)
-            await queue_service.reschedule_job(session, job_id=job.id, delay_seconds=delay_seconds, reason=queue_item.reason, error=queue_item.last_error)
+            delay_seconds = queue_service.compute_backoff_seconds(
+                base_seconds=self._continuation_base_delay_seconds,
+                attempt_count=int(queue_item.attempt_count),
+                max_seconds=self._continuation_max_delay_seconds,
+            )
+            await queue_service.reschedule_job(
+                session,
+                job_id=job.id,
+                delay_seconds=delay_seconds,
+                reason=queue_item.reason,
+                error=queue_item.last_error,
+            )
             await session.commit()
         structured_log(
-            logger, "info", "scheduler.queue_item_rescheduled_failed",
-            queue_item_id=job.id, user_id=job.user_id,
-            run_id=run_summary.crawl_run_id, status=run_summary.status.value,
+            logger,
+            "info",
+            "scheduler.queue_item_rescheduled_failed",
+            queue_item_id=job.id,
+            user_id=job.user_id,
+            run_id=run_summary.crawl_run_id,
+            status=run_summary.status.value,
             attempt_count=int(queue_item.attempt_count),
             delay_seconds=delay_seconds,
         )
@@ -545,7 +592,7 @@ class SchedulerService:
 
     async def _drain_pdf_queue(self) -> None:
         from app.services.domains.publications.pdf_queue import drain_ready_jobs
-        
+
         session_factory = get_session_factory()
         async with session_factory() as session:
             try:
@@ -556,7 +603,9 @@ class SchedulerService:
                 )
                 if processed > 0:
                     structured_log(
-                        logger, "info", "scheduler.pdf_queue_drain_completed",
+                        logger,
+                        "info",
+                        "scheduler.pdf_queue_drain_completed",
                         processed_count=processed,
                     )
             except Exception:
diff --git a/app/services/domains/openalex/client.py b/app/services/domains/openalex/client.py
index f6db5fd..83edc20 100644
--- a/app/services/domains/openalex/client.py
+++ b/app/services/domains/openalex/client.py
@@ -1,6 +1,4 @@
-import asyncio
 import logging
-from typing import Any, Mapping
 
 import httpx
 from tenacity import (
@@ -23,11 +21,13 @@ class OpenAlexClientError(Exception):
 
 class OpenAlexRateLimitError(OpenAlexClientError):
     """Transient rate limit (too many requests per second)."""
+
     pass
 
 
 class OpenAlexBudgetExhaustedError(OpenAlexClientError):
     """Daily API budget exhausted — retrying is futile until midnight UTC."""
+
     pass
 
 
@@ -64,7 +64,7 @@ class OpenAlexClient:
             return None
 
         url = f"{OPENALEX_BASE_URL}/works/{clean_doi}"
-        
+
         headers = {}
         if self.mailto:
             headers["User-Agent"] = f"scholar-scraper/1.0 (mailto:{self.mailto})"
@@ -79,9 +79,7 @@ class OpenAlexClient:
         if response.status_code == 429:
             remaining = response.headers.get("X-RateLimit-Remaining-USD", "")
             if remaining == "0" or remaining.startswith("-"):
-                raise OpenAlexBudgetExhaustedError(
-                    "Daily API budget exhausted; retrying won't help until midnight UTC"
-                )
+                raise OpenAlexBudgetExhaustedError("Daily API budget exhausted; retrying won't help until midnight UTC")
             raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex work by DOI")
         if response.status_code >= 400:
             logger.warning("OpenAlex API error: %s %s", response.status_code, response.text[:500])
@@ -110,13 +108,13 @@ class OpenAlexClient:
 
         # Example: {"doi": "10.foo|10.bar", "title.search": "query"}
         filter_str = ",".join(f"{k}:{v}" for k, v in filters.items())
-        
+
         params = self._base_params.copy()
         params["filter"] = filter_str
         params["per-page"] = str(limit)
 
         url = f"{OPENALEX_BASE_URL}/works"
-        
+
         headers = {}
         if self.mailto:
             headers["User-Agent"] = f"scholar-scraper/1.0 (mailto:{self.mailto})"
@@ -129,9 +127,7 @@ class OpenAlexClient:
         if response.status_code == 429:
             remaining = response.headers.get("X-RateLimit-Remaining-USD", "")
             if remaining == "0" or remaining.startswith("-"):
-                raise OpenAlexBudgetExhaustedError(
-                    "Daily API budget exhausted; retrying won't help until midnight UTC"
-                )
+                raise OpenAlexBudgetExhaustedError("Daily API budget exhausted; retrying won't help until midnight UTC")
             raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex works list")
         if response.status_code >= 400:
             logger.warning("OpenAlex API error (filters=%s): %s %s", filters, response.status_code, response.text[:500])
@@ -139,7 +135,7 @@ class OpenAlexClient:
 
         data = response.json()
         results = data.get("results") or []
-        
+
         parsed_works = []
         for raw_work in results:
             try:
diff --git a/app/services/domains/openalex/matching.py b/app/services/domains/openalex/matching.py
index cfa511c..40c25ba 100644
--- a/app/services/domains/openalex/matching.py
+++ b/app/services/domains/openalex/matching.py
@@ -24,11 +24,11 @@ def _clean_string(s: str | None) -> str:
 def _author_overlap_score(target_authors: str | None, candidate_authors: list[str]) -> bool:
     if not target_authors or not candidate_authors:
         return False
-    
+
     target_clean = _clean_string(target_authors)
     if not target_clean:
         return False
-        
+
     for candidate in candidate_authors:
         cand_clean = _clean_string(candidate)
         if cand_clean and (cand_clean in target_clean or target_clean in cand_clean):
@@ -36,7 +36,7 @@ def _author_overlap_score(target_authors: str | None, candidate_authors: list[st
         # Alternatively check rapidfuzz token_set_ratio
         if cand_clean and fuzz.token_set_ratio(target_clean, cand_clean) > 80:
             return True
-            
+
     return False
 
 
@@ -62,12 +62,12 @@ def find_best_match(
     for cand in candidates:
         if not cand.title:
             continue
-            
+
         clean_cand = _clean_string(cand.title)
-        
+
         # Primary sort: string similarity ratio
         score = fuzz.ratio(clean_target, clean_cand)
-        
+
         if score >= TITLE_MATCH_THRESHOLD:
             scored_candidates.append((score, cand))
 
@@ -76,13 +76,12 @@ def find_best_match(
 
     # Sort descending by score
     scored_candidates.sort(key=lambda x: x[0], reverse=True)
-    
+
     best_score = scored_candidates[0][0]
-    
+
     # Extract all candidates within the tiebreaker margin
     top_scored_candidates = [
-        (score, cand) for score, cand in scored_candidates 
-        if best_score - score <= TIEBREAKER_MARGIN
+        (score, cand) for score, cand in scored_candidates if best_score - score <= TIEBREAKER_MARGIN
     ]
 
     if len(top_scored_candidates) == 1:
@@ -91,18 +90,18 @@ def find_best_match(
     # We have a tie or near-tie. Use year and author overlap to break the tie.
     # Score candidates: +1 for year match (within 1 year), +1 for author overlap
     tiebreaker_scores: list[tuple[int, float, OpenAlexWork]] = []
-    
+
     for original_score, cand in top_scored_candidates:
         tb_score = 0
         if target_year is not None and cand.publication_year is not None:
             if abs(target_year - cand.publication_year) <= 1:
                 tb_score += 1
-                
+
         candidate_author_names = [a.display_name for a in cand.authors if a.display_name]
         if _author_overlap_score(target_authors, candidate_author_names):
             tb_score += 1
-            
+
         tiebreaker_scores.append((tb_score, original_score, cand))
-        
+
     tiebreaker_scores.sort(key=lambda x: (x[0], x[1]), reverse=True)
     return tiebreaker_scores[0][2]
diff --git a/app/services/domains/openalex/types.py b/app/services/domains/openalex/types.py
index 0d86754..8abf375 100644
--- a/app/services/domains/openalex/types.py
+++ b/app/services/domains/openalex/types.py
@@ -1,8 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
 from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Any, Mapping
+from typing import Any
 
 
 @dataclass(frozen=True)
@@ -28,24 +28,24 @@ class OpenAlexWork:
     @classmethod
     def from_api_dict(cls, data: Mapping[str, Any]) -> OpenAlexWork:
         ids = data.get("ids") or {}
-        
+
         # Extract DOI without the https://doi.org/ prefix
         doi = ids.get("doi")
         if doi and doi.startswith("https://doi.org/"):
             doi = doi[16:]
-            
+
         # Extract PMID without the url prefix
         pmid = ids.get("pmid")
         if pmid and pmid.startswith("https://pubmed.ncbi.nlm.nih.gov/"):
             pmid = pmid[32:]
-            
+
         # Extract PMCID without the url prefix
         pmcid = ids.get("pmcid")
         if pmcid and pmcid.startswith("https://www.ncbi.nlm.nih.gov/pmc/articles/"):
             pmcid = pmcid[42:]
 
         open_access = data.get("open_access") or {}
-        
+
         authors = []
         for authorship in data.get("authorships") or []:
             author_data = authorship.get("author") or {}
diff --git a/app/services/domains/portability/application.py b/app/services/domains/portability/application.py
index 7e0b56e..6285c5d 100644
--- a/app/services/domains/portability/application.py
+++ b/app/services/domains/portability/application.py
@@ -18,7 +18,7 @@ from app.services.domains.portability.publication_import import (
     _upsert_imported_publication,
 )
 from app.services.domains.portability.scholar_import import _upsert_imported_scholars
-from app.services.domains.portability.types import ImportExportError, ImportedPublicationInput
+from app.services.domains.portability.types import ImportedPublicationInput, ImportExportError
 
 
 async def import_user_data(
@@ -58,8 +58,8 @@ async def import_user_data(
 
 __all__ = [
     "EXPORT_SCHEMA_VERSION",
-    "MAX_IMPORT_SCHOLARS",
     "MAX_IMPORT_PUBLICATIONS",
+    "MAX_IMPORT_SCHOLARS",
     "ImportExportError",
     "ImportedPublicationInput",
     "export_user_data",
diff --git a/app/services/domains/portability/exporting.py b/app/services/domains/portability/exporting.py
index 5c89006..2f50247 100644
--- a/app/services/domains/portability/exporting.py
+++ b/app/services/domains/portability/exporting.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from typing import Any
 
 from sqlalchemy import select
@@ -11,7 +11,7 @@ from app.services.domains.portability.constants import EXPORT_SCHEMA_VERSION
 
 
 def _exported_at_iso() -> str:
-    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+    return datetime.now(UTC).replace(microsecond=0).isoformat()
 
 
 def _serialize_export_scholar(profile: ScholarProfile) -> dict[str, Any]:
@@ -58,9 +58,7 @@ async def export_user_data(
     user_id: int,
 ) -> dict[str, Any]:
     scholars_result = await db_session.execute(
-        select(ScholarProfile)
-        .where(ScholarProfile.user_id == user_id)
-        .order_by(ScholarProfile.id.asc())
+        select(ScholarProfile).where(ScholarProfile.user_id == user_id).order_by(ScholarProfile.id.asc())
     )
     publication_result = await db_session.execute(
         select(
diff --git a/app/services/domains/portability/normalize.py b/app/services/domains/portability/normalize.py
index 60dd619..176bfc5 100644
--- a/app/services/domains/portability/normalize.py
+++ b/app/services/domains/portability/normalize.py
@@ -104,6 +104,4 @@ def _validate_import_sizes(
     if len(scholars) > MAX_IMPORT_SCHOLARS:
         raise ImportExportError(f"Import exceeds max scholars ({MAX_IMPORT_SCHOLARS}).")
     if len(publications) > MAX_IMPORT_PUBLICATIONS:
-        raise ImportExportError(
-            f"Import exceeds max publications ({MAX_IMPORT_PUBLICATIONS})."
-        )
+        raise ImportExportError(f"Import exceeds max publications ({MAX_IMPORT_PUBLICATIONS}).")
diff --git a/app/services/domains/portability/publication_import.py b/app/services/domains/portability/publication_import.py
index 7654586..afcb580 100644
--- a/app/services/domains/portability/publication_import.py
+++ b/app/services/domains/portability/publication_import.py
@@ -6,8 +6,8 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import Publication, ScholarProfile, ScholarPublication
-from app.services.domains.ingestion.application import build_publication_url, normalize_title
 from app.services.domains.doi.normalize import normalize_doi
+from app.services.domains.ingestion.application import build_publication_url, normalize_title
 from app.services.domains.portability.normalize import (
     _normalize_citation_count,
     _normalize_optional_text,
@@ -22,9 +22,7 @@ async def _find_publication_by_cluster(
     *,
     cluster_id: str,
 ) -> Publication | None:
-    result = await db_session.execute(
-        select(Publication).where(Publication.cluster_id == cluster_id)
-    )
+    result = await db_session.execute(select(Publication).where(Publication.cluster_id == cluster_id))
     return result.scalar_one_or_none()
 
 
@@ -33,9 +31,7 @@ async def _find_publication_by_fingerprint(
     *,
     fingerprint_sha256: str,
 ) -> Publication | None:
-    result = await db_session.execute(
-        select(Publication).where(Publication.fingerprint_sha256 == fingerprint_sha256)
-    )
+    result = await db_session.execute(select(Publication).where(Publication.fingerprint_sha256 == fingerprint_sha256))
     return result.scalar_one_or_none()
 
 
diff --git a/app/services/domains/portability/scholar_import.py b/app/services/domains/portability/scholar_import.py
index 74e6ec1..c0a4c48 100644
--- a/app/services/domains/portability/scholar_import.py
+++ b/app/services/domains/portability/scholar_import.py
@@ -15,9 +15,7 @@ async def _load_user_scholar_map(
     *,
     user_id: int,
 ) -> dict[str, ScholarProfile]:
-    result = await db_session.execute(
-        select(ScholarProfile).where(ScholarProfile.user_id == user_id)
-    )
+    result = await db_session.execute(select(ScholarProfile).where(ScholarProfile.user_id == user_id))
     profiles = list(result.scalars().all())
     return {profile.scholar_id: profile for profile in profiles}
 
@@ -70,9 +68,7 @@ async def _upsert_imported_scholars(
     for item in scholars:
         try:
             scholar_id = scholar_service.validate_scholar_id(str(item["scholar_id"]))
-            display_name = scholar_service.normalize_display_name(
-                str(item.get("display_name") or "")
-            )
+            display_name = scholar_service.normalize_display_name(str(item.get("display_name") or ""))
             override_url = scholar_service.normalize_profile_image_url(
                 _normalize_optional_text(item.get("profile_image_override_url"))
             )
diff --git a/app/services/domains/publication_identifiers/__init__.py b/app/services/domains/publication_identifiers/__init__.py
index 9331dc0..d6a4263 100644
--- a/app/services/domains/publication_identifiers/__init__.py
+++ b/app/services/domains/publication_identifiers/__init__.py
@@ -1,7 +1,7 @@
 from app.services.domains.publication_identifiers.application import (
     DisplayIdentifier,
-    display_identifier_for_publication_id,
     derive_display_identifier_from_values,
+    display_identifier_for_publication_id,
     overlay_pdf_queue_items_with_display_identifiers,
     overlay_publication_items_with_display_identifiers,
     sync_identifiers_for_publication_fields,
@@ -10,8 +10,8 @@ from app.services.domains.publication_identifiers.application import (
 
 __all__ = [
     "DisplayIdentifier",
-    "display_identifier_for_publication_id",
     "derive_display_identifier_from_values",
+    "display_identifier_for_publication_id",
     "overlay_pdf_queue_items_with_display_identifiers",
     "overlay_publication_items_with_display_identifiers",
     "sync_identifiers_for_publication_fields",
diff --git a/app/services/domains/publication_identifiers/application.py b/app/services/domains/publication_identifiers/application.py
index 31f506c..47fe940 100644
--- a/app/services/domains/publication_identifiers/application.py
+++ b/app/services/domains/publication_identifiers/application.py
@@ -55,7 +55,9 @@ def _fallback_candidates_from_values(
     if doi:
         normalized_doi = normalize_doi(doi)
         if normalized_doi:
-            candidates.append(_candidate(IdentifierKind.DOI, doi, normalized_doi, "legacy_doi", CONFIDENCE_HIGH, pub_url))
+            candidates.append(
+                _candidate(IdentifierKind.DOI, doi, normalized_doi, "legacy_doi", CONFIDENCE_HIGH, pub_url)
+            )
     candidates.extend(_url_identifier_candidates(values=values, source="legacy_urls"))
     return _dedup_candidates(candidates)
 
@@ -332,10 +334,13 @@ async def _existing_identifier_by_kind(
     kind: str,
 ) -> PublicationIdentifier | None:
     result = await db_session.execute(
-        select(PublicationIdentifier).where(
+        select(PublicationIdentifier)
+        .where(
             PublicationIdentifier.publication_id == publication_id,
             PublicationIdentifier.kind == kind,
-        ).order_by(PublicationIdentifier.confidence_score.desc()).limit(1)
+        )
+        .order_by(PublicationIdentifier.confidence_score.desc())
+        .limit(1)
     )
     return result.scalar_one_or_none()
 
@@ -380,7 +385,9 @@ def _overlay_publication_item(
     item: PublicationListItem,
     display_identifier: DisplayIdentifier | None,
 ) -> PublicationListItem:
-    fallback = display_identifier or derive_display_identifier_from_values(doi=None, pub_url=item.pub_url, pdf_url=item.pdf_url)
+    fallback = display_identifier or derive_display_identifier_from_values(
+        doi=None, pub_url=item.pub_url, pdf_url=item.pdf_url
+    )
     return replace(item, display_identifier=fallback)
 
 
@@ -447,8 +454,7 @@ def _best_display_identifier_map(rows: list[PublicationIdentifier]) -> dict[int,
     return {
         publication_id: display
         for publication_id, display in (
-            (publication_id, _best_display_identifier(candidates))
-            for publication_id, candidates in grouped.items()
+            (publication_id, _best_display_identifier(candidates)) for publication_id, candidates in grouped.items()
         )
         if display is not None
     }
diff --git a/app/services/domains/publications/application.py b/app/services/domains/publications/application.py
index f51c79a..b36f2ec 100644
--- a/app/services/domains/publications/application.py
+++ b/app/services/domains/publications/application.py
@@ -1,21 +1,21 @@
 from __future__ import annotations
 
 from app.services.domains.publications.counts import (
-    count_for_user,
     count_favorite_for_user,
+    count_for_user,
     count_latest_for_user,
     count_unread_for_user,
 )
-from app.services.domains.publications.listing import (
-    list_for_user,
-    retry_pdf_for_user,
-    list_unread_for_user,
-)
 from app.services.domains.publications.enrichment import (
     hydrate_pdf_enrichment_state,
     schedule_missing_pdf_enrichment_for_user,
     schedule_retry_pdf_enrichment_for_row,
 )
+from app.services.domains.publications.listing import (
+    list_for_user,
+    list_unread_for_user,
+    retry_pdf_for_user,
+)
 from app.services.domains.publications.modes import (
     MODE_ALL,
     MODE_LATEST,
@@ -23,6 +23,13 @@ from app.services.domains.publications.modes import (
     MODE_UNREAD,
     resolve_publication_view_mode,
 )
+from app.services.domains.publications.pdf_queue import (
+    count_pdf_queue_items,
+    enqueue_all_missing_pdf_jobs,
+    enqueue_retry_pdf_job_for_publication_id,
+    list_pdf_queue_items,
+    list_pdf_queue_page,
+)
 from app.services.domains.publications.queries import (
     get_latest_run_id_for_user,
     get_publication_item_for_user,
@@ -33,42 +40,35 @@ from app.services.domains.publications.read_state import (
     mark_selected_as_read_for_user,
     set_publication_favorite_for_user,
 )
-from app.services.domains.publications.pdf_queue import (
-    count_pdf_queue_items,
-    enqueue_all_missing_pdf_jobs,
-    enqueue_retry_pdf_job_for_publication_id,
-    list_pdf_queue_page,
-    list_pdf_queue_items,
-)
 from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
 
 __all__ = [
     "MODE_ALL",
-    "MODE_UNREAD",
     "MODE_LATEST",
     "MODE_NEW",
+    "MODE_UNREAD",
     "PublicationListItem",
     "UnreadPublicationItem",
-    "resolve_publication_view_mode",
-    "get_latest_run_id_for_user",
-    "publications_query",
-    "get_publication_item_for_user",
-    "list_for_user",
-    "list_unread_for_user",
-    "retry_pdf_for_user",
-    "hydrate_pdf_enrichment_state",
-    "schedule_retry_pdf_enrichment_for_row",
-    "list_pdf_queue_items",
-    "list_pdf_queue_page",
+    "count_favorite_for_user",
+    "count_for_user",
+    "count_latest_for_user",
     "count_pdf_queue_items",
+    "count_unread_for_user",
     "enqueue_all_missing_pdf_jobs",
     "enqueue_retry_pdf_job_for_publication_id",
-    "schedule_missing_pdf_enrichment_for_user",
-    "count_for_user",
-    "count_favorite_for_user",
-    "count_unread_for_user",
-    "count_latest_for_user",
+    "get_latest_run_id_for_user",
+    "get_publication_item_for_user",
+    "hydrate_pdf_enrichment_state",
+    "list_for_user",
+    "list_pdf_queue_items",
+    "list_pdf_queue_page",
+    "list_unread_for_user",
     "mark_all_unread_as_read_for_user",
     "mark_selected_as_read_for_user",
+    "publications_query",
+    "resolve_publication_view_mode",
+    "retry_pdf_for_user",
+    "schedule_missing_pdf_enrichment_for_user",
+    "schedule_retry_pdf_enrichment_for_row",
     "set_publication_favorite_for_user",
 ]
diff --git a/app/services/domains/publications/dedup.py b/app/services/domains/publications/dedup.py
index 5bf1d43..d2e17a6 100644
--- a/app/services/domains/publications/dedup.py
+++ b/app/services/domains/publications/dedup.py
@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 import hashlib
 import logging
-from typing import Iterable
+from collections.abc import Iterable
+from dataclasses import dataclass
 
 from sqlalchemy import delete, select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -113,9 +113,7 @@ async def _load_publication(
     *,
     publication_id: int,
 ) -> Publication | None:
-    result = await db_session.execute(
-        select(Publication).where(Publication.id == publication_id)
-    )
+    result = await db_session.execute(select(Publication).where(Publication.id == publication_id))
     return result.scalar_one_or_none()
 
 
@@ -160,9 +158,7 @@ async def _migrate_scholar_links(
     dup_links = dup_links_result.scalars().all()
 
     winner_profiles_result = await db_session.execute(
-        select(ScholarPublication.scholar_profile_id).where(
-            ScholarPublication.publication_id == winner_id
-        )
+        select(ScholarPublication.scholar_profile_id).where(ScholarPublication.publication_id == winner_id)
     )
     winner_profiles: set[int] = {row for (row,) in winner_profiles_result}
 
@@ -346,11 +342,7 @@ def _candidate_from_row(
 
 
 def _normalized_tokens(tokens: Iterable[str]) -> set[str]:
-    return {
-        token
-        for token in tokens
-        if len(token) >= NEAR_DUP_MIN_TOKEN_LENGTH and token not in NEAR_DUP_STOPWORDS
-    }
+    return {token for token in tokens if len(token) >= NEAR_DUP_MIN_TOKEN_LENGTH and token not in NEAR_DUP_STOPWORDS}
 
 
 def _cluster_candidate_groups(
diff --git a/app/services/domains/publications/enrichment.py b/app/services/domains/publications/enrichment.py
index 8a6b04f..49cf9c6 100644
--- a/app/services/domains/publications/enrichment.py
+++ b/app/services/domains/publications/enrichment.py
@@ -4,12 +4,12 @@ import logging
 
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.logging_utils import structured_log
 from app.services.domains.publications.pdf_queue import (
     enqueue_missing_pdf_jobs,
     enqueue_retry_pdf_job,
     overlay_pdf_job_state,
 )
-from app.logging_utils import structured_log
 from app.services.domains.publications.types import PublicationListItem
 
 logger = logging.getLogger(__name__)
@@ -30,7 +30,9 @@ async def schedule_missing_pdf_enrichment_for_user(
         rows=items,
         max_items=max_items,
     )
-    structured_log(logger, "info", "publications.enrichment.scheduled", user_id=user_id, publication_count=len(queued_ids))
+    structured_log(
+        logger, "info", "publications.enrichment.scheduled", user_id=user_id, publication_count=len(queued_ids)
+    )
     return len(queued_ids)
 
 
@@ -47,7 +49,14 @@ async def schedule_retry_pdf_enrichment_for_row(
         request_email=request_email,
         row=item,
     )
-    structured_log(logger, "info", "publications.enrichment.retry_scheduled", user_id=user_id, publication_id=item.publication_id, queued=queued)
+    structured_log(
+        logger,
+        "info",
+        "publications.enrichment.retry_scheduled",
+        user_id=user_id,
+        publication_id=item.publication_id,
+        queued=queued,
+    )
     return queued
 
 
diff --git a/app/services/domains/publications/listing.py b/app/services/domains/publications/listing.py
index 5290f6f..92e7462 100644
--- a/app/services/domains/publications/listing.py
+++ b/app/services/domains/publications/listing.py
@@ -51,10 +51,7 @@ async def list_for_user(
             snapshot_before=snapshot_before,
         )
     )
-    rows = [
-        publication_list_item_from_row(row, latest_run_id=latest_run_id)
-        for row in result.all()
-    ]
+    rows = [publication_list_item_from_row(row, latest_run_id=latest_run_id) for row in result.all()]
     return await identifier_service.overlay_publication_items_with_display_identifiers(
         db_session,
         items=rows,
diff --git a/app/services/domains/publications/pdf_queue.py b/app/services/domains/publications/pdf_queue.py
index 0313f11..880b1a2 100644
--- a/app/services/domains/publications/pdf_queue.py
+++ b/app/services/domains/publications/pdf_queue.py
@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import asyncio
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
 import logging
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
 
 from sqlalchemy import Select, and_, func, literal, or_, select, union_all
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -17,6 +17,7 @@ from app.db.models import (
     User,
 )
 from app.db.session import get_session_factory
+from app.logging_utils import structured_log
 from app.services.domains.publication_identifiers import application as identifier_service
 from app.services.domains.publication_identifiers.types import DisplayIdentifier
 from app.services.domains.publications.pdf_resolution_pipeline import (
@@ -27,7 +28,6 @@ from app.services.domains.unpaywall.application import (
     FAILURE_RESOLUTION_EXCEPTION,
     OaResolutionOutcome,
 )
-from app.logging_utils import structured_log
 from app.settings import settings
 
 PDF_STATUS_UNTRACKED = "untracked"
@@ -85,7 +85,7 @@ class PdfQueuePage:
 
 
 def _utcnow() -> datetime:
-    return datetime.now(timezone.utc)
+    return datetime.now(UTC)
 
 
 def _publication_ids(rows: list[PublicationListItem]) -> list[int]:
@@ -472,7 +472,13 @@ async def _resolve_publication_row(
         # Propagate upward so the batch loop can stop immediately.
         raise
     except Exception as exc:  # pragma: no cover - defensive network boundary
-        structured_log(logger, "warning", "publications.pdf_queue.resolve_failed", publication_id=row.publication_id, error=str(exc))
+        structured_log(
+            logger,
+            "warning",
+            "publications.pdf_queue.resolve_failed",
+            publication_id=row.publication_id,
+            error=str(exc),
+        )
         outcome = _failed_outcome(row=row)
         arxiv_rate_limited = False
     await _persist_outcome(
@@ -514,9 +520,19 @@ async def _run_resolution_task(
             )
             if arxiv_rate_limited and arxiv_lookup_allowed:
                 arxiv_lookup_allowed = False
-                structured_log(logger, "warning", "pdf_queue.arxiv_batch_disabled", detail="arXiv temporarily disabled for remaining batch after rate limit")
+                structured_log(
+                    logger,
+                    "warning",
+                    "pdf_queue.arxiv_batch_disabled",
+                    detail="arXiv temporarily disabled for remaining batch after rate limit",
+                )
         except OpenAlexBudgetExhaustedError:
-            structured_log(logger, "warning", "pdf_queue.budget_exhausted", detail="Stopping PDF resolution batch — OpenAlex daily budget exhausted")
+            structured_log(
+                logger,
+                "warning",
+                "pdf_queue.budget_exhausted",
+                detail="Stopping PDF resolution batch — OpenAlex daily budget exhausted",
+            )
             break
 
 
@@ -679,7 +695,7 @@ async def _missing_pdf_candidates(
     limit: int,
 ) -> list[PublicationListItem]:
     bounded_limit = max(1, min(int(limit), 5000))
-    now = datetime.now(timezone.utc)
+    now = datetime.now(UTC)
     cooldown_threshold = now - timedelta(days=7)
 
     result = await db_session.execute(
@@ -701,10 +717,7 @@ async def _missing_pdf_candidates(
         .order_by(Publication.updated_at.desc(), Publication.id.desc())
         .limit(bounded_limit)
     )
-    return [
-        _queue_candidate_from_publication(publication)
-        for publication in result.scalars()
-    ]
+    return [_queue_candidate_from_publication(publication) for publication in result.scalars()]
 
 
 async def enqueue_all_missing_pdf_jobs(
@@ -902,9 +915,7 @@ async def count_pdf_queue_items(
     if normalized_status == PDF_STATUS_UNTRACKED:
         result = await db_session.execute(_untracked_queue_count_select())
         return int(result.scalar_one() or 0)
-    tracked_result = await db_session.execute(
-        _tracked_queue_count_select(status=normalized_status)
-    )
+    tracked_result = await db_session.execute(_tracked_queue_count_select(status=normalized_status))
     tracked_count = int(tracked_result.scalar_one() or 0)
     if normalized_status is not None:
         return tracked_count
@@ -946,9 +957,7 @@ async def drain_ready_jobs(
     limit: int,
     max_attempts: int,
 ) -> int:
-    result = await db_session.execute(
-        select(User.id).where(User.is_active.is_(True)).order_by(User.id.asc()).limit(1)
-    )
+    result = await db_session.execute(select(User.id).where(User.is_active.is_(True)).order_by(User.id.asc()).limit(1))
     system_user_id = result.scalar_one_or_none()
     if system_user_id is None:
         return 0
diff --git a/app/services/domains/publications/pdf_resolution_pipeline.py b/app/services/domains/publications/pdf_resolution_pipeline.py
index 37efa6b..88a07ca 100644
--- a/app/services/domains/publications/pdf_resolution_pipeline.py
+++ b/app/services/domains/publications/pdf_resolution_pipeline.py
@@ -1,15 +1,15 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 import logging
+from dataclasses import dataclass
 from typing import Any
 
+from app.logging_utils import structured_log
 from app.services.domains.arxiv.application import ArxivRateLimitError
 from app.services.domains.arxiv.guards import arxiv_skip_reason_for_item
 from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
 from app.services.domains.publications.types import PublicationListItem
 from app.services.domains.unpaywall.application import OaResolutionOutcome, resolve_publication_oa_outcomes
-from app.logging_utils import structured_log
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
@@ -66,6 +66,7 @@ async def _openalex_outcome(
         return None
 
     import re
+
     safe_title = re.sub(r"[^\w\s]", " ", row.title)
     safe_title = " ".join(safe_title.split())
     if not safe_title:
@@ -107,12 +108,24 @@ async def _arxiv_outcome(
     from app.services.domains.arxiv.application import discover_arxiv_id_for_publication
 
     if not allow_lookup:
-        structured_log(logger, "info", "pdf_resolution.arxiv_skipped", publication_id=int(row.publication_id), skip_reason="batch_arxiv_cooldown_active")
+        structured_log(
+            logger,
+            "info",
+            "pdf_resolution.arxiv_skipped",
+            publication_id=int(row.publication_id),
+            skip_reason="batch_arxiv_cooldown_active",
+        )
         return None
 
     skip_reason = arxiv_skip_reason_for_item(item=row)
     if skip_reason is not None:
-        structured_log(logger, "info", "pdf_resolution.arxiv_skipped", publication_id=int(row.publication_id), skip_reason=skip_reason)
+        structured_log(
+            logger,
+            "info",
+            "pdf_resolution.arxiv_skipped",
+            publication_id=int(row.publication_id),
+            skip_reason=skip_reason,
+        )
         return None
 
     try:
@@ -134,7 +147,6 @@ async def _arxiv_outcome(
     return None
 
 
-
 async def _oa_outcome(
     *,
     row: PublicationListItem,
diff --git a/app/services/domains/publications/queries.py b/app/services/domains/publications/queries.py
index d642a73..89dd1d1 100644
--- a/app/services/domains/publications/queries.py
+++ b/app/services/domains/publications/queries.py
@@ -228,9 +228,7 @@ def publication_list_item_from_row(
         is_read=bool(is_read),
         is_favorite=bool(is_favorite),
         first_seen_at=created_at,
-        is_new_in_latest_run=(
-            latest_run_id is not None and int(first_seen_run_id or 0) == latest_run_id
-        ),
+        is_new_in_latest_run=(latest_run_id is not None and int(first_seen_run_id or 0) == latest_run_id),
     )
 
 
diff --git a/app/services/domains/publications/read_state.py b/app/services/domains/publications/read_state.py
index 41fc31a..b816d59 100644
--- a/app/services/domains/publications/read_state.py
+++ b/app/services/domains/publications/read_state.py
@@ -17,11 +17,7 @@ def _normalized_selection_pairs(selections: list[tuple[int, int]]) -> set[tuple[
 
 
 def _scoped_scholar_ids_query(*, user_id: int):
-    return (
-        select(ScholarProfile.id)
-        .where(ScholarProfile.user_id == user_id)
-        .scalar_subquery()
-    )
+    return select(ScholarProfile.id).where(ScholarProfile.user_id == user_id).scalar_subquery()
 
 
 async def mark_all_unread_as_read_for_user(
diff --git a/app/services/domains/runs/application.py b/app/services/domains/runs/application.py
index 0019446..4f6e27f 100644
--- a/app/services/domains/runs/application.py
+++ b/app/services/domains/runs/application.py
@@ -25,21 +25,21 @@ from app.services.domains.runs.types import (
 )
 
 __all__ = [
+    "QUEUE_STATUS_DROPPED",
     "QUEUE_STATUS_QUEUED",
     "QUEUE_STATUS_RETRYING",
-    "QUEUE_STATUS_DROPPED",
-    "QueueListItem",
     "QueueClearResult",
+    "QueueListItem",
     "QueueTransitionError",
+    "clear_queue_item_for_user",
+    "drop_queue_item_for_user",
     "extract_run_summary",
+    "get_manual_run_by_idempotency_key",
+    "get_queue_item_for_user",
+    "get_run_for_user",
+    "list_queue_items_for_user",
     "list_recent_runs_for_user",
     "list_runs_for_user",
-    "get_run_for_user",
-    "get_manual_run_by_idempotency_key",
-    "list_queue_items_for_user",
-    "get_queue_item_for_user",
-    "retry_queue_item_for_user",
-    "drop_queue_item_for_user",
-    "clear_queue_item_for_user",
     "queue_status_counts_for_user",
+    "retry_queue_item_for_user",
 ]
diff --git a/app/services/domains/runs/events.py b/app/services/domains/runs/events.py
index ef28069..7f4a71e 100644
--- a/app/services/domains/runs/events.py
+++ b/app/services/domains/runs/events.py
@@ -1,14 +1,16 @@
 import asyncio
 import json
 import logging
-from typing import Any, AsyncGenerator, Dict, Set
+from collections.abc import AsyncGenerator
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
+
 class RunEventPublisher:
     def __init__(self) -> None:
         # Maps run_id to a set of subscriber queues
-        self._subscribers: Dict[int, Set[asyncio.Queue]] = {}
+        self._subscribers: dict[int, set[asyncio.Queue]] = {}
 
     def subscribe(self, run_id: int) -> asyncio.Queue:
         if run_id not in self._subscribers:
@@ -27,12 +29,9 @@ class RunEventPublisher:
     async def publish(self, run_id: int, event_type: str, data: dict[str, Any]) -> None:
         if run_id not in self._subscribers:
             return
-        
-        message = {
-            "type": event_type,
-            "data": data
-        }
-        
+
+        message = {"type": event_type, "data": data}
+
         # Fan-out to all active subscribers for this run
         for queue in list(self._subscribers[run_id]):
             try:
@@ -40,8 +39,10 @@ class RunEventPublisher:
             except asyncio.QueueFull:
                 logger.warning(f"Subscriber queue full for run {run_id}, dropping message")
 
+
 run_events = RunEventPublisher()
 
+
 async def event_generator(run_id: int) -> AsyncGenerator[str, None]:
     queue = run_events.subscribe(run_id)
     try:
diff --git a/app/services/domains/runs/queue_service.py b/app/services/domains/runs/queue_service.py
index d69ce21..530e5b5 100644
--- a/app/services/domains/runs/queue_service.py
+++ b/app/services/domains/runs/queue_service.py
@@ -41,9 +41,7 @@ async def get_queue_item_for_user(
     queue_item_id: int,
 ) -> QueueListItem | None:
     result = await db_session.execute(
-        queue_item_select(user_id=user_id)
-        .where(IngestionQueueItem.id == queue_item_id)
-        .limit(1)
+        queue_item_select(user_id=user_id).where(IngestionQueueItem.id == queue_item_id).limit(1)
     )
     row = result.one_or_none()
     if row is None:
diff --git a/app/services/domains/runs/runs_service.py b/app/services/domains/runs/runs_service.py
index 1cb9aa2..72901ec 100644
--- a/app/services/domains/runs/runs_service.py
+++ b/app/services/domains/runs/runs_service.py
@@ -35,9 +35,7 @@ async def list_runs_for_user(
         .limit(limit)
     )
     if failed_only:
-        stmt = stmt.where(
-            CrawlRun.status.in_([RunStatus.FAILED, RunStatus.PARTIAL_FAILURE])
-        )
+        stmt = stmt.where(CrawlRun.status.in_([RunStatus.FAILED, RunStatus.PARTIAL_FAILURE]))
     result = await db_session.execute(stmt)
     return list(result.scalars().all())
 
diff --git a/app/services/domains/runs/summary.py b/app/services/domains/runs/summary.py
index 9555558..b18ceb8 100644
--- a/app/services/domains/runs/summary.py
+++ b/app/services/domains/runs/summary.py
@@ -24,9 +24,7 @@ def _summary_int_dict(summary: dict[str, Any], key: str) -> dict[str, int]:
     if not isinstance(value, dict):
         return {}
     return {
-        str(item_key): _safe_int(item_value, 0)
-        for item_key, item_value in value.items()
-        if isinstance(item_key, str)
+        str(item_key): _safe_int(item_value, 0) for item_key, item_value in value.items() if isinstance(item_key, str)
     }
 
 
@@ -34,11 +32,7 @@ def _summary_bool_dict(summary: dict[str, Any], key: str) -> dict[str, bool]:
     value = summary.get(key)
     if not isinstance(value, dict):
         return {}
-    return {
-        str(item_key): bool(item_value)
-        for item_key, item_value in value.items()
-        if isinstance(item_key, str)
-    }
+    return {str(item_key): bool(item_value) for item_key, item_value in value.items() if isinstance(item_key, str)}
 
 
 def _retry_counts(summary: dict[str, Any]) -> dict[str, int]:
diff --git a/app/services/domains/scholar/author_rows.py b/app/services/domains/scholar/author_rows.py
index 8acd783..42a8b2b 100644
--- a/app/services/domains/scholar/author_rows.py
+++ b/app/services/domains/scholar/author_rows.py
@@ -79,9 +79,7 @@ class ScholarAuthorSearchParser(HTMLParser):
             return
 
         affiliation = normalize_space("".join(self._candidate["aff_parts"])) or None
-        email_domain = _extract_verified_email_domain(
-            normalize_space("".join(self._candidate["eml_parts"])) or None
-        )
+        email_domain = _extract_verified_email_domain(normalize_space("".join(self._candidate["eml_parts"])) or None)
         cited_by_text = normalize_space("".join(self._candidate["cby_parts"]))
         cited_by_match = re.search(r"\d+", cited_by_text)
         cited_by_count = int(cited_by_match.group(0)) if cited_by_match else None
@@ -97,10 +95,7 @@ class ScholarAuthorSearchParser(HTMLParser):
 
         profile_url = build_absolute_scholar_url(self._candidate["name_href"])
         if not profile_url:
-            profile_url = (
-                "https://scholar.google.com/citations"
-                f"?hl=en&user={scholar_id}"
-            )
+            profile_url = f"https://scholar.google.com/citations?hl=en&user={scholar_id}"
 
         self.candidates.append(
             ScholarSearchCandidate(
diff --git a/app/services/domains/scholar/parser.py b/app/services/domains/scholar/parser.py
index 060e825..26b2faf 100644
--- a/app/services/domains/scholar/parser.py
+++ b/app/services/domains/scholar/parser.py
@@ -3,40 +3,29 @@ from __future__ import annotations
 from app.services.domains.scholar.author_rows import (
     ScholarAuthorSearchParser,
     count_author_search_markers,
-    parse_scholar_id_from_href,
 )
 from app.services.domains.scholar.parser_constants import SCRIPT_STYLE_RE
 from app.services.domains.scholar.parser_types import (
-    ParseState,
     ParsedAuthorSearchPage,
     ParsedProfilePage,
     PublicationCandidate,
     ScholarDomInvariantError,
     ScholarMalformedDataError,
-    ScholarParserError,
-    ScholarSearchCandidate,
 )
 from app.services.domains.scholar.parser_utils import (
     strip_tags,
 )
 from app.services.domains.scholar.profile_rows import (
-    ScholarRowParser,
     count_markers,
     extract_articles_range,
     extract_profile_image_url,
     extract_profile_name,
-    extract_rows,
     has_operation_error_banner,
     has_show_more_button,
-    parse_citation_count,
-    parse_cluster_id_from_href,
     parse_publications,
-    parse_year,
 )
 from app.services.domains.scholar.source import FetchResult
 from app.services.domains.scholar.state_detection import (
-    classify_block_or_captcha_reason,
-    classify_network_error_reason,
     detect_author_search_state,
     detect_state,
 )
diff --git a/app/services/domains/scholar/profile_rows.py b/app/services/domains/scholar/profile_rows.py
index 6a63274..38faf0a 100644
--- a/app/services/domains/scholar/profile_rows.py
+++ b/app/services/domains/scholar/profile_rows.py
@@ -12,7 +12,6 @@ from app.services.domains.scholar.parser_types import PublicationCandidate
 from app.services.domains.scholar.parser_utils import (
     attr_class,
     attr_href,
-    attr_src,
     build_absolute_scholar_url,
     normalize_space,
     strip_tags,
@@ -260,7 +259,7 @@ def has_show_more_button(html: str) -> bool:
 
 def has_operation_error_banner(html: str) -> bool:
     lowered = html.lower()
-    if "id=\"gsc_a_err\"" not in lowered and "id='gsc_a_err'" not in lowered:
+    if 'id="gsc_a_err"' not in lowered and "id='gsc_a_err'" not in lowered:
         return False
     return "can't perform the operation now" in lowered or "cannot perform the operation now" in lowered
 
diff --git a/app/services/domains/scholar/source.py b/app/services/domains/scholar/source.py
index 7e34f01..3930f2e 100644
--- a/app/services/domains/scholar/source.py
+++ b/app/services/domains/scholar/source.py
@@ -17,18 +17,12 @@ SCHOLAR_PROFILE_URL = "https://scholar.google.com/citations"
 DEFAULT_PAGE_SIZE = 100
 
 DEFAULT_USER_AGENTS = [
-    (
-        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
-        "(KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
-    ),
+    ("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"),
     (
         "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7) AppleWebKit/605.1.15 "
         "(KHTML, like Gecko) Version/18.1 Safari/605.1.15"
     ),
-    (
-        "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) "
-        "Gecko/20100101 Firefox/131.0"
-    ),
+    ("Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0"),
 ]
 
 logger = logging.getLogger(__name__)
@@ -44,8 +38,7 @@ class FetchResult:
 
 
 class ScholarSource(Protocol):
-    async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
-        ...
+    async def fetch_profile_html(self, scholar_id: str) -> FetchResult: ...
 
     async def fetch_profile_page_html(
         self,
@@ -53,16 +46,14 @@ class ScholarSource(Protocol):
         *,
         cstart: int,
         pagesize: int,
-    ) -> FetchResult:
-        ...
+    ) -> FetchResult: ...
 
     async def fetch_author_search_html(
         self,
         query: str,
         *,
         start: int,
-    ) -> FetchResult:
-        ...
+    ) -> FetchResult: ...
 
 
 class LiveScholarSource:
@@ -145,7 +136,9 @@ class LiveScholarSource:
     @staticmethod
     def _network_error_result(requested_url: str, exc: URLError) -> FetchResult:
         structured_log(
-            logger, "warning", "scholar_source.fetch_network_error",
+            logger,
+            "warning",
+            "scholar_source.fetch_network_error",
             requested_url=requested_url,
         )
         return FetchResult(
@@ -159,7 +152,9 @@ class LiveScholarSource:
     @staticmethod
     def _http_error_result(requested_url: str, exc: HTTPError) -> FetchResult:
         structured_log(
-            logger, "warning", "scholar_source.fetch_http_error",
+            logger,
+            "warning",
+            "scholar_source.fetch_http_error",
             requested_url=requested_url,
             status_code=exc.code,
         )
@@ -176,7 +171,9 @@ class LiveScholarSource:
         body = response.read().decode("utf-8", errors="replace")
         status_code = getattr(response, "status", 200)
         structured_log(
-            logger, "debug", "scholar_source.fetch_succeeded",
+            logger,
+            "debug",
+            "scholar_source.fetch_succeeded",
             requested_url=requested_url,
             status_code=status_code,
         )
diff --git a/app/services/domains/scholars/application.py b/app/services/domains/scholars/application.py
index 18ffdae..3b66643 100644
--- a/app/services/domains/scholars/application.py
+++ b/app/services/domains/scholars/application.py
@@ -1,13 +1,11 @@
 from __future__ import annotations
 
 import asyncio
-from dataclasses import replace
-from datetime import datetime
-from datetime import timedelta
-from datetime import timezone
 import logging
 import os
 import random
+from dataclasses import replace
+from datetime import UTC, datetime, timedelta
 from uuid import uuid4
 
 from sqlalchemy import delete, func, select, text
@@ -15,9 +13,10 @@ from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import AuthorSearchCacheEntry, AuthorSearchRuntimeState, ScholarProfile
+from app.logging_utils import structured_log
 from app.services.domains.scholar.parser import (
-    ParseState,
     ParsedAuthorSearchPage,
+    ParseState,
     ScholarParserError,
     parse_author_search_page,
     parse_profile_page,
@@ -34,33 +33,30 @@ from app.services.domains.scholars.constants import (
     DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD,
     DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS,
     DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS,
-    MAX_AUTHOR_SEARCH_LIMIT,
     DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS,
     DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD,
+    MAX_AUTHOR_SEARCH_LIMIT,
     SEARCH_CACHED_BLOCK_REASON,
     SEARCH_COOLDOWN_REASON,
     SEARCH_DISABLED_REASON,
 )
-from app.logging_utils import structured_log
 from app.services.domains.scholars.exceptions import ScholarServiceError
 from app.services.domains.scholars.search_hints import (
     _merge_warnings,
     _policy_blocked_author_search_result,
     _trim_author_search_result,
-    resolve_profile_image,
-    scrape_state_hint,
 )
 from app.services.domains.scholars.uploads import (
     _ensure_upload_root,
     _resolve_upload_path,
     _safe_remove_upload,
-    resolve_upload_file_path,
 )
 from app.services.domains.scholars.validators import (
     normalize_display_name,
     normalize_profile_image_url,
     validate_scholar_id,
 )
+
 logger = logging.getLogger(__name__)
 
 
@@ -247,7 +243,7 @@ async def _cache_get_author_search_result(
         return None
     expires_at = entry.expires_at
     if expires_at.tzinfo is None:
-        expires_at = expires_at.replace(tzinfo=timezone.utc)
+        expires_at = expires_at.replace(tzinfo=UTC)
     if expires_at <= now_utc:
         await db_session.delete(entry)
         return None
@@ -305,27 +301,19 @@ async def _prune_author_search_cache(
     now_utc: datetime,
     max_entries: int,
 ) -> None:
-    await db_session.execute(
-        delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.expires_at <= now_utc)
-    )
+    await db_session.execute(delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.expires_at <= now_utc))
     bounded_max_entries = max(1, int(max_entries))
-    count_result = await db_session.execute(
-        select(func.count()).select_from(AuthorSearchCacheEntry)
-    )
+    count_result = await db_session.execute(select(func.count()).select_from(AuthorSearchCacheEntry))
     entry_count = int(count_result.scalar_one() or 0)
     overflow = max(0, entry_count - bounded_max_entries)
     if overflow <= 0:
         return
     stale_keys_result = await db_session.execute(
-        select(AuthorSearchCacheEntry.query_key)
-        .order_by(AuthorSearchCacheEntry.cached_at.asc())
-        .limit(overflow)
+        select(AuthorSearchCacheEntry.query_key).order_by(AuthorSearchCacheEntry.cached_at.asc()).limit(overflow)
     )
     stale_keys = [str(row[0]) for row in stale_keys_result.all()]
     if stale_keys:
-        await db_session.execute(
-            delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key.in_(stale_keys))
-        )
+        await db_session.execute(delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key.in_(stale_keys)))
 
 
 def _is_author_search_block_state(parsed: ParsedAuthorSearchPage) -> bool:
@@ -340,7 +328,7 @@ def _author_search_cooldown_remaining_seconds(
     if cooldown_until is None:
         return 0
     if cooldown_until.tzinfo is None:
-        cooldown_until = cooldown_until.replace(tzinfo=timezone.utc)
+        cooldown_until = cooldown_until.replace(tzinfo=UTC)
     remaining_seconds = int((cooldown_until - now_utc).total_seconds())
     return max(0, remaining_seconds)
 
@@ -432,7 +420,9 @@ def _normalize_author_search_inputs(query: str, limit: int) -> tuple[str, int, s
 
 def _disabled_search_result(*, normalized_query: str, bounded_limit: int) -> ParsedAuthorSearchPage:
     structured_log(
-        logger, "warning", "scholar_search.disabled_by_configuration",
+        logger,
+        "warning",
+        "scholar_search.disabled_by_configuration",
         query=normalized_query,
     )
     return _policy_blocked_author_search_result(
@@ -452,13 +442,15 @@ def _normalize_runtime_cooldown_state(
     cooldown_until = runtime_state.cooldown_until
     updated = False
     if cooldown_until.tzinfo is None:
-        cooldown_until = cooldown_until.replace(tzinfo=timezone.utc)
+        cooldown_until = cooldown_until.replace(tzinfo=UTC)
         runtime_state.cooldown_until = cooldown_until
         updated = True
     if now_utc < cooldown_until:
         return updated
     structured_log(
-        logger, "info", "scholar_search.cooldown_expired",
+        logger,
+        "info",
+        "scholar_search.cooldown_expired",
         cooldown_until_utc=cooldown_until.isoformat(),
     )
     runtime_state.cooldown_until = None
@@ -494,7 +486,9 @@ def _emit_cooldown_threshold_alert(
     if bool(runtime_state.cooldown_alert_emitted):
         return True
     structured_log(
-        logger, "error", "scholar_search.cooldown_rejection_threshold_exceeded",
+        logger,
+        "error",
+        "scholar_search.cooldown_rejection_threshold_exceeded",
         query=normalized_query,
         cooldown_rejection_count=int(runtime_state.cooldown_rejection_count),
         threshold=threshold,
@@ -518,7 +512,9 @@ def _cooldown_block_result(
         cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
     )
     structured_log(
-        logger, "warning", "scholar_search.cooldown_active",
+        logger,
+        "warning",
+        "scholar_search.cooldown_active",
         query=normalized_query,
         cooldown_remaining_seconds=cooldown_remaining_seconds,
         cooldown_until_utc=runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
@@ -549,7 +545,9 @@ async def _cache_hit_result(
     if cached is None:
         return None
     structured_log(
-        logger, "info", "scholar_search.cache_hit",
+        logger,
+        "info",
+        "scholar_search.cache_hit",
         query=normalized_query,
         state=cached.state.value,
         state_reason=cached.state_reason,
@@ -576,7 +574,7 @@ def _throttle_sleep_seconds(
     else:
         last_live_request_at = runtime_state.last_live_request_at
         if last_live_request_at.tzinfo is None:
-            last_live_request_at = last_live_request_at.replace(tzinfo=timezone.utc)
+            last_live_request_at = last_live_request_at.replace(tzinfo=UTC)
             runtime_state.last_live_request_at = last_live_request_at
             updated = True
         enforced_wait_seconds = (
@@ -603,7 +601,9 @@ async def _wait_for_author_search_throttle(
     if sleep_seconds <= 0.0:
         return updated
     structured_log(
-        logger, "info", "scholar_search.throttle_wait",
+        logger,
+        "info",
+        "scholar_search.throttle_wait",
         query=normalized_query,
         sleep_seconds=round(sleep_seconds, 3),
     )
@@ -659,7 +659,9 @@ def _with_retry_warnings(
     if retry_scheduled_count < threshold:
         return merged
     structured_log(
-        logger, "warning", "scholar_search.retry_threshold_exceeded",
+        logger,
+        "warning",
+        "scholar_search.retry_threshold_exceeded",
         query=normalized_query,
         retry_scheduled_count=retry_scheduled_count,
         threshold=threshold,
@@ -688,19 +690,23 @@ def _apply_block_circuit_breaker(
         return merged_parsed
     runtime_state.consecutive_blocked_count = int(runtime_state.consecutive_blocked_count) + 1
     structured_log(
-        logger, "warning", "scholar_search.block_detected",
+        logger,
+        "warning",
+        "scholar_search.block_detected",
         query=normalized_query,
         state_reason=merged_parsed.state_reason,
         consecutive_blocked_count=int(runtime_state.consecutive_blocked_count),
     )
     if int(runtime_state.consecutive_blocked_count) < max(1, int(cooldown_block_threshold)):
         return merged_parsed
-    runtime_state.cooldown_until = datetime.now(timezone.utc) + timedelta(seconds=max(60, int(cooldown_seconds)))
+    runtime_state.cooldown_until = datetime.now(UTC) + timedelta(seconds=max(60, int(cooldown_seconds)))
     runtime_state.consecutive_blocked_count = 0
     runtime_state.cooldown_rejection_count = 0
     runtime_state.cooldown_alert_emitted = False
     structured_log(
-        logger, "error", "scholar_search.cooldown_activated",
+        logger,
+        "error",
+        "scholar_search.cooldown_activated",
         query=normalized_query,
         cooldown_until_utc=runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
     )
@@ -739,11 +745,11 @@ async def _cooldown_or_cache_result(
 ) -> tuple[ParsedAuthorSearchPage | None, bool]:
     runtime_state_updated = _normalize_runtime_cooldown_state(
         runtime_state,
-        now_utc=datetime.now(timezone.utc),
+        now_utc=datetime.now(UTC),
     )
     cooldown_remaining_seconds = _author_search_cooldown_remaining_seconds(
         runtime_state,
-        datetime.now(timezone.utc),
+        datetime.now(UTC),
     )
     if cooldown_remaining_seconds > 0:
         return (
@@ -759,18 +765,35 @@ async def _cooldown_or_cache_result(
     cached_result = await _cache_hit_result(
         db_session,
         query_key=query_key,
-        now_utc=datetime.now(timezone.utc),
+        now_utc=datetime.now(UTC),
         normalized_query=normalized_query,
         bounded_limit=bounded_limit,
     )
     return cached_result, runtime_state_updated
 
 
-async def _perform_live_author_search(db_session: AsyncSession, *, source: ScholarSource, runtime_state: AuthorSearchRuntimeState, normalized_query: str, query_key: str, network_error_retries: int, retry_backoff_seconds: float, min_interval_seconds: float, interval_jitter_seconds: float, retry_alert_threshold: int, cooldown_block_threshold: int, cooldown_seconds: int, blocked_cache_ttl_seconds: int, cache_ttl_seconds: int, cache_max_entries: int) -> tuple[ParsedAuthorSearchPage, bool]:
+async def _perform_live_author_search(
+    db_session: AsyncSession,
+    *,
+    source: ScholarSource,
+    runtime_state: AuthorSearchRuntimeState,
+    normalized_query: str,
+    query_key: str,
+    network_error_retries: int,
+    retry_backoff_seconds: float,
+    min_interval_seconds: float,
+    interval_jitter_seconds: float,
+    retry_alert_threshold: int,
+    cooldown_block_threshold: int,
+    cooldown_seconds: int,
+    blocked_cache_ttl_seconds: int,
+    cache_ttl_seconds: int,
+    cache_max_entries: int,
+) -> tuple[ParsedAuthorSearchPage, bool]:
     runtime_state_updated = await _wait_for_author_search_throttle(
         runtime_state=runtime_state,
         normalized_query=normalized_query,
-        now_utc=datetime.now(timezone.utc),
+        now_utc=datetime.now(UTC),
         min_interval_seconds=min_interval_seconds,
         interval_jitter_seconds=interval_jitter_seconds,
     )
@@ -780,7 +803,7 @@ async def _perform_live_author_search(db_session: AsyncSession, *, source: Schol
         network_error_retries=network_error_retries,
         retry_backoff_seconds=retry_backoff_seconds,
     )
-    runtime_state.last_live_request_at = datetime.now(timezone.utc)
+    runtime_state.last_live_request_at = datetime.now(UTC)
     merged = _with_retry_warnings(
         parsed,
         retry_warnings=retry_warnings,
@@ -806,12 +829,30 @@ async def _perform_live_author_search(db_session: AsyncSession, *, source: Schol
         parsed=merged,
         ttl_seconds=float(ttl_seconds),
         max_entries=cache_max_entries,
-        now_utc=datetime.now(timezone.utc),
+        now_utc=datetime.now(UTC),
     )
     return merged, True
 
 
-async def search_author_candidates(*, source: ScholarSource, db_session: AsyncSession, query: str, limit: int, network_error_retries: int = 1, retry_backoff_seconds: float = 1.0, search_enabled: bool = True, cache_ttl_seconds: int = 21_600, blocked_cache_ttl_seconds: int = DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS, cache_max_entries: int = DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES, min_interval_seconds: float = DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS, interval_jitter_seconds: float = DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS, cooldown_block_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD, cooldown_seconds: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS, retry_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD, cooldown_rejection_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD) -> ParsedAuthorSearchPage:
+async def search_author_candidates(
+    *,
+    source: ScholarSource,
+    db_session: AsyncSession,
+    query: str,
+    limit: int,
+    network_error_retries: int = 1,
+    retry_backoff_seconds: float = 1.0,
+    search_enabled: bool = True,
+    cache_ttl_seconds: int = 21_600,
+    blocked_cache_ttl_seconds: int = DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS,
+    cache_max_entries: int = DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES,
+    min_interval_seconds: float = DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS,
+    interval_jitter_seconds: float = DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS,
+    cooldown_block_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD,
+    cooldown_seconds: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS,
+    retry_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD,
+    cooldown_rejection_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD,
+) -> ParsedAuthorSearchPage:
     normalized_query, bounded_limit, query_key = _normalize_author_search_inputs(query, limit)
     if not search_enabled:
         return _disabled_search_result(
@@ -924,17 +965,13 @@ async def set_profile_image_upload(
     normalized_content_type = (content_type or "").strip().lower()
     extension = ALLOWED_IMAGE_UPLOAD_CONTENT_TYPES.get(normalized_content_type)
     if extension is None:
-        raise ScholarServiceError(
-            "Unsupported image type. Use JPEG, PNG, WEBP, or GIF."
-        )
+        raise ScholarServiceError("Unsupported image type. Use JPEG, PNG, WEBP, or GIF.")
 
     if not image_bytes:
         raise ScholarServiceError("Uploaded image file is empty.")
 
     if len(image_bytes) > max_upload_bytes:
-        raise ScholarServiceError(
-            f"Uploaded image exceeds {max_upload_bytes} bytes."
-        )
+        raise ScholarServiceError(f"Uploaded image exceeds {max_upload_bytes} bytes.")
 
     upload_root = _ensure_upload_root(upload_dir, create=True)
     user_dir = upload_root / str(profile.user_id)
diff --git a/app/services/domains/scholars/constants.py b/app/services/domains/scholars/constants.py
index 7ee18ad..0602acd 100644
--- a/app/services/domains/scholars/constants.py
+++ b/app/services/domains/scholars/constants.py
@@ -32,39 +32,25 @@ SEARCH_CACHED_BLOCK_REASON = "search_temporarily_disabled_from_cached_blocked_re
 
 STATE_REASON_HINTS: dict[str, str] = {
     SEARCH_DISABLED_REASON: (
-        "Scholar name search is currently disabled by service policy. "
-        "Add scholars by profile URL or Scholar ID."
+        "Scholar name search is currently disabled by service policy. Add scholars by profile URL or Scholar ID."
     ),
     SEARCH_COOLDOWN_REASON: (
         "Scholar name search is temporarily paused after repeated block responses. "
         "Use Scholar URL/ID adds until cooldown expires."
     ),
     SEARCH_CACHED_BLOCK_REASON: (
-        "A recent blocked response was cached to reduce traffic. "
-        "Retry later or add by Scholar URL/ID."
+        "A recent blocked response was cached to reduce traffic. Retry later or add by Scholar URL/ID."
     ),
     "network_dns_resolution_failed": (
-        "DNS resolution failed while reaching scholar.google.com. "
-        "Verify container DNS/network and retry."
-    ),
-    "network_timeout": (
-        "Request timed out before Google Scholar responded. "
-        "Increase delay/backoff and retry."
-    ),
-    "network_tls_error": (
-        "TLS handshake/certificate validation failed. "
-        "Verify outbound TLS/network configuration."
-    ),
-    "blocked_http_429_rate_limited": (
-        "Google Scholar rate-limited the request. "
-        "Slow request cadence and retry later."
+        "DNS resolution failed while reaching scholar.google.com. Verify container DNS/network and retry."
     ),
+    "network_timeout": ("Request timed out before Google Scholar responded. Increase delay/backoff and retry."),
+    "network_tls_error": ("TLS handshake/certificate validation failed. Verify outbound TLS/network configuration."),
+    "blocked_http_429_rate_limited": ("Google Scholar rate-limited the request. Slow request cadence and retry later."),
     "blocked_unusual_traffic_detected": (
-        "Google Scholar flagged traffic as unusual. "
-        "Increase delay/jitter and reduce concurrent scraping."
+        "Google Scholar flagged traffic as unusual. Increase delay/jitter and reduce concurrent scraping."
     ),
     "blocked_accounts_redirect": (
-        "Request was redirected to Google Account sign-in. "
-        "Treat as access block and retry later."
+        "Request was redirected to Google Account sign-in. Treat as access block and retry later."
     ),
 }
diff --git a/app/services/domains/scholars/search_hints.py b/app/services/domains/scholars/search_hints.py
index f905c14..b33cb1b 100644
--- a/app/services/domains/scholars/search_hints.py
+++ b/app/services/domains/scholars/search_hints.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from app.db.models import ScholarProfile
-from app.services.domains.scholar.parser import ParseState, ParsedAuthorSearchPage
+from app.services.domains.scholar.parser import ParsedAuthorSearchPage, ParseState
 from app.services.domains.scholars.constants import (
     MAX_AUTHOR_SEARCH_LIMIT,
     STATE_REASON_HINTS,
diff --git a/app/services/domains/scholars/validators.py b/app/services/domains/scholars/validators.py
index 1c79baa..e102eb1 100644
--- a/app/services/domains/scholars/validators.py
+++ b/app/services/domains/scholars/validators.py
@@ -27,9 +27,7 @@ def normalize_profile_image_url(value: str | None) -> str | None:
         return None
 
     if len(candidate) > MAX_IMAGE_URL_LENGTH:
-        raise ScholarServiceError(
-            f"Image URL must be {MAX_IMAGE_URL_LENGTH} characters or fewer."
-        )
+        raise ScholarServiceError(f"Image URL must be {MAX_IMAGE_URL_LENGTH} characters or fewer.")
 
     parsed = urlparse(candidate)
     if parsed.scheme.lower() not in {"http", "https"} or not parsed.netloc:
diff --git a/app/services/domains/settings/application.py b/app/services/domains/settings/application.py
index 7f435e8..3636bf6 100644
--- a/app/services/domains/settings/application.py
+++ b/app/services/domains/settings/application.py
@@ -60,9 +60,7 @@ def parse_run_interval_minutes(value: str, *, minimum: int = HARD_MIN_RUN_INTERV
         raise UserSettingsServiceError("Check interval must be a whole number.") from exc
     effective_minimum = resolve_run_interval_minimum(minimum)
     if parsed < effective_minimum:
-        raise UserSettingsServiceError(
-            f"Check interval must be at least {effective_minimum} minutes."
-        )
+        raise UserSettingsServiceError(f"Check interval must be at least {effective_minimum} minutes.")
     return parsed
 
 
@@ -73,9 +71,7 @@ def parse_request_delay_seconds(value: str, *, minimum: int = HARD_MIN_REQUEST_D
         raise UserSettingsServiceError("Request delay must be a whole number.") from exc
     effective_minimum = resolve_request_delay_minimum(minimum)
     if parsed < effective_minimum:
-        raise UserSettingsServiceError(
-            f"Request delay must be at least {effective_minimum} seconds."
-        )
+        raise UserSettingsServiceError(f"Request delay must be at least {effective_minimum} seconds.")
     return parsed
 
 
@@ -102,23 +98,20 @@ def parse_nav_visible_pages(value: object) -> list[str]:
 
     missing_required = [page for page in REQUIRED_NAV_PAGES if page not in seen]
     if missing_required:
-        raise UserSettingsServiceError(
-            "Dashboard, Scholars, and Settings must remain visible."
-        )
+        raise UserSettingsServiceError("Dashboard, Scholars, and Settings must remain visible.")
 
     return deduped
 
 
 from app.settings import settings as app_settings
 
+
 async def get_or_create_settings(
     db_session: AsyncSession,
     *,
     user_id: int,
 ) -> UserSetting:
-    result = await db_session.execute(
-        select(UserSetting).where(UserSetting.user_id == user_id)
-    )
+    result = await db_session.execute(select(UserSetting).where(UserSetting.user_id == user_id))
     settings = result.scalar_one_or_none()
     if settings is not None:
         return settings
diff --git a/app/services/domains/unpaywall/application.py b/app/services/domains/unpaywall/application.py
index 8b4d528..0febe51 100644
--- a/app/services/domains/unpaywall/application.py
+++ b/app/services/domains/unpaywall/application.py
@@ -1,11 +1,12 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 import logging
 import re
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 from urllib.parse import unquote
 
+from app.logging_utils import structured_log
 from app.services.domains.crossref.application import discover_doi_for_publication
 from app.services.domains.doi.normalize import normalize_doi
 from app.services.domains.unpaywall.pdf_discovery import (
@@ -13,7 +14,6 @@ from app.services.domains.unpaywall.pdf_discovery import (
     resolve_pdf_from_landing_page,
 )
 from app.services.domains.unpaywall.rate_limit import wait_for_unpaywall_slot
-from app.logging_utils import structured_log
 from app.settings import settings
 
 if TYPE_CHECKING:
@@ -67,11 +67,8 @@ def _publication_doi(item: PublicationListItem | UnreadPublicationItem) -> str |
     stored = None
     if getattr(item, "display_identifier", None) and item.display_identifier.kind == "doi":
         stored = normalize_doi(item.display_identifier.value)
-    
-    explicit_doi = (
-        _extract_explicit_doi(item.pub_url)
-        or _extract_explicit_doi(item.venue_text)
-    )
+
+    explicit_doi = _extract_explicit_doi(item.pub_url) or _extract_explicit_doi(item.venue_text)
     if explicit_doi:
         return explicit_doi
     pub_url_doi = _extract_doi_candidate(item.pub_url)
@@ -289,10 +286,7 @@ def _resolved_pdf_count(outcomes: dict[int, OaResolutionOutcome]) -> int:
 
 
 def _outcome_metadata(outcomes: dict[int, OaResolutionOutcome]) -> dict[int, tuple[str | None, str | None]]:
-    return {
-        publication_id: (outcome.doi, outcome.pdf_url)
-        for publication_id, outcome in outcomes.items()
-    }
+    return {publication_id: (outcome.doi, outcome.pdf_url) for publication_id, outcome in outcomes.items()}
 
 
 async def _resolve_outcome_for_item(
@@ -347,7 +341,9 @@ async def _safe_outcome_for_item(
             allow_crossref=allow_crossref,
         )
     except Exception as exc:  # pragma: no cover - defensive network boundary
-        structured_log(logger, "warning", "unpaywall.resolve_item_failed", publication_id=item.publication_id, error=str(exc))
+        structured_log(
+            logger, "warning", "unpaywall.resolve_item_failed", publication_id=item.publication_id, error=str(exc)
+        )
         return _outcome_with_failure(
             item=item,
             failure_reason=FAILURE_RESOLUTION_EXCEPTION,
@@ -410,7 +406,9 @@ async def resolve_publication_oa_outcomes(
             email=email,
         )
     structured_log(
-        logger, "info", "unpaywall.resolve_completed",
+        logger,
+        "info",
+        "unpaywall.resolve_completed",
         publication_count=len(items),
         doi_input_count=_doi_input_count(items),
         search_attempt_count=_search_attempt_count(targets=targets),
diff --git a/app/services/domains/unpaywall/pdf_discovery.py b/app/services/domains/unpaywall/pdf_discovery.py
index 5f82a58..312bf04 100644
--- a/app/services/domains/unpaywall/pdf_discovery.py
+++ b/app/services/domains/unpaywall/pdf_discovery.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from html.parser import HTMLParser
 import re
+from html.parser import HTMLParser
 from urllib.parse import urljoin, urlparse
 
 from app.services.domains.unpaywall.rate_limit import wait_for_unpaywall_slot
diff --git a/app/services/domains/users/application.py b/app/services/domains/users/application.py
index 7f019c4..e07f514 100644
--- a/app/services/domains/users/application.py
+++ b/app/services/domains/users/application.py
@@ -39,9 +39,7 @@ async def get_user_by_id(db_session: AsyncSession, user_id: int) -> User | None:
 
 
 async def get_user_by_email(db_session: AsyncSession, email: str) -> User | None:
-    result = await db_session.execute(
-        select(User).where(User.email == normalize_email(email))
-    )
+    result = await db_session.execute(select(User).where(User.email == normalize_email(email)))
     return result.scalar_one_or_none()
 
 
@@ -95,4 +93,3 @@ async def set_user_password_hash(
     await db_session.commit()
     await db_session.refresh(user)
     return user
-
diff --git a/app/settings.py b/app/settings.py
index 51ebcf4..175480e 100644
--- a/app/settings.py
+++ b/app/settings.py
@@ -1,5 +1,5 @@
-from dataclasses import dataclass
 import os
+from dataclasses import dataclass
 
 DEFAULT_SECURITY_PERMISSIONS_POLICY = (
     "accelerometer=(), autoplay=(), camera=(), display-capture=(), "
@@ -266,7 +266,7 @@ class Settings:
     crossref_timeout_seconds: float = _env_float("CROSSREF_TIMEOUT_SECONDS", 8.0)
     crossref_min_interval_seconds: float = _env_float("CROSSREF_MIN_INTERVAL_SECONDS", 0.6)
     crossref_max_lookups_per_request: int = _env_int("CROSSREF_MAX_LOOKUPS_PER_REQUEST", 8)
-    
+
     openalex_api_key: str | None = os.getenv("OPENALEX_API_KEY")
     crossref_api_token: str | None = os.getenv("CROSSREF_API_TOKEN")
     crossref_api_mailto: str | None = os.getenv("CROSSREF_API_MAILTO")
diff --git a/frontend/src/theme/presets/deutan-blue.js b/frontend/src/theme/presets/deutan-blue.js
new file mode 100644
index 0000000..d8ecba2
--- /dev/null
+++ b/frontend/src/theme/presets/deutan-blue.js
@@ -0,0 +1,313 @@
+export default {
+  "id": "deutan-blue-75",
+  "label": "Deutan Colorblind - Blue",
+  "description": "Colorblind-oriented theme with blue-led emphasis and deutan-safer state separation.",
+  "modes": {
+    "light": {
+      "scale": {
+        "brand": {
+          "50": "#f3f7ff",
+          "100": "#e6efff",
+          "200": "#c9dbff",
+          "300": "#a6c1ff",
+          "400": "#7ea2f5",
+          "500": "#5f84dc",
+          "600": "#4a6bc0",
+          "700": "#3e589b",
+          "800": "#35497d",
+          "900": "#2e3f68",
+          "950": "#1d2742"
+        },
+        "info": {
+          "50": "#f0f7fa",
+          "100": "#dcedf4",
+          "200": "#bcd9e8",
+          "300": "#93bfd8",
+          "400": "#669fc4",
+          "500": "#4b82a8",
+          "600": "#3b6887",
+          "700": "#31546d",
+          "800": "#2b465a",
+          "900": "#253b4c",
+          "950": "#16242f"
+        },
+        "success": {
+          "50": "#f2f8ff",
+          "100": "#deefff",
+          "200": "#bddfff",
+          "300": "#93c9ff",
+          "400": "#62acef",
+          "500": "#3e8fd1",
+          "600": "#2f72ad",
+          "700": "#285c8c",
+          "800": "#244d73",
+          "900": "#213f5d",
+          "950": "#15273a"
+        },
+        "warning": {
+          "50": "#fff8ef",
+          "100": "#ffedd2",
+          "200": "#ffd7a3",
+          "300": "#ffbb6b",
+          "400": "#f49c38",
+          "500": "#db7f1d",
+          "600": "#b86516",
+          "700": "#945013",
+          "800": "#784214",
+          "900": "#633814",
+          "950": "#381d0a"
+        },
+        "danger": {
+          "50": "#fcf4fb",
+          "100": "#f7e6f5",
+          "200": "#efcdea",
+          "300": "#e2a7d8",
+          "400": "#ce79bf",
+          "500": "#b856a4",
+          "600": "#9b3f89",
+          "700": "#7f3470",
+          "800": "#692e5d",
+          "900": "#57294d",
+          "950": "#311428"
+        }
+      },
+      "surface": {
+        "app": "#f4f7fb",
+        "nav": "#ffffff",
+        "nav_active": "#dce9ff",
+        "card": "#ffffff",
+        "card_muted": "#edf3fb",
+        "table": "#ffffff",
+        "table_header": "#f4f7fb",
+        "input": "#ffffff",
+        "overlay": "#1c2430"
+      },
+      "text": {
+        "primary": "#1f2937",
+        "secondary": "#41536b",
+        "muted": "#6a7a8f",
+        "inverse": "#ffffff",
+        "link": "#3e589b"
+      },
+      "border": {
+        "default": "#d8e2ee",
+        "strong": "#bccbdb",
+        "subtle": "#edf3fb",
+        "interactive": "#7ea2f5"
+      },
+      "focus": {
+        "ring": "#5f84dc",
+        "ring_offset": "#f4f7fb"
+      },
+      "action": {
+        "primary": {
+          "bg": "#5f84dc",
+          "border": "#5f84dc",
+          "text": "#ffffff",
+          "hover_bg": "#4a6bc0",
+          "hover_border": "#4a6bc0",
+          "hover_text": "#ffffff"
+        },
+        "secondary": {
+          "bg": "#edf3fb",
+          "border": "#d8e2ee",
+          "text": "#1f2937",
+          "hover_bg": "#dce9ff",
+          "hover_border": "#bccbdb",
+          "hover_text": "#111827"
+        },
+        "ghost": {
+          "bg": "#f4f7fb",
+          "border": "#d8e2ee",
+          "text": "#3e589b",
+          "hover_bg": "#edf3fb",
+          "hover_border": "#bccbdb",
+          "hover_text": "#2e3f68"
+        },
+        "danger": {
+          "bg": "#f7e6f5",
+          "border": "#efcdea",
+          "text": "#7f3470",
+          "hover_bg": "#efcdea",
+          "hover_border": "#e2a7d8",
+          "hover_text": "#692e5d"
+        }
+      },
+      "state": {
+        "info": {
+          "bg": "#dcedf4",
+          "border": "#bcd9e8",
+          "text": "#31546d"
+        },
+        "success": {
+          "bg": "#deefff",
+          "border": "#bddfff",
+          "text": "#285c8c"
+        },
+        "warning": {
+          "bg": "#ffedd2",
+          "border": "#ffd7a3",
+          "text": "#945013"
+        },
+        "danger": {
+          "bg": "#f7e6f5",
+          "border": "#efcdea",
+          "text": "#7f3470"
+        }
+      }
+    },
+    "dark": {
+      "scale": {
+        "brand": {
+          "50": "#f3f7ff",
+          "100": "#e6efff",
+          "200": "#c9dbff",
+          "300": "#a6c1ff",
+          "400": "#7ea2f5",
+          "500": "#5f84dc",
+          "600": "#4a6bc0",
+          "700": "#3e589b",
+          "800": "#35497d",
+          "900": "#2e3f68",
+          "950": "#1d2742"
+        },
+        "info": {
+          "50": "#f0f7fa",
+          "100": "#dcedf4",
+          "200": "#bcd9e8",
+          "300": "#93bfd8",
+          "400": "#669fc4",
+          "500": "#4b82a8",
+          "600": "#3b6887",
+          "700": "#31546d",
+          "800": "#2b465a",
+          "900": "#253b4c",
+          "950": "#16242f"
+        },
+        "success": {
+          "50": "#f2f8ff",
+          "100": "#deefff",
+          "200": "#bddfff",
+          "300": "#93c9ff",
+          "400": "#62acef",
+          "500": "#3e8fd1",
+          "600": "#2f72ad",
+          "700": "#285c8c",
+          "800": "#244d73",
+          "900": "#213f5d",
+          "950": "#15273a"
+        },
+        "warning": {
+          "50": "#fff8ef",
+          "100": "#ffedd2",
+          "200": "#ffd7a3",
+          "300": "#ffbb6b",
+          "400": "#f49c38",
+          "500": "#db7f1d",
+          "600": "#b86516",
+          "700": "#945013",
+          "800": "#784214",
+          "900": "#633814",
+          "950": "#381d0a"
+        },
+        "danger": {
+          "50": "#fcf4fb",
+          "100": "#f7e6f5",
+          "200": "#efcdea",
+          "300": "#e2a7d8",
+          "400": "#ce79bf",
+          "500": "#b856a4",
+          "600": "#9b3f89",
+          "700": "#7f3470",
+          "800": "#692e5d",
+          "900": "#57294d",
+          "950": "#311428"
+        }
+      },
+      "surface": {
+        "app": "#111827",
+        "nav": "#172131",
+        "nav_active": "#3e589b",
+        "card": "#172131",
+        "card_muted": "#1d2a3d",
+        "table": "#172131",
+        "table_header": "#1d2a3d",
+        "input": "#0d1522",
+        "overlay": "#05070b"
+      },
+      "text": {
+        "primary": "#e8eef7",
+        "secondary": "#bfd0e6",
+        "muted": "#8ea1ba",
+        "inverse": "#111827",
+        "link": "#a6c1ff"
+      },
+      "border": {
+        "default": "#27364b",
+        "strong": "#334760",
+        "subtle": "#1d2a3d",
+        "interactive": "#5f84dc"
+      },
+      "focus": {
+        "ring": "#7ea2f5",
+        "ring_offset": "#111827"
+      },
+      "action": {
+        "primary": {
+          "bg": "#5f84dc",
+          "border": "#5f84dc",
+          "text": "#0b1020",
+          "hover_bg": "#7ea2f5",
+          "hover_border": "#7ea2f5",
+          "hover_text": "#0b1020"
+        },
+        "secondary": {
+          "bg": "#1d2a3d",
+          "border": "#334760",
+          "text": "#e8eef7",
+          "hover_bg": "#27364b",
+          "hover_border": "#41536b",
+          "hover_text": "#ffffff"
+        },
+        "ghost": {
+          "bg": "#111827",
+          "border": "#27364b",
+          "text": "#bfd0e6",
+          "hover_bg": "#1d2a3d",
+          "hover_border": "#334760",
+          "hover_text": "#ffffff"
+        },
+        "danger": {
+          "bg": "#311428",
+          "border": "#7f3470",
+          "text": "#efcdea",
+          "hover_bg": "#421b35",
+          "hover_border": "#9b3f89",
+          "hover_text": "#f7e6f5"
+        }
+      },
+      "state": {
+        "info": {
+          "bg": "#253b4c",
+          "border": "#31546d",
+          "text": "#dcedf4"
+        },
+        "success": {
+          "bg": "#213f5d",
+          "border": "#285c8c",
+          "text": "#deefff"
+        },
+        "warning": {
+          "bg": "#633814",
+          "border": "#945013",
+          "text": "#ffd7a3"
+        },
+        "danger": {
+          "bg": "#311428",
+          "border": "#7f3470",
+          "text": "#efcdea"
+        }
+      }
+    }
+  }
+};
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 4990b4b..79c61b1 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -27,6 +27,8 @@ dependencies = [
 dev = [
   "pytest>=8.3,<9.0",
   "pytest-asyncio>=0.25,<0.26",
+  "ruff>=0.9",
+  "mypy>=1.14",
 ]
 
 [tool.pytest.ini_options]
@@ -41,6 +43,24 @@ markers = [
   "smoke: smoke tests for containerized runtime",
 ]
 
+[tool.ruff]
+target-version = "py312"
+line-length = 120
+extend-exclude = ["alembic/versions"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B", "SIM", "RUF"]
+ignore = ["E501", "B008", "RUF001"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["app"]
+
+[tool.mypy]
+python_version = "3.12"
+ignore_missing_imports = true
+check_untyped_defs = false
+warn_unused_ignores = true
+
 [tool.setuptools]
 include-package-data = true
 
diff --git a/scripts/check_frontend_api_contract.py b/scripts/check_frontend_api_contract.py
index 07ba856..52e6e97 100755
--- a/scripts/check_frontend_api_contract.py
+++ b/scripts/check_frontend_api_contract.py
@@ -103,9 +103,7 @@ def main() -> int:
             print(f"- {method} {route}")
         return 1
 
-    print(
-        f"Frontend API contract check passed: {len(frontend_routes)} frontend routes match backend definitions."
-    )
+    print(f"Frontend API contract check passed: {len(frontend_routes)} frontend routes match backend definitions.")
     return 0
 
 
diff --git a/tests/conftest.py b/tests/conftest.py
index 0fb19ed..323a396 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -6,12 +6,12 @@ import re
 from collections.abc import AsyncIterator, Iterator
 
 import pytest
-from alembic import command
 from alembic.config import Config
-from sqlalchemy.engine import make_url
 from sqlalchemy import text
+from sqlalchemy.engine import make_url
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 
+from alembic import command
 from app.auth.deps import get_login_rate_limiter
 from app.db.session import close_engine
 from app.settings import settings
@@ -52,9 +52,7 @@ def _resolve_test_database_url() -> str | None:
     parsed = make_url(base)
     if not parsed.database:
         return None
-    derived_database = (
-        parsed.database if parsed.database.endswith("_test") else f"{parsed.database}_test"
-    )
+    derived_database = parsed.database if parsed.database.endswith("_test") else f"{parsed.database}_test"
     return parsed.set(database=derived_database).render_as_string(hide_password=False)
 
 
@@ -85,9 +83,7 @@ def ensure_test_database_exists(database_url: str) -> Iterator[None]:
     if not database_name:
         raise RuntimeError("TEST_DATABASE_URL must include a database name.")
     if not DB_NAME_SAFE_RE.fullmatch(database_name):
-        raise RuntimeError(
-            "TEST_DATABASE_URL database name must match [A-Za-z0-9_]+ for safe auto-provisioning."
-        )
+        raise RuntimeError("TEST_DATABASE_URL database name must match [A-Za-z0-9_]+ for safe auto-provisioning.")
 
     admin_name = "postgres" if database_name != "postgres" else "template1"
     admin_url = parsed.set(database=admin_name)
diff --git a/tests/integration/helpers.py b/tests/integration/helpers.py
index d1f5c68..135f271 100644
--- a/tests/integration/helpers.py
+++ b/tests/integration/helpers.py
@@ -6,6 +6,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.auth.security import PasswordService
 
+
 def login_user(client: TestClient, *, email: str, password: str) -> None:
     bootstrap_response = client.get("/api/v1/auth/csrf")
     assert bootstrap_response.status_code == 200
diff --git a/tests/integration/test_api_v1.py b/tests/integration/test_api_v1.py
index 7da04a6..c3e67e3 100644
--- a/tests/integration/test_api_v1.py
+++ b/tests/integration/test_api_v1.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from pathlib import Path
 
 import pytest
@@ -12,8 +12,8 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from app.api.runtime_deps import get_scholar_source
 from app.main import app
 from app.services.domains.publications.types import PublicationListItem
-from app.services.domains.settings import application as user_settings_service
 from app.services.domains.scholar.source import FetchResult
+from app.services.domains.settings import application as user_settings_service
 from app.settings import settings
 from tests.integration.helpers import insert_user, login_user
 
@@ -412,10 +412,7 @@ async def test_api_admin_dbops_integrity_and_repair_flow(db_session: AsyncSessio
     assert integrity_response.status_code == 200
     integrity_payload = integrity_response.json()["data"]
     assert integrity_payload["status"] in {"ok", "warning", "failed"}
-    assert any(
-        check["name"] == "missing_pdf_url"
-        for check in integrity_payload["checks"]
-    )
+    assert any(check["name"] == "missing_pdf_url" for check in integrity_payload["checks"])
 
     repair_response = client.post(
         "/api/v1/admin/db/repairs/publication-links",
@@ -450,10 +447,7 @@ async def test_api_admin_dbops_integrity_and_repair_flow(db_session: AsyncSessio
     assert page_two_payload["has_prev"] is True
     untracked_response = client.get("/api/v1/admin/db/pdf-queue?limit=20&status=untracked")
     assert untracked_response.status_code == 200
-    assert any(
-        item["status"] == "untracked"
-        for item in untracked_response.json()["data"]["items"]
-    )
+    assert any(item["status"] == "untracked" for item in untracked_response.json()["data"]["items"])
 
     link_count_result = await db_session.execute(
         text("SELECT count(*) FROM scholar_publications WHERE publication_id = :publication_id"),
@@ -1272,9 +1266,9 @@ async def test_api_settings_get_and_update(db_session: AsyncSession) -> None:
     assert settings_payload["policy"]["min_run_interval_minutes"] == user_settings_service.resolve_run_interval_minimum(
         settings.ingestion_min_run_interval_minutes
     )
-    assert settings_payload["policy"]["min_request_delay_seconds"] == user_settings_service.resolve_request_delay_minimum(
-        settings.ingestion_min_request_delay_seconds
-    )
+    assert settings_payload["policy"][
+        "min_request_delay_seconds"
+    ] == user_settings_service.resolve_request_delay_minimum(settings.ingestion_min_request_delay_seconds)
     assert settings_payload["policy"]["automation_allowed"] is settings.ingestion_automation_allowed
     assert settings_payload["policy"]["manual_run_allowed"] is settings.ingestion_manual_run_allowed
     assert settings_payload["policy"]["blocked_failure_threshold"] == max(
@@ -1482,10 +1476,7 @@ async def test_api_runs_manual_and_queue_actions(db_session: AsyncSession) -> No
 
     queue_list_response = client.get("/api/v1/runs/queue/items")
     assert queue_list_response.status_code == 200
-    assert any(
-        int(item["id"]) == queue_item_id
-        for item in queue_list_response.json()["data"]["queue_items"]
-    )
+    assert any(int(item["id"]) == queue_item_id for item in queue_list_response.json()["data"]["queue_items"])
 
     retry_response = client.post(f"/api/v1/runs/queue/{queue_item_id}/retry", headers=headers)
     assert retry_response.status_code == 200
@@ -1766,7 +1757,7 @@ async def test_api_settings_clears_expired_scrape_safety_cooldown(
     )
     user_settings.scrape_safety_state = {"blocked_start_count": 2}
     user_settings.scrape_cooldown_reason = "blocked_failure_threshold_exceeded"
-    user_settings.scrape_cooldown_until = datetime.now(timezone.utc) - timedelta(seconds=15)
+    user_settings.scrape_cooldown_until = datetime.now(UTC) - timedelta(seconds=15)
     await db_session.commit()
 
     client = TestClient(app)
diff --git a/tests/integration/test_data_repair_jobs.py b/tests/integration/test_data_repair_jobs.py
index f291866..dc02904 100644
--- a/tests/integration/test_data_repair_jobs.py
+++ b/tests/integration/test_data_repair_jobs.py
@@ -160,10 +160,7 @@ async def _assert_apply_effects(
     )
     baseline_completed = await _count_rows(
         db_session,
-        sql=(
-            "SELECT count(*) FROM scholar_profiles "
-            "WHERE id = :scholar_profile_id AND baseline_completed = false"
-        ),
+        sql=("SELECT count(*) FROM scholar_profiles WHERE id = :scholar_profile_id AND baseline_completed = false"),
         params={"scholar_profile_id": scholar_profile_id},
     )
     publication_count = await _count_rows(
diff --git a/tests/integration/test_deferred_enrichment.py b/tests/integration/test_deferred_enrichment.py
index c51861e..ff15345 100644
--- a/tests/integration/test_deferred_enrichment.py
+++ b/tests/integration/test_deferred_enrichment.py
@@ -1,22 +1,24 @@
 from __future__ import annotations
 
+from datetime import UTC, datetime
+from unittest.mock import AsyncMock, MagicMock, patch
+
 import pytest
-from unittest.mock import patch, AsyncMock, MagicMock
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
-from datetime import datetime, timezone
 
-from app.db.models import CrawlRun, Publication, ScholarProfile, ScholarPublication, RunStatus, RunTriggerType
+from app.db.models import CrawlRun, Publication, RunStatus, RunTriggerType, ScholarProfile, ScholarPublication
 from app.services.domains.ingestion.application import ScholarIngestionService
 from app.services.domains.openalex.types import OpenAlexWork
 from tests.integration.helpers import insert_user
 
+
 @pytest.mark.integration
 @pytest.mark.asyncio
 async def test_deferred_enrichment_sweeps_previous_runs(db_session: AsyncSession) -> None:
     # 1. Setup: Create user and scholar
     user_id = await insert_user(db_session, email="test@example.com", password="password123")
-    
+
     scholar = ScholarProfile(
         user_id=user_id,
         scholar_id="SaiiI5MAAAAJ",
@@ -25,17 +27,17 @@ async def test_deferred_enrichment_sweeps_previous_runs(db_session: AsyncSession
     )
     db_session.add(scholar)
     await db_session.flush()
-    
+
     # 2. Simulate a previous FAILED run that left an un-enriched publication
     failed_run = CrawlRun(
         user_id=user_id,
         status=RunStatus.FAILED,
         trigger_type=RunTriggerType.MANUAL,
-        start_dt=datetime.now(timezone.utc),
+        start_dt=datetime.now(UTC),
     )
     db_session.add(failed_run)
     await db_session.flush()
-    
+
     pub = Publication(
         title_raw="A fast quantum mechanical algorithm for database search",
         title_normalized="a fast quantum mechanical algorithm for database search",
@@ -45,7 +47,7 @@ async def test_deferred_enrichment_sweeps_previous_runs(db_session: AsyncSession
     )
     db_session.add(pub)
     await db_session.flush()
-    
+
     link = ScholarPublication(
         scholar_profile_id=scholar.id,
         publication_id=pub.id,
@@ -53,17 +55,17 @@ async def test_deferred_enrichment_sweeps_previous_runs(db_session: AsyncSession
     )
     db_session.add(link)
     await db_session.commit()
-    
+
     # 3. Create a NEW run
     new_run = CrawlRun(
         user_id=user_id,
         status=RunStatus.RUNNING,
         trigger_type=RunTriggerType.MANUAL,
-        start_dt=datetime.now(timezone.utc),
+        start_dt=datetime.now(UTC),
     )
     db_session.add(new_run)
     await db_session.commit()
-    
+
     # 4. Mock OpenAlex client to return enrichment data
     mock_work = OpenAlexWork(
         openalex_id="W1234567",
@@ -76,26 +78,30 @@ async def test_deferred_enrichment_sweeps_previous_runs(db_session: AsyncSession
         is_oa=True,
         oa_url="http://example.com/grover.pdf",
     )
-    
+
     mock_source = MagicMock()
     service = ScholarIngestionService(source=mock_source)
-    
+
     # We patch the client at its source, and also mock arXiv to avoid real HTTP calls
-    with patch("app.services.domains.openalex.client.OpenAlexClient") as MockClient, \
-         patch("app.services.domains.arxiv.application.discover_arxiv_id_for_publication", new=AsyncMock(return_value=None)):
+    with (
+        patch("app.services.domains.openalex.client.OpenAlexClient") as MockClient,
+        patch(
+            "app.services.domains.arxiv.application.discover_arxiv_id_for_publication", new=AsyncMock(return_value=None)
+        ),
+    ):
         mock_instance = MockClient.return_value
         mock_instance.get_works_by_filter = AsyncMock(return_value=[mock_work])
 
         # 5. Execute the enrichment pass for the NEW run
         await service._enrich_pending_publications(db_session, run_id=new_run.id)
         await db_session.commit()
-    
+
     # 6. Verification: The publication from the FAILED run should now be enriched
     await db_session.refresh(pub)
     assert pub.openalex_enriched is True
     assert pub.citation_count == 1000
     assert pub.pdf_url == "http://example.com/grover.pdf"
-    
+
     # Double check it was indeed processed
     stmt = select(Publication).where(Publication.id == pub.id)
     result = await db_session.execute(stmt)
diff --git a/tests/integration/test_fixture_probe_runs.py b/tests/integration/test_fixture_probe_runs.py
index 65361f2..0e721e5 100644
--- a/tests/integration/test_fixture_probe_runs.py
+++ b/tests/integration/test_fixture_probe_runs.py
@@ -34,8 +34,7 @@ def _blocked_fetch(*, scholar_id: str, body: str) -> FetchResult:
         requested_url=f"https://scholar.google.com/citations?hl=en&user={scholar_id}",
         status_code=200,
         final_url=(
-            "https://accounts.google.com/v3/signin/identifier"
-            "?continue=https%3A%2F%2Fscholar.google.com%2Fcitations"
+            "https://accounts.google.com/v3/signin/identifier?continue=https%3A%2F%2Fscholar.google.com%2Fcitations"
         ),
         body=body,
         error=None,
diff --git a/tests/integration/test_migrations.py b/tests/integration/test_migrations.py
index 0155cbc..0bb3440 100644
--- a/tests/integration/test_migrations.py
+++ b/tests/integration/test_migrations.py
@@ -29,9 +29,7 @@ EXPECTED_REVISION = "20260226_0024"
 @pytest.mark.migrations
 @pytest.mark.asyncio
 async def test_migration_creates_expected_tables(db_session: AsyncSession) -> None:
-    result = await db_session.execute(
-        text("SELECT tablename FROM pg_tables WHERE schemaname = 'public'")
-    )
+    result = await db_session.execute(text("SELECT tablename FROM pg_tables WHERE schemaname = 'public'"))
     table_names = {row[0] for row in result}
     assert EXPECTED_TABLES.issubset(table_names)
 
diff --git a/tests/integration/test_run_lifecycle_consistency.py b/tests/integration/test_run_lifecycle_consistency.py
index 28020e6..b74ec1f 100644
--- a/tests/integration/test_run_lifecycle_consistency.py
+++ b/tests/integration/test_run_lifecycle_consistency.py
@@ -338,8 +338,8 @@ async def test_partial_discovery_exception_keeps_new_pub_count_consistent(
 
     monkeypatch.setattr(service, "_resolve_publication", _resolve_publication_stub)
 
-    from app.services.domains.scholar.parser_types import PublicationCandidate
     from app.db.models import ScholarProfile
+    from app.services.domains.scholar.parser_types import PublicationCandidate
 
     scholar = await db_session.get(ScholarProfile, scholar_profile_id)
     assert scholar is not None
@@ -505,9 +505,7 @@ async def test_publications_pagination_snapshot_stays_stable_across_inserts(
     )
     assert first_page_again_response.status_code == 200
     first_page_again = first_page_again_response.json()["data"]
-    first_page_again_ids = [
-        int(item["publication_id"]) for item in first_page_again["publications"]
-    ]
+    first_page_again_ids = [int(item["publication_id"]) for item in first_page_again["publications"]]
 
     assert first_page_again_ids == first_page_ids
     assert not (set(first_page_ids) & set(second_page_ids))
diff --git a/tests/smoke/test_db_connectivity.py b/tests/smoke/test_db_connectivity.py
index 848a034..ba9ce76 100644
--- a/tests/smoke/test_db_connectivity.py
+++ b/tests/smoke/test_db_connectivity.py
@@ -20,4 +20,3 @@ async def test_database_connectivity_from_database_url() -> None:
             assert result.scalar_one() == 1
     finally:
         await engine.dispose()
-
diff --git a/tests/smoke/test_migration_schema.py b/tests/smoke/test_migration_schema.py
index c12be25..d107388 100644
--- a/tests/smoke/test_migration_schema.py
+++ b/tests/smoke/test_migration_schema.py
@@ -1,6 +1,6 @@
+import pytest
 from alembic.config import Config
 from alembic.script import ScriptDirectory
-import pytest
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession
 
diff --git a/tests/unit/services/domains/arxiv/test_cache.py b/tests/unit/services/domains/arxiv/test_cache.py
index 2f15891..1586a1b 100644
--- a/tests/unit/services/domains/arxiv/test_cache.py
+++ b/tests/unit/services/domains/arxiv/test_cache.py
@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import gc
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 
 import pytest
 from sqlalchemy import select
@@ -59,7 +59,7 @@ def test_build_query_fingerprint_normalizes_search_and_id_params() -> None:
 @pytest.mark.asyncio
 async def test_cache_entry_expires_and_is_deleted(db_session: AsyncSession) -> None:
     query_fingerprint = build_query_fingerprint(params={"search_query": "ti:test", "start": 0})
-    now_utc = datetime(2026, 2, 26, 12, 0, tzinfo=timezone.utc)
+    now_utc = datetime(2026, 2, 26, 12, 0, tzinfo=UTC)
 
     await set_cached_feed(
         query_fingerprint=query_fingerprint,
@@ -79,9 +79,7 @@ async def test_cache_entry_expires_and_is_deleted(db_session: AsyncSession) -> N
     )
 
     result = await db_session.execute(
-        select(ArxivQueryCacheEntry).where(
-            ArxivQueryCacheEntry.query_fingerprint == query_fingerprint
-        )
+        select(ArxivQueryCacheEntry).where(ArxivQueryCacheEntry.query_fingerprint == query_fingerprint)
     )
     assert hit is not None
     assert miss is None
@@ -118,6 +116,7 @@ async def test_inflight_owner_failure_without_joiner_has_no_unretrieved_exceptio
 
     loop.set_exception_handler(_capture_exception)
     try:
+
         async def _failing_fetch() -> ArxivFeed:
             raise RuntimeError("owner_failed")
 
diff --git a/tests/unit/services/domains/arxiv/test_client.py b/tests/unit/services/domains/arxiv/test_client.py
index 445d3cd..b51273d 100644
--- a/tests/unit/services/domains/arxiv/test_client.py
+++ b/tests/unit/services/domains/arxiv/test_client.py
@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import asyncio
-from datetime import datetime, timezone
+from datetime import UTC, datetime
+
 import httpx
 import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -35,7 +36,9 @@ async def test_client_search_builds_query_and_sort_params() -> None:
         captured["params"] = params
         captured["request_email"] = request_email
         captured["timeout_seconds"] = timeout_seconds
-        return httpx.Response(200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query"))
+        return httpx.Response(
+            200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query")
+        )
 
     client = ArxivClient(request_fn=_request_fn)
     feed = await client.search(
@@ -66,7 +69,9 @@ async def test_client_lookup_ids_builds_id_list_param() -> None:
 
     async def _request_fn(*, params, request_email, timeout_seconds):
         captured["params"] = params
-        return httpx.Response(200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query"))
+        return httpx.Response(
+            200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query")
+        )
 
     client = ArxivClient(request_fn=_request_fn)
     await client.lookup_ids(id_list=["1234.5678", " 9999.0001 "], start=0, max_results=2)
@@ -76,7 +81,9 @@ async def test_client_lookup_ids_builds_id_list_param() -> None:
 @pytest.mark.asyncio
 async def test_client_search_rejects_invalid_sort_by() -> None:
     async def _unused_request_fn(*, params, request_email, timeout_seconds):
-        return httpx.Response(200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query"))
+        return httpx.Response(
+            200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query")
+        )
 
     client = ArxivClient(request_fn=_unused_request_fn)
     with pytest.raises(ArxivClientValidationError):
@@ -86,7 +93,9 @@ async def test_client_search_rejects_invalid_sort_by() -> None:
 @pytest.mark.asyncio
 async def test_client_lookup_ids_rejects_empty_list() -> None:
     async def _unused_request_fn(*, params, request_email, timeout_seconds):
-        return httpx.Response(200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query"))
+        return httpx.Response(
+            200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query")
+        )
 
     client = ArxivClient(request_fn=_unused_request_fn)
     with pytest.raises(ArxivClientValidationError):
@@ -96,7 +105,9 @@ async def test_client_lookup_ids_rejects_empty_list() -> None:
 @pytest.mark.asyncio
 async def test_client_search_rejects_negative_start() -> None:
     async def _unused_request_fn(*, params, request_email, timeout_seconds):
-        return httpx.Response(200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query"))
+        return httpx.Response(
+            200, text=_CLIENT_FEED_XML, request=httpx.Request("GET", "https://export.arxiv.org/api/query")
+        )
 
     client = ArxivClient(request_fn=_unused_request_fn)
     with pytest.raises(ArxivClientValidationError):
@@ -172,7 +183,7 @@ async def test_request_feed_skips_live_call_when_global_cooldown_is_active(
         return ArxivCooldownStatus(
             is_active=True,
             remaining_seconds=61.0,
-            cooldown_until=datetime(2026, 2, 26, 12, 1, tzinfo=timezone.utc),
+            cooldown_until=datetime(2026, 2, 26, 12, 1, tzinfo=UTC),
         )
 
     async def _unexpected_limit_call(*, fetch, source_path):  # pragma: no cover - defensive
diff --git a/tests/unit/services/domains/arxiv/test_guards.py b/tests/unit/services/domains/arxiv/test_guards.py
index 6acc042..0ebe422 100644
--- a/tests/unit/services/domains/arxiv/test_guards.py
+++ b/tests/unit/services/domains/arxiv/test_guards.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 
 from app.services.domains.arxiv.guards import arxiv_skip_reason_for_item
 from app.services.domains.publication_identifiers.types import DisplayIdentifier
@@ -25,7 +25,7 @@ def _item(
         pub_url=pub_url,
         pdf_url=pdf_url,
         is_read=False,
-        first_seen_at=datetime.now(timezone.utc),
+        first_seen_at=datetime.now(UTC),
         is_new_in_latest_run=True,
         display_identifier=display_identifier,
     )
diff --git a/tests/unit/services/domains/arxiv/test_parser.py b/tests/unit/services/domains/arxiv/test_parser.py
index 5ff78a8..f93d719 100644
--- a/tests/unit/services/domains/arxiv/test_parser.py
+++ b/tests/unit/services/domains/arxiv/test_parser.py
@@ -50,6 +50,8 @@ def test_parse_arxiv_feed_raises_on_invalid_xml() -> None:
 
 
 def test_parse_arxiv_feed_raises_on_invalid_opensearch_integer() -> None:
-    payload = _VALID_FEED_XML.replace("<opensearch:totalResults>2</opensearch:totalResults>", "<opensearch:totalResults>x</opensearch:totalResults>")
+    payload = _VALID_FEED_XML.replace(
+        "<opensearch:totalResults>2</opensearch:totalResults>", "<opensearch:totalResults>x</opensearch:totalResults>"
+    )
     with pytest.raises(ArxivParseError):
         parse_arxiv_feed(payload)
diff --git a/tests/unit/services/domains/arxiv/test_rate_limit.py b/tests/unit/services/domains/arxiv/test_rate_limit.py
index 86ad949..69b4947 100644
--- a/tests/unit/services/domains/arxiv/test_rate_limit.py
+++ b/tests/unit/services/domains/arxiv/test_rate_limit.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 
 import httpx
 import pytest
@@ -20,7 +20,7 @@ async def test_arxiv_rate_limit_respects_cooldown(db_session: AsyncSession) -> N
     db_session.add(
         ArxivRuntimeState(
             state_key=ARXIV_RUNTIME_STATE_KEY,
-            cooldown_until=datetime.now(timezone.utc) + timedelta(seconds=30),
+            cooldown_until=datetime.now(UTC) + timedelta(seconds=30),
         )
     )
     await db_session.commit()
@@ -43,6 +43,7 @@ async def test_arxiv_rate_limit_persists_cooldown_after_429(db_session: AsyncSes
     object.__setattr__(settings, "arxiv_min_interval_seconds", 0.0)
     object.__setattr__(settings, "arxiv_rate_limit_cooldown_seconds", 5.0)
     try:
+
         async def _fetch() -> httpx.Response:
             return httpx.Response(429, text="rate limited")
 
@@ -57,7 +58,7 @@ async def test_arxiv_rate_limit_persists_cooldown_after_429(db_session: AsyncSes
     )
     state = result.scalar_one()
     assert state.cooldown_until is not None
-    assert state.cooldown_until > datetime.now(timezone.utc)
+    assert state.cooldown_until > datetime.now(UTC)
 
 
 @pytest.mark.asyncio
@@ -120,6 +121,7 @@ async def test_arxiv_rate_limit_logs_cooldown_activation(
     object.__setattr__(settings, "arxiv_min_interval_seconds", 0.0)
     object.__setattr__(settings, "arxiv_rate_limit_cooldown_seconds", 5.0)
     try:
+
         async def _fetch() -> httpx.Response:
             return httpx.Response(429, text="rate limited")
 
@@ -133,9 +135,7 @@ async def test_arxiv_rate_limit_logs_cooldown_activation(
         object.__setattr__(settings, "arxiv_min_interval_seconds", previous_interval)
         object.__setattr__(settings, "arxiv_rate_limit_cooldown_seconds", previous_cooldown)
 
-    cooldown_events = [
-        entry for entry in logged_warning if entry.get("event") == "arxiv.cooldown_activated"
-    ]
+    cooldown_events = [entry for entry in logged_warning if entry.get("event") == "arxiv.cooldown_activated"]
     assert cooldown_events
     assert cooldown_events[0]["source_path"] == "lookup_ids"
     assert float(cooldown_events[0]["cooldown_remaining_seconds"]) > 0.0
@@ -143,7 +143,7 @@ async def test_arxiv_rate_limit_logs_cooldown_activation(
 
 @pytest.mark.asyncio
 async def test_get_arxiv_cooldown_status_reads_active_cooldown(db_session: AsyncSession) -> None:
-    now_utc = datetime(2026, 2, 26, 13, 0, tzinfo=timezone.utc)
+    now_utc = datetime(2026, 2, 26, 13, 0, tzinfo=UTC)
     existing = await db_session.get(ArxivRuntimeState, ARXIV_RUNTIME_STATE_KEY)
     if existing is None:
         db_session.add(
diff --git a/tests/unit/services/domains/openalex/test_client.py b/tests/unit/services/domains/openalex/test_client.py
index 4b31cb3..5aab58f 100644
--- a/tests/unit/services/domains/openalex/test_client.py
+++ b/tests/unit/services/domains/openalex/test_client.py
@@ -1,6 +1,6 @@
-import pytest
 from app.services.domains.openalex.types import OpenAlexWork
 
+
 def test_parse_openalex_work_from_api_dict() -> None:
     raw_api_response = {
         "id": "https://openalex.org/W2741809807",
@@ -13,28 +13,19 @@ def test_parse_openalex_work_from_api_dict() -> None:
             "doi": "https://doi.org/10.1038/s41586-020-0315-z",
             "mag": "2741809807",
             "pmid": "https://pubmed.ncbi.nlm.nih.gov/32040050",
-            "pmcid": "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7325852"
-        },
-        "open_access": {
-            "is_oa": True,
-            "oa_url": "https://example.com/pdf"
+            "pmcid": "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7325852",
         },
+        "open_access": {"is_oa": True, "oa_url": "https://example.com/pdf"},
         "authorships": [
             {
                 "author_position": "first",
-                "author": {
-                    "id": "https://openalex.org/A1969205032",
-                    "display_name": "Giuseppe Carleo"
-                }
+                "author": {"id": "https://openalex.org/A1969205032", "display_name": "Giuseppe Carleo"},
             },
             {
                 "author_position": "middle",
-                "author": {
-                    "id": "https://openalex.org/A4356881717",
-                    "display_name": "Ignacio Cirac"
-                }
-            }
-        ]
+                "author": {"id": "https://openalex.org/A4356881717", "display_name": "Ignacio Cirac"},
+            },
+        ],
     }
 
     work = OpenAlexWork.from_api_dict(raw_api_response)
@@ -52,6 +43,7 @@ def test_parse_openalex_work_from_api_dict() -> None:
     assert work.authors[0].display_name == "Giuseppe Carleo"
     assert work.authors[1].display_name == "Ignacio Cirac"
 
+
 def test_parse_openalex_work_empty() -> None:
     work = OpenAlexWork.from_api_dict({"id": "W123"})
     assert work.openalex_id == "W123"
diff --git a/tests/unit/services/domains/openalex/test_matching.py b/tests/unit/services/domains/openalex/test_matching.py
index b8583a0..7d01d0b 100644
--- a/tests/unit/services/domains/openalex/test_matching.py
+++ b/tests/unit/services/domains/openalex/test_matching.py
@@ -1,54 +1,62 @@
-import pytest
-from app.services.domains.openalex.types import OpenAlexWork
 from app.services.domains.openalex.matching import find_best_match
+from app.services.domains.openalex.types import OpenAlexWork
+
 
 def test_find_best_match_exact_title():
     cand1 = OpenAlexWork.from_api_dict({"id": "W1", "title": "Exact Title of the Paper"})
     cand2 = OpenAlexWork.from_api_dict({"id": "W2", "title": "Totally Different Paper"})
-    
+
     match = find_best_match("Exact Title of the Paper", 2020, "Author A", [cand1, cand2])
     assert match is not None
     assert match.openalex_id == "W1"
 
+
 def test_find_best_match_fuzzy_title():
     # Only differences are punctuation or minor phrasing (e.g., matching a preprint title vs published)
     cand1 = OpenAlexWork.from_api_dict({"id": "W1", "title": "Fuzzier Title: A Study on OpenAlex"})
     cand2 = OpenAlexWork.from_api_dict({"id": "W2", "title": "Some completely unrelated work"})
-    
+
     match = find_best_match("Fuzzier Title A Study on OpenAlex", 2021, "Author B", [cand1, cand2])
     assert match is not None
     assert match.openalex_id == "W1"
 
+
 def test_find_best_match_rejects_low_score():
     cand1 = OpenAlexWork.from_api_dict({"id": "W1", "title": "Cats in hats"})
-    
+
     match = find_best_match("Dogs with logs", 2020, "Author A", [cand1])
     assert match is None
 
+
 def test_find_best_match_year_tiebreaker():
     # Both titles are very similar, one has exact year.
     cand1 = OpenAlexWork.from_api_dict({"id": "W1", "title": "The exact same title", "publication_year": 2018})
     cand2 = OpenAlexWork.from_api_dict({"id": "W2", "title": "The exact same title", "publication_year": 2020})
-    
+
     match = find_best_match("The exact same title", 2020, "Author A", [cand1, cand2])
     assert match is not None
     assert match.openalex_id == "W2"
 
+
 def test_find_best_match_author_tiebreaker():
     # Titles and years match exactly. Author overlap decides it.
-    cand1 = OpenAlexWork.from_api_dict({
-        "id": "W1", 
-        "title": "A popular title", 
-        "publication_year": 2020,
-        "authorships": [{"author": {"display_name": "Smith, J"}}]
-    })
-    cand2 = OpenAlexWork.from_api_dict({
-        "id": "W2", 
-        "title": "A popular title", 
-        "publication_year": 2020,
-        "authorships": [{"author": {"display_name": "Doe, J"}}]
-    })
-    
+    cand1 = OpenAlexWork.from_api_dict(
+        {
+            "id": "W1",
+            "title": "A popular title",
+            "publication_year": 2020,
+            "authorships": [{"author": {"display_name": "Smith, J"}}],
+        }
+    )
+    cand2 = OpenAlexWork.from_api_dict(
+        {
+            "id": "W2",
+            "title": "A popular title",
+            "publication_year": 2020,
+            "authorships": [{"author": {"display_name": "Doe, J"}}],
+        }
+    )
+
     # Target authors contains "Doe"
     match = find_best_match("A popular title", 2020, "A Einstein, J Doe", [cand1, cand2])
     assert match is not None
diff --git a/tests/unit/services/domains/publications/test_dedup.py b/tests/unit/services/domains/publications/test_dedup.py
index 1f0f4dd..d2875c3 100644
--- a/tests/unit/services/domains/publications/test_dedup.py
+++ b/tests/unit/services/domains/publications/test_dedup.py
@@ -110,12 +110,14 @@ async def test_merge_duplicate_publication_migrates_links_and_identifiers() -> N
 async def test_merge_duplicate_publication_rejects_missing_publications() -> None:
     session = AsyncMock()
 
-    with patch(
-        "app.services.domains.publications.dedup._load_publication",
-        new=AsyncMock(side_effect=[None, None]),
+    with (
+        patch(
+            "app.services.domains.publications.dedup._load_publication",
+            new=AsyncMock(side_effect=[None, None]),
+        ),
+        pytest.raises(ValueError),
     ):
-        with pytest.raises(ValueError):
-            await merge_duplicate_publication(session, winner_id=1, dup_id=2)
+        await merge_duplicate_publication(session, winner_id=1, dup_id=2)
 
 
 @pytest.mark.asyncio
diff --git a/tests/unit/test_fingerprints.py b/tests/unit/test_fingerprints.py
index f05b69d..3965c8e 100644
--- a/tests/unit/test_fingerprints.py
+++ b/tests/unit/test_fingerprints.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import pytest
-
 from app.services.domains.ingestion.fingerprints import (
     _dedupe_publication_candidates,
     canonical_title_for_dedup,
@@ -36,28 +34,40 @@ class TestFuzzyTitlesMatch:
         assert fuzzy_titles_match("Deep Learning for NLP", "deep learning for nlp") is True
 
     def test_minor_word_difference(self) -> None:
-        assert fuzzy_titles_match(
-            "A Survey on Deep Learning Methods for NLP",
-            "Survey on Deep Learning Methods for NLP",
-        ) is True
+        assert (
+            fuzzy_titles_match(
+                "A Survey on Deep Learning Methods for NLP",
+                "Survey on Deep Learning Methods for NLP",
+            )
+            is True
+        )
 
     def test_punctuation_difference(self) -> None:
-        assert fuzzy_titles_match(
-            "Attention Is All You Need",
-            "Attention Is All You Need.",
-        ) is True
+        assert (
+            fuzzy_titles_match(
+                "Attention Is All You Need",
+                "Attention Is All You Need.",
+            )
+            is True
+        )
 
     def test_colon_vs_dash_subtitle(self) -> None:
-        assert fuzzy_titles_match(
-            "Deep Learning: A Comprehensive Survey",
-            "Deep Learning - A Comprehensive Survey",
-        ) is True
+        assert (
+            fuzzy_titles_match(
+                "Deep Learning: A Comprehensive Survey",
+                "Deep Learning - A Comprehensive Survey",
+            )
+            is True
+        )
 
     def test_completely_different_titles(self) -> None:
-        assert fuzzy_titles_match(
-            "Deep Learning for NLP",
-            "Climate Change Impact on Agriculture",
-        ) is False
+        assert (
+            fuzzy_titles_match(
+                "Deep Learning for NLP",
+                "Climate Change Impact on Agriculture",
+            )
+            is False
+        )
 
     def test_short_title_no_false_positive(self) -> None:
         assert fuzzy_titles_match("On Trees", "On Forests") is False
@@ -67,16 +77,22 @@ class TestFuzzyTitlesMatch:
 
     def test_custom_threshold(self) -> None:
         # Lower threshold catches more distant matches
-        assert fuzzy_titles_match(
-            "A Survey on Deep Learning",
-            "Survey on Machine Learning Approaches",
-            threshold=0.3,
-        ) is True
+        assert (
+            fuzzy_titles_match(
+                "A Survey on Deep Learning",
+                "Survey on Machine Learning Approaches",
+                threshold=0.3,
+            )
+            is True
+        )
         # Default threshold rejects them
-        assert fuzzy_titles_match(
-            "A Survey on Deep Learning",
-            "Survey on Machine Learning Approaches",
-        ) is False
+        assert (
+            fuzzy_titles_match(
+                "A Survey on Deep Learning",
+                "Survey on Machine Learning Approaches",
+            )
+            is False
+        )
 
 
 class TestDedupePublicationCandidates:
@@ -203,27 +219,19 @@ class TestDedupePublicationCandidates:
 class TestCanonicalTitleForDedup:
     def test_strips_doi_suffix(self) -> None:
         title = "Adam: A Method for Stochastic Optimization. doi: 10.48550/arxiv.1412.6980"
-        assert canonical_title_for_dedup(title) == normalize_title(
-            "Adam: A Method for Stochastic Optimization"
-        )
+        assert canonical_title_for_dedup(title) == normalize_title("Adam: A Method for Stochastic Optimization")
 
     def test_strips_arxiv_metadata_suffix(self) -> None:
         title = "Adam: A Method for Stochastic Optimization. arXiv, Jan 29, 2017"
-        assert canonical_title_for_dedup(title) == normalize_title(
-            "Adam: A Method for Stochastic Optimization"
-        )
+        assert canonical_title_for_dedup(title) == normalize_title("Adam: A Method for Stochastic Optimization")
 
     def test_strips_preprint_parenthetical(self) -> None:
         title = "Adam: A method for stochastic optimization, preprint (2014)"
-        assert canonical_title_for_dedup(title) == normalize_title(
-            "Adam: A method for stochastic optimization"
-        )
+        assert canonical_title_for_dedup(title) == normalize_title("Adam: A method for stochastic optimization")
 
     def test_strips_venue_sentence_suffix(self) -> None:
         title = "Adam a method for stochastic optimization. Comput. Sci"
-        assert canonical_title_for_dedup(title) == normalize_title(
-            "Adam a method for stochastic optimization"
-        )
+        assert canonical_title_for_dedup(title) == normalize_title("Adam a method for stochastic optimization")
 
     def test_strips_trailing_year_in_parens(self) -> None:
         assert canonical_title_for_dedup("Deep Learning (2018)") == normalize_title("Deep Learning")
@@ -242,10 +250,7 @@ class TestCanonicalTitleForDedup:
         assert len(set(canonicals)) == 1, f"Expected one canonical, got: {canonicals}"
 
     def test_strips_mojibake_conference_suffix(self) -> None:
-        noisy = (
-            "†œAdam: A method for stochastic optimization, "
-            "†3rd Int. Conf. Learn. Represent. ICLR 2015-Conf"
-        )
+        noisy = "†œAdam: A method for stochastic optimization, †3rd Int. Conf. Learn. Represent. ICLR 2015-Conf"
         clean = "Adam: A method for stochastic optimization"
         assert canonical_title_for_dedup(noisy) == normalize_title(clean)
 
diff --git a/tests/unit/test_ingestion_arxiv_rate_limit.py b/tests/unit/test_ingestion_arxiv_rate_limit.py
index 470a59f..6f25796 100644
--- a/tests/unit/test_ingestion_arxiv_rate_limit.py
+++ b/tests/unit/test_ingestion_arxiv_rate_limit.py
@@ -31,6 +31,7 @@ async def test_discover_identifiers_for_enrichment_disables_arxiv_on_rate_limit(
         _raise_rate_limit,
     )
     monkeypatch.setattr(identifier_service, "sync_identifiers_for_publication_fields", _sync_fields)
+
     async def _publish_noop(*args, **kwargs) -> None:
         _ = (args, kwargs)
 
diff --git a/tests/unit/test_logging.py b/tests/unit/test_logging.py
index 696cb2a..a4d8d99 100644
--- a/tests/unit/test_logging.py
+++ b/tests/unit/test_logging.py
@@ -7,10 +7,10 @@ from unittest.mock import AsyncMock
 
 from fastapi.testclient import TestClient
 
+from app.http.middleware import REQUEST_ID_HEADER, parse_skip_paths
 from app.logging_config import ConsoleLogFormatter, JsonLogFormatter, parse_redact_fields
 from app.logging_utils import structured_log
 from app.main import app
-from app.http.middleware import REQUEST_ID_HEADER, parse_skip_paths
 
 
 def test_json_log_formatter_redacts_sensitive_fields() -> None:
diff --git a/tests/unit/test_publication_pdf_queue_policy.py b/tests/unit/test_publication_pdf_queue_policy.py
index 5f8cbeb..e8e1a94 100644
--- a/tests/unit/test_publication_pdf_queue_policy.py
+++ b/tests/unit/test_publication_pdf_queue_policy.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from types import SimpleNamespace
 
 import pytest
@@ -25,7 +25,9 @@ def _job(
     )
 
 
-def _row(*, pub_url: str | None = "https://scholar.google.com/citations?view_op=view_citation&citation_for_view=abc:xyz") -> SimpleNamespace:
+def _row(
+    *, pub_url: str | None = "https://scholar.google.com/citations?view_op=view_citation&citation_for_view=abc:xyz"
+) -> SimpleNamespace:
     return SimpleNamespace(
         publication_id=1,
         scholar_profile_id=1,
@@ -39,13 +41,13 @@ def _row(*, pub_url: str | None = "https://scholar.google.com/citations?view_op=
         pdf_url=None,
         is_read=False,
         is_favorite=False,
-        first_seen_at=datetime(2026, 2, 22, 12, 0, tzinfo=timezone.utc),
+        first_seen_at=datetime(2026, 2, 22, 12, 0, tzinfo=UTC),
         is_new_in_latest_run=True,
     )
 
 
 def test_pdf_queue_auto_enqueue_blocks_recent_attempt(monkeypatch: pytest.MonkeyPatch) -> None:
-    now = datetime(2026, 2, 21, 12, 0, tzinfo=timezone.utc)
+    now = datetime(2026, 2, 21, 12, 0, tzinfo=UTC)
     monkeypatch.setattr(pdf_queue, "_utcnow", lambda: now)
     monkeypatch.setattr(pdf_queue, "_auto_retry_first_interval_seconds", lambda: 3_600)
     monkeypatch.setattr(pdf_queue, "_auto_retry_interval_seconds", lambda: 86_400)
@@ -59,7 +61,7 @@ def test_pdf_queue_auto_enqueue_blocks_recent_attempt(monkeypatch: pytest.Monkey
 
 
 def test_pdf_queue_auto_enqueue_blocks_recent_first_retry(monkeypatch: pytest.MonkeyPatch) -> None:
-    now = datetime(2026, 2, 21, 12, 0, tzinfo=timezone.utc)
+    now = datetime(2026, 2, 21, 12, 0, tzinfo=UTC)
     monkeypatch.setattr(pdf_queue, "_utcnow", lambda: now)
     monkeypatch.setattr(pdf_queue, "_auto_retry_first_interval_seconds", lambda: 3_600)
     monkeypatch.setattr(pdf_queue, "_auto_retry_interval_seconds", lambda: 86_400)
@@ -73,7 +75,7 @@ def test_pdf_queue_auto_enqueue_blocks_recent_first_retry(monkeypatch: pytest.Mo
 
 
 def test_pdf_queue_auto_enqueue_blocks_after_max_attempts(monkeypatch: pytest.MonkeyPatch) -> None:
-    now = datetime(2026, 2, 21, 12, 0, tzinfo=timezone.utc)
+    now = datetime(2026, 2, 21, 12, 0, tzinfo=UTC)
     monkeypatch.setattr(pdf_queue, "_utcnow", lambda: now)
     monkeypatch.setattr(pdf_queue, "_auto_retry_first_interval_seconds", lambda: 3_600)
     monkeypatch.setattr(pdf_queue, "_auto_retry_interval_seconds", lambda: 86_400)
@@ -87,7 +89,7 @@ def test_pdf_queue_auto_enqueue_blocks_after_max_attempts(monkeypatch: pytest.Mo
 
 
 def test_pdf_queue_auto_enqueue_blocks_second_retry_within_day(monkeypatch: pytest.MonkeyPatch) -> None:
-    now = datetime(2026, 2, 21, 12, 0, tzinfo=timezone.utc)
+    now = datetime(2026, 2, 21, 12, 0, tzinfo=UTC)
     monkeypatch.setattr(pdf_queue, "_utcnow", lambda: now)
     monkeypatch.setattr(pdf_queue, "_auto_retry_first_interval_seconds", lambda: 3_600)
     monkeypatch.setattr(pdf_queue, "_auto_retry_interval_seconds", lambda: 86_400)
@@ -103,7 +105,7 @@ def test_pdf_queue_auto_enqueue_blocks_second_retry_within_day(monkeypatch: pyte
 def test_pdf_queue_manual_requeue_bypasses_cooldown_and_max_attempts(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    now = datetime(2026, 2, 21, 12, 0, tzinfo=timezone.utc)
+    now = datetime(2026, 2, 21, 12, 0, tzinfo=UTC)
     monkeypatch.setattr(pdf_queue, "_utcnow", lambda: now)
     monkeypatch.setattr(pdf_queue, "_auto_retry_first_interval_seconds", lambda: 3_600)
     monkeypatch.setattr(pdf_queue, "_auto_retry_interval_seconds", lambda: 86_400)
diff --git a/tests/unit/test_publication_pdf_resolution_pipeline.py b/tests/unit/test_publication_pdf_resolution_pipeline.py
index 9016dad..8574a5e 100644
--- a/tests/unit/test_publication_pdf_resolution_pipeline.py
+++ b/tests/unit/test_publication_pdf_resolution_pipeline.py
@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from types import SimpleNamespace
 
 import pytest
 
 from app.services.domains.arxiv.errors import ArxivRateLimitError
-from app.services.domains.publications import pdf_resolution_pipeline as pipeline
 from app.services.domains.publication_identifiers.types import DisplayIdentifier
+from app.services.domains.publications import pdf_resolution_pipeline as pipeline
 from app.services.domains.unpaywall.application import OaResolutionOutcome
 
 
@@ -25,7 +25,7 @@ def _row(*, display_identifier: DisplayIdentifier | None = None) -> SimpleNamesp
         pdf_url=None,
         is_read=False,
         is_favorite=False,
-        first_seen_at=datetime(2026, 2, 22, 12, 0, tzinfo=timezone.utc),
+        first_seen_at=datetime(2026, 2, 22, 12, 0, tzinfo=UTC),
         is_new_in_latest_run=True,
     )
 
@@ -61,7 +61,7 @@ async def test_pipeline_prefers_openalex_before_arxiv(monkeypatch: pytest.Monkey
 
     async def _fail_arxiv(row, *, request_email: str | None = None, allow_lookup: bool = True):
         _ = (row, request_email, allow_lookup)
-        raise AssertionError(f"arXiv should not run when OpenAlex candidate exists.")
+        raise AssertionError("arXiv should not run when OpenAlex candidate exists.")
 
     monkeypatch.setattr(pipeline, "_openalex_outcome", _fake_openalex)
     monkeypatch.setattr(pipeline, "_arxiv_outcome", _fail_arxiv)
diff --git a/tests/unit/test_request_delay_policy.py b/tests/unit/test_request_delay_policy.py
index f8eb767..f45039e 100644
--- a/tests/unit/test_request_delay_policy.py
+++ b/tests/unit/test_request_delay_policy.py
@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 
-from app.services.domains.ingestion.application import ScholarIngestionService
 from app.services.domains.ingestion import scheduler as scheduler_module
+from app.services.domains.ingestion.application import ScholarIngestionService
 from app.settings import settings
 
 
@@ -37,7 +37,7 @@ def test_scheduler_candidate_row_clamps_request_delay() -> None:
     try:
         candidate = scheduler_module.SchedulerService._candidate_from_row(
             (1, 15, 1, None, None),
-            now_utc=datetime(2026, 2, 21, tzinfo=timezone.utc),
+            now_utc=datetime(2026, 2, 21, tzinfo=UTC),
         )
         assert candidate is not None
         assert candidate.request_delay_seconds == 6
diff --git a/tests/unit/test_run_safety.py b/tests/unit/test_run_safety.py
index 60cd87c..81671d9 100644
--- a/tests/unit/test_run_safety.py
+++ b/tests/unit/test_run_safety.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 
 from app.db.models import UserSetting
 from app.services.domains.ingestion import safety as run_safety
@@ -8,7 +8,7 @@ from app.services.domains.ingestion import safety as run_safety
 
 def test_apply_run_safety_outcome_triggers_blocked_cooldown() -> None:
     settings = UserSetting(user_id=1, scrape_safety_state={})
-    now = datetime(2026, 2, 19, 20, 0, tzinfo=timezone.utc)
+    now = datetime(2026, 2, 19, 20, 0, tzinfo=UTC)
 
     safety_state, reason = run_safety.apply_run_safety_outcome(
         settings,
@@ -32,7 +32,7 @@ def test_apply_run_safety_outcome_triggers_blocked_cooldown() -> None:
 
 
 def test_clear_expired_cooldown() -> None:
-    now = datetime(2026, 2, 19, 20, 0, tzinfo=timezone.utc)
+    now = datetime(2026, 2, 19, 20, 0, tzinfo=UTC)
     settings = UserSetting(
         user_id=1,
         scrape_safety_state={"blocked_start_count": 3},
@@ -51,7 +51,7 @@ def test_clear_expired_cooldown() -> None:
 
 def test_apply_run_safety_outcome_triggers_network_cooldown() -> None:
     settings = UserSetting(user_id=1, scrape_safety_state={})
-    now = datetime(2026, 2, 19, 20, 0, tzinfo=timezone.utc)
+    now = datetime(2026, 2, 19, 20, 0, tzinfo=UTC)
 
     safety_state, reason = run_safety.apply_run_safety_outcome(
         settings,
@@ -75,7 +75,7 @@ def test_apply_run_safety_outcome_triggers_network_cooldown() -> None:
 
 
 def test_register_cooldown_blocked_start_increments_counter() -> None:
-    now = datetime(2026, 2, 19, 20, 0, tzinfo=timezone.utc)
+    now = datetime(2026, 2, 19, 20, 0, tzinfo=UTC)
     settings = UserSetting(
         user_id=1,
         scrape_safety_state={"blocked_start_count": 1},
@@ -91,7 +91,7 @@ def test_register_cooldown_blocked_start_increments_counter() -> None:
 
 
 def test_get_safety_event_context_contains_structured_fields() -> None:
-    now = datetime(2026, 2, 19, 20, 0, tzinfo=timezone.utc)
+    now = datetime(2026, 2, 19, 20, 0, tzinfo=UTC)
     settings = UserSetting(
         user_id=1,
         scrape_safety_state={"cooldown_entry_count": 4},
diff --git a/tests/unit/test_scholar_search_safety.py b/tests/unit/test_scholar_search_safety.py
index b3c35da..ff21c1e 100644
--- a/tests/unit/test_scholar_search_safety.py
+++ b/tests/unit/test_scholar_search_safety.py
@@ -3,9 +3,9 @@ from __future__ import annotations
 import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.services.domains.scholars import application as scholar_service
 from app.services.domains.scholar.parser import ParseState
 from app.services.domains.scholar.source import FetchResult
+from app.services.domains.scholars import application as scholar_service
 
 pytestmark = [pytest.mark.integration, pytest.mark.db]
 
@@ -51,8 +51,7 @@ def _blocked_author_search_fetch() -> FetchResult:
         requested_url="https://scholar.google.com/citations?hl=en&view_op=search_authors&mauthors=ada",
         status_code=200,
         final_url=(
-            "https://accounts.google.com/v3/signin/identifier"
-            "?continue=https%3A%2F%2Fscholar.google.com%2Fcitations"
+            "https://accounts.google.com/v3/signin/identifier?continue=https%3A%2F%2Fscholar.google.com%2Fcitations"
         ),
         body="<html><body>Sign in</body></html>",
         error=None,
diff --git a/tests/unit/test_unpaywall_pdf_discovery.py b/tests/unit/test_unpaywall_pdf_discovery.py
index 16e1c27..48270e0 100644
--- a/tests/unit/test_unpaywall_pdf_discovery.py
+++ b/tests/unit/test_unpaywall_pdf_discovery.py
@@ -61,7 +61,7 @@ class _FakeClient:
     def __init__(self, pages: dict[str, _FakeResponse]) -> None:
         self._pages = pages
 
-    async def get(self, url: str, follow_redirects: bool = True):  # noqa: ARG002
+    async def get(self, url: str, follow_redirects: bool = True):
         return self._pages[url]
 
 
@@ -69,7 +69,7 @@ class _FakeClient:
 async def test_resolve_pdf_from_landing_page_follows_one_hop_html_candidate(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    async def _skip_wait(*args, **kwargs):  # noqa: ARG001, ANN002
+    async def _skip_wait(*args, **kwargs):
         return None
 
     monkeypatch.setattr(pdf_discovery, "wait_for_unpaywall_slot", _skip_wait)
@@ -81,7 +81,7 @@ async def test_resolve_pdf_from_landing_page_follows_one_hop_html_candidate(
             landing_url: _FakeResponse(
                 status_code=200,
                 content_type="text/html",
-                text=f"<html><body><a href=\"{hop_url}\">View article</a></body></html>",
+                text=f'<html><body><a href="{hop_url}">View article</a></body></html>',
             ),
             hop_url: _FakeResponse(
                 status_code=200,
diff --git a/tests/unit/test_unpaywall_resolution.py b/tests/unit/test_unpaywall_resolution.py
index b29cc2c..6dc7481 100644
--- a/tests/unit/test_unpaywall_resolution.py
+++ b/tests/unit/test_unpaywall_resolution.py
@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 from dataclasses import replace
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 
 import pytest
 
-from app.services.domains.publications.types import PublicationListItem
 from app.services.domains.publication_identifiers.types import DisplayIdentifier
+from app.services.domains.publications.types import PublicationListItem
 from app.services.domains.unpaywall import application as unpaywall_app
 
 
@@ -35,7 +35,7 @@ def _item(publication_id: int) -> PublicationListItem:
         display_identifier=None,
         pdf_url=None,
         is_read=False,
-        first_seen_at=datetime.now(timezone.utc),
+        first_seen_at=datetime.now(UTC),
         is_new_in_latest_run=True,
     )
 
diff --git a/uv.lock b/uv.lock
index f4f139b..c151172 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 1
+revision = 3
 requires-python = ">=3.12"
 resolution-markers = [
     "python_full_version >= '3.14'",
@@ -15,18 +15,18 @@ dependencies = [
     { name = "sqlalchemy" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/94/13/8b084e0f2efb0275a1d534838844926f798bd766566b1375174e2448cd31/alembic-1.18.4.tar.gz", hash = "sha256:cb6e1fd84b6174ab8dbb2329f86d631ba9559dd78df550b57804d607672cedbc", size = 2056725 }
+sdist = { url = "https://files.pythonhosted.org/packages/94/13/8b084e0f2efb0275a1d534838844926f798bd766566b1375174e2448cd31/alembic-1.18.4.tar.gz", hash = "sha256:cb6e1fd84b6174ab8dbb2329f86d631ba9559dd78df550b57804d607672cedbc", size = 2056725, upload-time = "2026-02-10T16:00:47.195Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/29/6533c317b74f707ea28f8d633734dbda2119bbadfc61b2f3640ba835d0f7/alembic-1.18.4-py3-none-any.whl", hash = "sha256:a5ed4adcf6d8a4cb575f3d759f071b03cd6e5c7618eb796cb52497be25bfe19a", size = 263893 },
+    { url = "https://files.pythonhosted.org/packages/d2/29/6533c317b74f707ea28f8d633734dbda2119bbadfc61b2f3640ba835d0f7/alembic-1.18.4-py3-none-any.whl", hash = "sha256:a5ed4adcf6d8a4cb575f3d759f071b03cd6e5c7618eb796cb52497be25bfe19a", size = 263893, upload-time = "2026-02-10T16:00:49.997Z" },
 ]
 
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 },
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
 ]
 
 [[package]]
@@ -37,9 +37,9 @@ dependencies = [
     { name = "idna" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685 }
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592 },
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
 ]
 
 [[package]]
@@ -49,9 +49,9 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "argon2-cffi-bindings" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706 }
+sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657 },
+    { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" },
 ]
 
 [[package]]
@@ -61,70 +61,70 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cffi" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441 }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393 },
-    { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328 },
-    { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269 },
-    { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558 },
-    { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364 },
-    { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637 },
-    { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934 },
-    { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158 },
-    { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597 },
-    { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231 },
-    { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121 },
-    { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177 },
-    { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090 },
-    { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246 },
-    { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126 },
-    { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343 },
-    { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777 },
-    { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180 },
-    { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715 },
-    { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149 },
+    { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393, upload-time = "2025-07-30T10:01:40.97Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328, upload-time = "2025-07-30T10:01:41.916Z" },
+    { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269, upload-time = "2025-07-30T10:01:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558, upload-time = "2025-07-30T10:01:43.943Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364, upload-time = "2025-07-30T10:01:44.887Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637, upload-time = "2025-07-30T10:01:46.225Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934, upload-time = "2025-07-30T10:01:47.203Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158, upload-time = "2025-07-30T10:01:48.341Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597, upload-time = "2025-07-30T10:01:49.112Z" },
+    { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231, upload-time = "2025-07-30T10:01:49.92Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121, upload-time = "2025-07-30T10:01:50.815Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177, upload-time = "2025-07-30T10:01:51.681Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090, upload-time = "2025-07-30T10:01:53.184Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246, upload-time = "2025-07-30T10:01:54.145Z" },
+    { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126, upload-time = "2025-07-30T10:01:55.074Z" },
+    { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343, upload-time = "2025-07-30T10:01:56.007Z" },
+    { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777, upload-time = "2025-07-30T10:01:56.943Z" },
+    { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180, upload-time = "2025-07-30T10:01:57.759Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715, upload-time = "2025-07-30T10:01:58.56Z" },
+    { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" },
 ]
 
 [[package]]
 name = "asttokens"
 version = "3.0.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308 }
+sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047 },
+    { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" },
 ]
 
 [[package]]
 name = "asyncpg"
 version = "0.30.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2f/4c/7c991e080e106d854809030d8584e15b2e996e26f16aee6d757e387bc17d/asyncpg-0.30.0.tar.gz", hash = "sha256:c551e9928ab6707602f44811817f82ba3c446e018bfe1d3abecc8ba5f3eac851", size = 957746 }
+sdist = { url = "https://files.pythonhosted.org/packages/2f/4c/7c991e080e106d854809030d8584e15b2e996e26f16aee6d757e387bc17d/asyncpg-0.30.0.tar.gz", hash = "sha256:c551e9928ab6707602f44811817f82ba3c446e018bfe1d3abecc8ba5f3eac851", size = 957746, upload-time = "2024-10-20T00:30:41.127Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4b/64/9d3e887bb7b01535fdbc45fbd5f0a8447539833b97ee69ecdbb7a79d0cb4/asyncpg-0.30.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c902a60b52e506d38d7e80e0dd5399f657220f24635fee368117b8b5fce1142e", size = 673162 },
-    { url = "https://files.pythonhosted.org/packages/6e/eb/8b236663f06984f212a087b3e849731f917ab80f84450e943900e8ca4052/asyncpg-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aca1548e43bbb9f0f627a04666fedaca23db0a31a84136ad1f868cb15deb6e3a", size = 637025 },
-    { url = "https://files.pythonhosted.org/packages/cc/57/2dc240bb263d58786cfaa60920779af6e8d32da63ab9ffc09f8312bd7a14/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c2a2ef565400234a633da0eafdce27e843836256d40705d83ab7ec42074efb3", size = 3496243 },
-    { url = "https://files.pythonhosted.org/packages/f4/40/0ae9d061d278b10713ea9021ef6b703ec44698fe32178715a501ac696c6b/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1292b84ee06ac8a2ad8e51c7475aa309245874b61333d97411aab835c4a2f737", size = 3575059 },
-    { url = "https://files.pythonhosted.org/packages/c3/75/d6b895a35a2c6506952247640178e5f768eeb28b2e20299b6a6f1d743ba0/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0f5712350388d0cd0615caec629ad53c81e506b1abaaf8d14c93f54b35e3595a", size = 3473596 },
-    { url = "https://files.pythonhosted.org/packages/c8/e7/3693392d3e168ab0aebb2d361431375bd22ffc7b4a586a0fc060d519fae7/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:db9891e2d76e6f425746c5d2da01921e9a16b5a71a1c905b13f30e12a257c4af", size = 3641632 },
-    { url = "https://files.pythonhosted.org/packages/32/ea/15670cea95745bba3f0352341db55f506a820b21c619ee66b7d12ea7867d/asyncpg-0.30.0-cp312-cp312-win32.whl", hash = "sha256:68d71a1be3d83d0570049cd1654a9bdfe506e794ecc98ad0873304a9f35e411e", size = 560186 },
-    { url = "https://files.pythonhosted.org/packages/7e/6b/fe1fad5cee79ca5f5c27aed7bd95baee529c1bf8a387435c8ba4fe53d5c1/asyncpg-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:9a0292c6af5c500523949155ec17b7fe01a00ace33b68a476d6b5059f9630305", size = 621064 },
-    { url = "https://files.pythonhosted.org/packages/3a/22/e20602e1218dc07692acf70d5b902be820168d6282e69ef0d3cb920dc36f/asyncpg-0.30.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05b185ebb8083c8568ea8a40e896d5f7af4b8554b64d7719c0eaa1eb5a5c3a70", size = 670373 },
-    { url = "https://files.pythonhosted.org/packages/3d/b3/0cf269a9d647852a95c06eb00b815d0b95a4eb4b55aa2d6ba680971733b9/asyncpg-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c47806b1a8cbb0a0db896f4cd34d89942effe353a5035c62734ab13b9f938da3", size = 634745 },
-    { url = "https://files.pythonhosted.org/packages/8e/6d/a4f31bf358ce8491d2a31bfe0d7bcf25269e80481e49de4d8616c4295a34/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b6fde867a74e8c76c71e2f64f80c64c0f3163e687f1763cfaf21633ec24ec33", size = 3512103 },
-    { url = "https://files.pythonhosted.org/packages/96/19/139227a6e67f407b9c386cb594d9628c6c78c9024f26df87c912fabd4368/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46973045b567972128a27d40001124fbc821c87a6cade040cfcd4fa8a30bcdc4", size = 3592471 },
-    { url = "https://files.pythonhosted.org/packages/67/e4/ab3ca38f628f53f0fd28d3ff20edff1c975dd1cb22482e0061916b4b9a74/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9110df111cabc2ed81aad2f35394a00cadf4f2e0635603db6ebbd0fc896f46a4", size = 3496253 },
-    { url = "https://files.pythonhosted.org/packages/ef/5f/0bf65511d4eeac3a1f41c54034a492515a707c6edbc642174ae79034d3ba/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04ff0785ae7eed6cc138e73fc67b8e51d54ee7a3ce9b63666ce55a0bf095f7ba", size = 3662720 },
-    { url = "https://files.pythonhosted.org/packages/e7/31/1513d5a6412b98052c3ed9158d783b1e09d0910f51fbe0e05f56cc370bc4/asyncpg-0.30.0-cp313-cp313-win32.whl", hash = "sha256:ae374585f51c2b444510cdf3595b97ece4f233fde739aa14b50e0d64e8a7a590", size = 560404 },
-    { url = "https://files.pythonhosted.org/packages/c8/a4/cec76b3389c4c5ff66301cd100fe88c318563ec8a520e0b2e792b5b84972/asyncpg-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:f59b430b8e27557c3fb9869222559f7417ced18688375825f8f12302c34e915e", size = 621623 },
+    { url = "https://files.pythonhosted.org/packages/4b/64/9d3e887bb7b01535fdbc45fbd5f0a8447539833b97ee69ecdbb7a79d0cb4/asyncpg-0.30.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c902a60b52e506d38d7e80e0dd5399f657220f24635fee368117b8b5fce1142e", size = 673162, upload-time = "2024-10-20T00:29:41.88Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/eb/8b236663f06984f212a087b3e849731f917ab80f84450e943900e8ca4052/asyncpg-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aca1548e43bbb9f0f627a04666fedaca23db0a31a84136ad1f868cb15deb6e3a", size = 637025, upload-time = "2024-10-20T00:29:43.352Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/57/2dc240bb263d58786cfaa60920779af6e8d32da63ab9ffc09f8312bd7a14/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c2a2ef565400234a633da0eafdce27e843836256d40705d83ab7ec42074efb3", size = 3496243, upload-time = "2024-10-20T00:29:44.922Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/40/0ae9d061d278b10713ea9021ef6b703ec44698fe32178715a501ac696c6b/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1292b84ee06ac8a2ad8e51c7475aa309245874b61333d97411aab835c4a2f737", size = 3575059, upload-time = "2024-10-20T00:29:46.891Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/75/d6b895a35a2c6506952247640178e5f768eeb28b2e20299b6a6f1d743ba0/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0f5712350388d0cd0615caec629ad53c81e506b1abaaf8d14c93f54b35e3595a", size = 3473596, upload-time = "2024-10-20T00:29:49.201Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/e7/3693392d3e168ab0aebb2d361431375bd22ffc7b4a586a0fc060d519fae7/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:db9891e2d76e6f425746c5d2da01921e9a16b5a71a1c905b13f30e12a257c4af", size = 3641632, upload-time = "2024-10-20T00:29:50.768Z" },
+    { url = "https://files.pythonhosted.org/packages/32/ea/15670cea95745bba3f0352341db55f506a820b21c619ee66b7d12ea7867d/asyncpg-0.30.0-cp312-cp312-win32.whl", hash = "sha256:68d71a1be3d83d0570049cd1654a9bdfe506e794ecc98ad0873304a9f35e411e", size = 560186, upload-time = "2024-10-20T00:29:52.394Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/6b/fe1fad5cee79ca5f5c27aed7bd95baee529c1bf8a387435c8ba4fe53d5c1/asyncpg-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:9a0292c6af5c500523949155ec17b7fe01a00ace33b68a476d6b5059f9630305", size = 621064, upload-time = "2024-10-20T00:29:53.757Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/22/e20602e1218dc07692acf70d5b902be820168d6282e69ef0d3cb920dc36f/asyncpg-0.30.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05b185ebb8083c8568ea8a40e896d5f7af4b8554b64d7719c0eaa1eb5a5c3a70", size = 670373, upload-time = "2024-10-20T00:29:55.165Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/b3/0cf269a9d647852a95c06eb00b815d0b95a4eb4b55aa2d6ba680971733b9/asyncpg-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c47806b1a8cbb0a0db896f4cd34d89942effe353a5035c62734ab13b9f938da3", size = 634745, upload-time = "2024-10-20T00:29:57.14Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/6d/a4f31bf358ce8491d2a31bfe0d7bcf25269e80481e49de4d8616c4295a34/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b6fde867a74e8c76c71e2f64f80c64c0f3163e687f1763cfaf21633ec24ec33", size = 3512103, upload-time = "2024-10-20T00:29:58.499Z" },
+    { url = "https://files.pythonhosted.org/packages/96/19/139227a6e67f407b9c386cb594d9628c6c78c9024f26df87c912fabd4368/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46973045b567972128a27d40001124fbc821c87a6cade040cfcd4fa8a30bcdc4", size = 3592471, upload-time = "2024-10-20T00:30:00.354Z" },
+    { url = "https://files.pythonhosted.org/packages/67/e4/ab3ca38f628f53f0fd28d3ff20edff1c975dd1cb22482e0061916b4b9a74/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9110df111cabc2ed81aad2f35394a00cadf4f2e0635603db6ebbd0fc896f46a4", size = 3496253, upload-time = "2024-10-20T00:30:02.794Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/5f/0bf65511d4eeac3a1f41c54034a492515a707c6edbc642174ae79034d3ba/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04ff0785ae7eed6cc138e73fc67b8e51d54ee7a3ce9b63666ce55a0bf095f7ba", size = 3662720, upload-time = "2024-10-20T00:30:04.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/31/1513d5a6412b98052c3ed9158d783b1e09d0910f51fbe0e05f56cc370bc4/asyncpg-0.30.0-cp313-cp313-win32.whl", hash = "sha256:ae374585f51c2b444510cdf3595b97ece4f233fde739aa14b50e0d64e8a7a590", size = 560404, upload-time = "2024-10-20T00:30:06.537Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/a4/cec76b3389c4c5ff66301cd100fe88c318563ec8a520e0b2e792b5b84972/asyncpg-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:f59b430b8e27557c3fb9869222559f7417ced18688375825f8f12302c34e915e", size = 621623, upload-time = "2024-10-20T00:30:09.024Z" },
 ]
 
 [[package]]
 name = "certifi"
 version = "2026.1.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268 }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900 },
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
 ]
 
 [[package]]
@@ -134,111 +134,111 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pycparser", marker = "implementation_name != 'PyPy'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588 }
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271 },
-    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048 },
-    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529 },
-    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097 },
-    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983 },
-    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519 },
-    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572 },
-    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963 },
-    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361 },
-    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932 },
-    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557 },
-    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762 },
-    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230 },
-    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043 },
-    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446 },
-    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101 },
-    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948 },
-    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422 },
-    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499 },
-    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928 },
-    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302 },
-    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909 },
-    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402 },
-    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780 },
-    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320 },
-    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487 },
-    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049 },
-    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793 },
-    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300 },
-    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244 },
-    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828 },
-    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926 },
-    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328 },
-    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650 },
-    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687 },
-    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773 },
-    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013 },
-    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593 },
-    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354 },
-    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480 },
-    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584 },
-    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443 },
-    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437 },
-    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487 },
-    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726 },
-    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195 },
+    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },
+    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
+    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
+    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
 ]
 
 [[package]]
 name = "charset-normalizer"
 version = "3.4.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418 }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425 },
-    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162 },
-    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558 },
-    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497 },
-    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240 },
-    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471 },
-    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864 },
-    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647 },
-    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110 },
-    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839 },
-    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667 },
-    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535 },
-    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816 },
-    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694 },
-    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131 },
-    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390 },
-    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091 },
-    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936 },
-    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180 },
-    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346 },
-    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874 },
-    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076 },
-    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601 },
-    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376 },
-    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825 },
-    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583 },
-    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366 },
-    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300 },
-    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465 },
-    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404 },
-    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092 },
-    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408 },
-    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746 },
-    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889 },
-    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641 },
-    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779 },
-    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035 },
-    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542 },
-    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524 },
-    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395 },
-    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680 },
-    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045 },
-    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687 },
-    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014 },
-    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044 },
-    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940 },
-    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104 },
-    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743 },
-    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402 },
+    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" },
+    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" },
+    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" },
+    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" },
+    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" },
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
 ]
 
 [[package]]
@@ -248,18 +248,18 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065 }
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274 },
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
 ]
 
 [[package]]
 name = "colorama"
 version = "0.4.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
 ]
 
 [[package]]
@@ -271,27 +271,27 @@ dependencies = [
     { name = "requests" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f7/c7/bd020af76301bfede41869b3c18f3efb6fac7dd064371d2a9956bc3306c4/crossrefapi-1.7.0.tar.gz", hash = "sha256:598f27a3cc1bd8d29770de284b0b1315c820de1d70894084945d5265e6fe2dae", size = 13444 }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/c7/bd020af76301bfede41869b3c18f3efb6fac7dd064371d2a9956bc3306c4/crossrefapi-1.7.0.tar.gz", hash = "sha256:598f27a3cc1bd8d29770de284b0b1315c820de1d70894084945d5265e6fe2dae", size = 13444, upload-time = "2025-07-03T20:39:49.223Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ab/de/58f53b61330e74b8d1401abb448c27027fb66ca14556a120248fc3ff84b0/crossrefapi-1.7.0-py3-none-any.whl", hash = "sha256:577919e26727651a546dfb94781fc0f24b05fe0d05a62f8e49dba87c4bb7f87e", size = 14652 },
+    { url = "https://files.pythonhosted.org/packages/ab/de/58f53b61330e74b8d1401abb448c27027fb66ca14556a120248fc3ff84b0/crossrefapi-1.7.0-py3-none-any.whl", hash = "sha256:577919e26727651a546dfb94781fc0f24b05fe0d05a62f8e49dba87c4bb7f87e", size = 14652, upload-time = "2025-07-03T20:39:48.059Z" },
 ]
 
 [[package]]
 name = "decorator"
 version = "5.2.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711 }
+sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190 },
+    { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" },
 ]
 
 [[package]]
 name = "executing"
 version = "2.2.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488 }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317 },
+    { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" },
 ]
 
 [[package]]
@@ -303,61 +303,57 @@ dependencies = [
     { name = "starlette" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/01/64/1296f46d6b9e3b23fb22e5d01af3f104ef411425531376212f1eefa2794d/fastapi-0.116.2.tar.gz", hash = "sha256:231a6af2fe21cfa2c32730170ad8514985fc250bec16c9b242d3b94c835ef529", size = 298595 }
+sdist = { url = "https://files.pythonhosted.org/packages/01/64/1296f46d6b9e3b23fb22e5d01af3f104ef411425531376212f1eefa2794d/fastapi-0.116.2.tar.gz", hash = "sha256:231a6af2fe21cfa2c32730170ad8514985fc250bec16c9b242d3b94c835ef529", size = 298595, upload-time = "2025-09-16T18:29:23.058Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/32/e4/c543271a8018874b7f682bf6156863c416e1334b8ed3e51a69495c5d4360/fastapi-0.116.2-py3-none-any.whl", hash = "sha256:c3a7a8fb830b05f7e087d920e0d786ca1fc9892eb4e9a84b227be4c1bc7569db", size = 95670 },
+    { url = "https://files.pythonhosted.org/packages/32/e4/c543271a8018874b7f682bf6156863c416e1334b8ed3e51a69495c5d4360/fastapi-0.116.2-py3-none-any.whl", hash = "sha256:c3a7a8fb830b05f7e087d920e0d786ca1fc9892eb4e9a84b227be4c1bc7569db", size = 95670, upload-time = "2025-09-16T18:29:21.329Z" },
 ]
 
 [[package]]
 name = "greenlet"
 version = "3.3.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/8a/99/1cd3411c56a410994669062bd73dd58270c00cc074cac15f385a1fd91f8a/greenlet-3.3.1.tar.gz", hash = "sha256:41848f3230b58c08bb43dee542e74a2a2e34d3c59dc3076cec9151aeeedcae98", size = 184690 }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/99/1cd3411c56a410994669062bd73dd58270c00cc074cac15f385a1fd91f8a/greenlet-3.3.1.tar.gz", hash = "sha256:41848f3230b58c08bb43dee542e74a2a2e34d3c59dc3076cec9151aeeedcae98", size = 184690, upload-time = "2026-01-23T15:31:02.076Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f9/c8/9d76a66421d1ae24340dfae7e79c313957f6e3195c144d2c73333b5bfe34/greenlet-3.3.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7e806ca53acf6d15a888405880766ec84721aa4181261cd11a457dfe9a7a4975", size = 276443 },
-    { url = "https://files.pythonhosted.org/packages/81/99/401ff34bb3c032d1f10477d199724f5e5f6fbfb59816ad1455c79c1eb8e7/greenlet-3.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d842c94b9155f1c9b3058036c24ffb8ff78b428414a19792b2380be9cecf4f36", size = 597359 },
-    { url = "https://files.pythonhosted.org/packages/2b/bc/4dcc0871ed557792d304f50be0f7487a14e017952ec689effe2180a6ff35/greenlet-3.3.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:20fedaadd422fa02695f82093f9a98bad3dab5fcda793c658b945fcde2ab27ba", size = 607805 },
-    { url = "https://files.pythonhosted.org/packages/3b/cd/7a7ca57588dac3389e97f7c9521cb6641fd8b6602faf1eaa4188384757df/greenlet-3.3.1-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c620051669fd04ac6b60ebc70478210119c56e2d5d5df848baec4312e260e4ca", size = 622363 },
-    { url = "https://files.pythonhosted.org/packages/cf/05/821587cf19e2ce1f2b24945d890b164401e5085f9d09cbd969b0c193cd20/greenlet-3.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14194f5f4305800ff329cbf02c5fcc88f01886cadd29941b807668a45f0d2336", size = 609947 },
-    { url = "https://files.pythonhosted.org/packages/a4/52/ee8c46ed9f8babaa93a19e577f26e3d28a519feac6350ed6f25f1afee7e9/greenlet-3.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7b2fe4150a0cf59f847a67db8c155ac36aed89080a6a639e9f16df5d6c6096f1", size = 1567487 },
-    { url = "https://files.pythonhosted.org/packages/8f/7c/456a74f07029597626f3a6db71b273a3632aecb9afafeeca452cfa633197/greenlet-3.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49f4ad195d45f4a66a0eb9c1ba4832bb380570d361912fa3554746830d332149", size = 1636087 },
-    { url = "https://files.pythonhosted.org/packages/34/2f/5e0e41f33c69655300a5e54aeb637cf8ff57f1786a3aba374eacc0228c1d/greenlet-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cc98b9c4e4870fa983436afa999d4eb16b12872fab7071423d5262fa7120d57a", size = 227156 },
-    { url = "https://files.pythonhosted.org/packages/c8/ab/717c58343cf02c5265b531384b248787e04d8160b8afe53d9eec053d7b44/greenlet-3.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bfb2d1763d777de5ee495c85309460f6fd8146e50ec9d0ae0183dbf6f0a829d1", size = 226403 },
-    { url = "https://files.pythonhosted.org/packages/ec/ab/d26750f2b7242c2b90ea2ad71de70cfcd73a948a49513188a0fc0d6fc15a/greenlet-3.3.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:7ab327905cabb0622adca5971e488064e35115430cec2c35a50fd36e72a315b3", size = 275205 },
-    { url = "https://files.pythonhosted.org/packages/10/d3/be7d19e8fad7c5a78eeefb2d896a08cd4643e1e90c605c4be3b46264998f/greenlet-3.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65be2f026ca6a176f88fb935ee23c18333ccea97048076aef4db1ef5bc0713ac", size = 599284 },
-    { url = "https://files.pythonhosted.org/packages/ae/21/fe703aaa056fdb0f17e5afd4b5c80195bbdab701208918938bd15b00d39b/greenlet-3.3.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7a3ae05b3d225b4155bda56b072ceb09d05e974bc74be6c3fc15463cf69f33fd", size = 610274 },
-    { url = "https://files.pythonhosted.org/packages/06/00/95df0b6a935103c0452dad2203f5be8377e551b8466a29650c4c5a5af6cc/greenlet-3.3.1-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:12184c61e5d64268a160226fb4818af4df02cfead8379d7f8b99a56c3a54ff3e", size = 624375 },
-    { url = "https://files.pythonhosted.org/packages/cb/86/5c6ab23bb3c28c21ed6bebad006515cfe08b04613eb105ca0041fecca852/greenlet-3.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6423481193bbbe871313de5fd06a082f2649e7ce6e08015d2a76c1e9186ca5b3", size = 612904 },
-    { url = "https://files.pythonhosted.org/packages/c2/f3/7949994264e22639e40718c2daf6f6df5169bf48fb038c008a489ec53a50/greenlet-3.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:33a956fe78bbbda82bfc95e128d61129b32d66bcf0a20a1f0c08aa4839ffa951", size = 1567316 },
-    { url = "https://files.pythonhosted.org/packages/8d/6e/d73c94d13b6465e9f7cd6231c68abde838bb22408596c05d9059830b7872/greenlet-3.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b065d3284be43728dd280f6f9a13990b56470b81be20375a207cdc814a983f2", size = 1636549 },
-    { url = "https://files.pythonhosted.org/packages/5e/b3/c9c23a6478b3bcc91f979ce4ca50879e4d0b2bd7b9a53d8ecded719b92e2/greenlet-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:27289986f4e5b0edec7b5a91063c109f0276abb09a7e9bdab08437525977c946", size = 227042 },
-    { url = "https://files.pythonhosted.org/packages/90/e7/824beda656097edee36ab15809fd063447b200cc03a7f6a24c34d520bc88/greenlet-3.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:2f080e028001c5273e0b42690eaf359aeef9cb1389da0f171ea51a5dc3c7608d", size = 226294 },
-    { url = "https://files.pythonhosted.org/packages/ae/fb/011c7c717213182caf78084a9bea51c8590b0afda98001f69d9f853a495b/greenlet-3.3.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:bd59acd8529b372775cd0fcbc5f420ae20681c5b045ce25bd453ed8455ab99b5", size = 275737 },
-    { url = "https://files.pythonhosted.org/packages/41/2e/a3a417d620363fdbb08a48b1dd582956a46a61bf8fd27ee8164f9dfe87c2/greenlet-3.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b31c05dd84ef6871dd47120386aed35323c944d86c3d91a17c4b8d23df62f15b", size = 646422 },
-    { url = "https://files.pythonhosted.org/packages/b4/09/c6c4a0db47defafd2d6bab8ddfe47ad19963b4e30f5bed84d75328059f8c/greenlet-3.3.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02925a0bfffc41e542c70aa14c7eda3593e4d7e274bfcccca1827e6c0875902e", size = 658219 },
-    { url = "https://files.pythonhosted.org/packages/e2/89/b95f2ddcc5f3c2bc09c8ee8d77be312df7f9e7175703ab780f2014a0e781/greenlet-3.3.1-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3e0f3878ca3a3ff63ab4ea478585942b53df66ddde327b59ecb191b19dbbd62d", size = 671455 },
-    { url = "https://files.pythonhosted.org/packages/80/38/9d42d60dffb04b45f03dbab9430898352dba277758640751dc5cc316c521/greenlet-3.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34a729e2e4e4ffe9ae2408d5ecaf12f944853f40ad724929b7585bca808a9d6f", size = 660237 },
-    { url = "https://files.pythonhosted.org/packages/96/61/373c30b7197f9e756e4c81ae90a8d55dc3598c17673f91f4d31c3c689c3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aec9ab04e82918e623415947921dea15851b152b822661cce3f8e4393c3df683", size = 1615261 },
-    { url = "https://files.pythonhosted.org/packages/fd/d3/ca534310343f5945316f9451e953dcd89b36fe7a19de652a1dc5a0eeef3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71c767cf281a80d02b6c1bdc41c9468e1f5a494fb11bc8688c360524e273d7b1", size = 1683719 },
-    { url = "https://files.pythonhosted.org/packages/52/cb/c21a3fd5d2c9c8b622e7bede6d6d00e00551a5ee474ea6d831b5f567a8b4/greenlet-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:96aff77af063b607f2489473484e39a0bbae730f2ea90c9e5606c9b73c44174a", size = 228125 },
-    { url = "https://files.pythonhosted.org/packages/6a/8e/8a2db6d11491837af1de64b8aff23707c6e85241be13c60ed399a72e2ef8/greenlet-3.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:b066e8b50e28b503f604fa538adc764a638b38cf8e81e025011d26e8a627fa79", size = 227519 },
-    { url = "https://files.pythonhosted.org/packages/28/24/cbbec49bacdcc9ec652a81d3efef7b59f326697e7edf6ed775a5e08e54c2/greenlet-3.3.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:3e63252943c921b90abb035ebe9de832c436401d9c45f262d80e2d06cc659242", size = 282706 },
-    { url = "https://files.pythonhosted.org/packages/86/2e/4f2b9323c144c4fe8842a4e0d92121465485c3c2c5b9e9b30a52e80f523f/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76e39058e68eb125de10c92524573924e827927df5d3891fbc97bd55764a8774", size = 651209 },
-    { url = "https://files.pythonhosted.org/packages/d9/87/50ca60e515f5bb55a2fbc5f0c9b5b156de7d2fc51a0a69abc9d23914a237/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9f9d5e7a9310b7a2f416dd13d2e3fd8b42d803968ea580b7c0f322ccb389b97", size = 654300 },
-    { url = "https://files.pythonhosted.org/packages/7c/25/c51a63f3f463171e09cb586eb64db0861eb06667ab01a7968371a24c4f3b/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b9721549a95db96689458a1e0ae32412ca18776ed004463df3a9299c1b257ab", size = 662574 },
-    { url = "https://files.pythonhosted.org/packages/1d/94/74310866dfa2b73dd08659a3d18762f83985ad3281901ba0ee9a815194fb/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92497c78adf3ac703b57f1e3813c2d874f27f71a178f9ea5887855da413cd6d2", size = 653842 },
-    { url = "https://files.pythonhosted.org/packages/97/43/8bf0ffa3d498eeee4c58c212a3905dd6146c01c8dc0b0a046481ca29b18c/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ed6b402bc74d6557a705e197d47f9063733091ed6357b3de33619d8a8d93ac53", size = 1614917 },
-    { url = "https://files.pythonhosted.org/packages/89/90/a3be7a5f378fc6e84abe4dcfb2ba32b07786861172e502388b4c90000d1b/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:59913f1e5ada20fde795ba906916aea25d442abcc0593fba7e26c92b7ad76249", size = 1676092 },
-    { url = "https://files.pythonhosted.org/packages/e1/2b/98c7f93e6db9977aaee07eb1e51ca63bd5f779b900d362791d3252e60558/greenlet-3.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:301860987846c24cb8964bdec0e31a96ad4a2a801b41b4ef40963c1b44f33451", size = 233181 },
+    { url = "https://files.pythonhosted.org/packages/f9/c8/9d76a66421d1ae24340dfae7e79c313957f6e3195c144d2c73333b5bfe34/greenlet-3.3.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7e806ca53acf6d15a888405880766ec84721aa4181261cd11a457dfe9a7a4975", size = 276443, upload-time = "2026-01-23T15:30:10.066Z" },
+    { url = "https://files.pythonhosted.org/packages/81/99/401ff34bb3c032d1f10477d199724f5e5f6fbfb59816ad1455c79c1eb8e7/greenlet-3.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d842c94b9155f1c9b3058036c24ffb8ff78b428414a19792b2380be9cecf4f36", size = 597359, upload-time = "2026-01-23T16:00:57.394Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/bc/4dcc0871ed557792d304f50be0f7487a14e017952ec689effe2180a6ff35/greenlet-3.3.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:20fedaadd422fa02695f82093f9a98bad3dab5fcda793c658b945fcde2ab27ba", size = 607805, upload-time = "2026-01-23T16:05:28.068Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/05/821587cf19e2ce1f2b24945d890b164401e5085f9d09cbd969b0c193cd20/greenlet-3.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14194f5f4305800ff329cbf02c5fcc88f01886cadd29941b807668a45f0d2336", size = 609947, upload-time = "2026-01-23T15:32:51.004Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/52/ee8c46ed9f8babaa93a19e577f26e3d28a519feac6350ed6f25f1afee7e9/greenlet-3.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7b2fe4150a0cf59f847a67db8c155ac36aed89080a6a639e9f16df5d6c6096f1", size = 1567487, upload-time = "2026-01-23T16:04:22.125Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/7c/456a74f07029597626f3a6db71b273a3632aecb9afafeeca452cfa633197/greenlet-3.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49f4ad195d45f4a66a0eb9c1ba4832bb380570d361912fa3554746830d332149", size = 1636087, upload-time = "2026-01-23T15:33:47.486Z" },
+    { url = "https://files.pythonhosted.org/packages/34/2f/5e0e41f33c69655300a5e54aeb637cf8ff57f1786a3aba374eacc0228c1d/greenlet-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cc98b9c4e4870fa983436afa999d4eb16b12872fab7071423d5262fa7120d57a", size = 227156, upload-time = "2026-01-23T15:34:34.808Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/ab/717c58343cf02c5265b531384b248787e04d8160b8afe53d9eec053d7b44/greenlet-3.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bfb2d1763d777de5ee495c85309460f6fd8146e50ec9d0ae0183dbf6f0a829d1", size = 226403, upload-time = "2026-01-23T15:31:39.372Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/ab/d26750f2b7242c2b90ea2ad71de70cfcd73a948a49513188a0fc0d6fc15a/greenlet-3.3.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:7ab327905cabb0622adca5971e488064e35115430cec2c35a50fd36e72a315b3", size = 275205, upload-time = "2026-01-23T15:30:24.556Z" },
+    { url = "https://files.pythonhosted.org/packages/10/d3/be7d19e8fad7c5a78eeefb2d896a08cd4643e1e90c605c4be3b46264998f/greenlet-3.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65be2f026ca6a176f88fb935ee23c18333ccea97048076aef4db1ef5bc0713ac", size = 599284, upload-time = "2026-01-23T16:00:58.584Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/21/fe703aaa056fdb0f17e5afd4b5c80195bbdab701208918938bd15b00d39b/greenlet-3.3.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7a3ae05b3d225b4155bda56b072ceb09d05e974bc74be6c3fc15463cf69f33fd", size = 610274, upload-time = "2026-01-23T16:05:29.312Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/86/5c6ab23bb3c28c21ed6bebad006515cfe08b04613eb105ca0041fecca852/greenlet-3.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6423481193bbbe871313de5fd06a082f2649e7ce6e08015d2a76c1e9186ca5b3", size = 612904, upload-time = "2026-01-23T15:32:52.317Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/f3/7949994264e22639e40718c2daf6f6df5169bf48fb038c008a489ec53a50/greenlet-3.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:33a956fe78bbbda82bfc95e128d61129b32d66bcf0a20a1f0c08aa4839ffa951", size = 1567316, upload-time = "2026-01-23T16:04:23.316Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/6e/d73c94d13b6465e9f7cd6231c68abde838bb22408596c05d9059830b7872/greenlet-3.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b065d3284be43728dd280f6f9a13990b56470b81be20375a207cdc814a983f2", size = 1636549, upload-time = "2026-01-23T15:33:48.643Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/b3/c9c23a6478b3bcc91f979ce4ca50879e4d0b2bd7b9a53d8ecded719b92e2/greenlet-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:27289986f4e5b0edec7b5a91063c109f0276abb09a7e9bdab08437525977c946", size = 227042, upload-time = "2026-01-23T15:33:58.216Z" },
+    { url = "https://files.pythonhosted.org/packages/90/e7/824beda656097edee36ab15809fd063447b200cc03a7f6a24c34d520bc88/greenlet-3.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:2f080e028001c5273e0b42690eaf359aeef9cb1389da0f171ea51a5dc3c7608d", size = 226294, upload-time = "2026-01-23T15:30:52.73Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/fb/011c7c717213182caf78084a9bea51c8590b0afda98001f69d9f853a495b/greenlet-3.3.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:bd59acd8529b372775cd0fcbc5f420ae20681c5b045ce25bd453ed8455ab99b5", size = 275737, upload-time = "2026-01-23T15:32:16.889Z" },
+    { url = "https://files.pythonhosted.org/packages/41/2e/a3a417d620363fdbb08a48b1dd582956a46a61bf8fd27ee8164f9dfe87c2/greenlet-3.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b31c05dd84ef6871dd47120386aed35323c944d86c3d91a17c4b8d23df62f15b", size = 646422, upload-time = "2026-01-23T16:01:00.354Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/09/c6c4a0db47defafd2d6bab8ddfe47ad19963b4e30f5bed84d75328059f8c/greenlet-3.3.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02925a0bfffc41e542c70aa14c7eda3593e4d7e274bfcccca1827e6c0875902e", size = 658219, upload-time = "2026-01-23T16:05:30.956Z" },
+    { url = "https://files.pythonhosted.org/packages/80/38/9d42d60dffb04b45f03dbab9430898352dba277758640751dc5cc316c521/greenlet-3.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34a729e2e4e4ffe9ae2408d5ecaf12f944853f40ad724929b7585bca808a9d6f", size = 660237, upload-time = "2026-01-23T15:32:53.967Z" },
+    { url = "https://files.pythonhosted.org/packages/96/61/373c30b7197f9e756e4c81ae90a8d55dc3598c17673f91f4d31c3c689c3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aec9ab04e82918e623415947921dea15851b152b822661cce3f8e4393c3df683", size = 1615261, upload-time = "2026-01-23T16:04:25.066Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d3/ca534310343f5945316f9451e953dcd89b36fe7a19de652a1dc5a0eeef3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71c767cf281a80d02b6c1bdc41c9468e1f5a494fb11bc8688c360524e273d7b1", size = 1683719, upload-time = "2026-01-23T15:33:50.61Z" },
+    { url = "https://files.pythonhosted.org/packages/52/cb/c21a3fd5d2c9c8b622e7bede6d6d00e00551a5ee474ea6d831b5f567a8b4/greenlet-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:96aff77af063b607f2489473484e39a0bbae730f2ea90c9e5606c9b73c44174a", size = 228125, upload-time = "2026-01-23T15:32:45.265Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/8e/8a2db6d11491837af1de64b8aff23707c6e85241be13c60ed399a72e2ef8/greenlet-3.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:b066e8b50e28b503f604fa538adc764a638b38cf8e81e025011d26e8a627fa79", size = 227519, upload-time = "2026-01-23T15:31:47.284Z" },
+    { url = "https://files.pythonhosted.org/packages/28/24/cbbec49bacdcc9ec652a81d3efef7b59f326697e7edf6ed775a5e08e54c2/greenlet-3.3.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:3e63252943c921b90abb035ebe9de832c436401d9c45f262d80e2d06cc659242", size = 282706, upload-time = "2026-01-23T15:33:05.525Z" },
+    { url = "https://files.pythonhosted.org/packages/86/2e/4f2b9323c144c4fe8842a4e0d92121465485c3c2c5b9e9b30a52e80f523f/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76e39058e68eb125de10c92524573924e827927df5d3891fbc97bd55764a8774", size = 651209, upload-time = "2026-01-23T16:01:01.517Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/87/50ca60e515f5bb55a2fbc5f0c9b5b156de7d2fc51a0a69abc9d23914a237/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9f9d5e7a9310b7a2f416dd13d2e3fd8b42d803968ea580b7c0f322ccb389b97", size = 654300, upload-time = "2026-01-23T16:05:32.199Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/94/74310866dfa2b73dd08659a3d18762f83985ad3281901ba0ee9a815194fb/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92497c78adf3ac703b57f1e3813c2d874f27f71a178f9ea5887855da413cd6d2", size = 653842, upload-time = "2026-01-23T15:32:55.671Z" },
+    { url = "https://files.pythonhosted.org/packages/97/43/8bf0ffa3d498eeee4c58c212a3905dd6146c01c8dc0b0a046481ca29b18c/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ed6b402bc74d6557a705e197d47f9063733091ed6357b3de33619d8a8d93ac53", size = 1614917, upload-time = "2026-01-23T16:04:26.276Z" },
+    { url = "https://files.pythonhosted.org/packages/89/90/a3be7a5f378fc6e84abe4dcfb2ba32b07786861172e502388b4c90000d1b/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:59913f1e5ada20fde795ba906916aea25d442abcc0593fba7e26c92b7ad76249", size = 1676092, upload-time = "2026-01-23T15:33:52.176Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2b/98c7f93e6db9977aaee07eb1e51ca63bd5f779b900d362791d3252e60558/greenlet-3.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:301860987846c24cb8964bdec0e31a96ad4a2a801b41b4ef40963c1b44f33451", size = 233181, upload-time = "2026-01-23T15:33:00.29Z" },
 ]
 
 [[package]]
 name = "h11"
 version = "0.16.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250 }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515 },
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
 ]
 
 [[package]]
@@ -368,38 +364,38 @@ dependencies = [
     { name = "certifi" },
     { name = "h11" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484 }
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784 },
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
 ]
 
 [[package]]
 name = "httptools"
 version = "0.7.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961 }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/53/7f/403e5d787dc4942316e515e949b0c8a013d84078a915910e9f391ba9b3ed/httptools-0.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:38e0c83a2ea9746ebbd643bdfb521b9aa4a91703e2cd705c20443405d2fd16a5", size = 206280 },
-    { url = "https://files.pythonhosted.org/packages/2a/0d/7f3fd28e2ce311ccc998c388dd1c53b18120fda3b70ebb022b135dc9839b/httptools-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f25bbaf1235e27704f1a7b86cd3304eabc04f569c828101d94a0e605ef7205a5", size = 110004 },
-    { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655 },
-    { url = "https://files.pythonhosted.org/packages/11/7d/71fee6f1844e6fa378f2eddde6c3e41ce3a1fb4b2d81118dd544e3441ec0/httptools-0.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7fe6e96090df46b36ccfaf746f03034e5ab723162bc51b0a4cf58305324036f2", size = 511440 },
-    { url = "https://files.pythonhosted.org/packages/22/a5/079d216712a4f3ffa24af4a0381b108aa9c45b7a5cc6eb141f81726b1823/httptools-0.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f72fdbae2dbc6e68b8239defb48e6a5937b12218e6ffc2c7846cc37befa84362", size = 495186 },
-    { url = "https://files.pythonhosted.org/packages/e9/9e/025ad7b65278745dee3bd0ebf9314934c4592560878308a6121f7f812084/httptools-0.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e99c7b90a29fd82fea9ef57943d501a16f3404d7b9ee81799d41639bdaae412c", size = 499192 },
-    { url = "https://files.pythonhosted.org/packages/6d/de/40a8f202b987d43afc4d54689600ff03ce65680ede2f31df348d7f368b8f/httptools-0.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3e14f530fefa7499334a79b0cf7e7cd2992870eb893526fb097d51b4f2d0f321", size = 86694 },
-    { url = "https://files.pythonhosted.org/packages/09/8f/c77b1fcbfd262d422f12da02feb0d218fa228d52485b77b953832105bb90/httptools-0.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6babce6cfa2a99545c60bfef8bee0cc0545413cb0018f617c8059a30ad985de3", size = 202889 },
-    { url = "https://files.pythonhosted.org/packages/0a/1a/22887f53602feaa066354867bc49a68fc295c2293433177ee90870a7d517/httptools-0.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:601b7628de7504077dd3dcb3791c6b8694bbd967148a6d1f01806509254fb1ca", size = 108180 },
-    { url = "https://files.pythonhosted.org/packages/32/6a/6aaa91937f0010d288d3d124ca2946d48d60c3a5ee7ca62afe870e3ea011/httptools-0.7.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:04c6c0e6c5fb0739c5b8a9eb046d298650a0ff38cf42537fc372b28dc7e4472c", size = 478596 },
-    { url = "https://files.pythonhosted.org/packages/6d/70/023d7ce117993107be88d2cbca566a7c1323ccbaf0af7eabf2064fe356f6/httptools-0.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69d4f9705c405ae3ee83d6a12283dc9feba8cc6aaec671b412917e644ab4fa66", size = 473268 },
-    { url = "https://files.pythonhosted.org/packages/32/4d/9dd616c38da088e3f436e9a616e1d0cc66544b8cdac405cc4e81c8679fc7/httptools-0.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:44c8f4347d4b31269c8a9205d8a5ee2df5322b09bbbd30f8f862185bb6b05346", size = 455517 },
-    { url = "https://files.pythonhosted.org/packages/1d/3a/a6c595c310b7df958e739aae88724e24f9246a514d909547778d776799be/httptools-0.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:465275d76db4d554918aba40bf1cbebe324670f3dfc979eaffaa5d108e2ed650", size = 458337 },
-    { url = "https://files.pythonhosted.org/packages/fd/82/88e8d6d2c51edc1cc391b6e044c6c435b6aebe97b1abc33db1b0b24cd582/httptools-0.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:322d00c2068d125bd570f7bf78b2d367dad02b919d8581d7476d8b75b294e3e6", size = 85743 },
-    { url = "https://files.pythonhosted.org/packages/34/50/9d095fcbb6de2d523e027a2f304d4551855c2f46e0b82befd718b8b20056/httptools-0.7.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:c08fe65728b8d70b6923ce31e3956f859d5e1e8548e6f22ec520a962c6757270", size = 203619 },
-    { url = "https://files.pythonhosted.org/packages/07/f0/89720dc5139ae54b03f861b5e2c55a37dba9a5da7d51e1e824a1f343627f/httptools-0.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7aea2e3c3953521c3c51106ee11487a910d45586e351202474d45472db7d72d3", size = 108714 },
-    { url = "https://files.pythonhosted.org/packages/b3/cb/eea88506f191fb552c11787c23f9a405f4c7b0c5799bf73f2249cd4f5228/httptools-0.7.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0e68b8582f4ea9166be62926077a3334064d422cf08ab87d8b74664f8e9058e1", size = 472909 },
-    { url = "https://files.pythonhosted.org/packages/e0/4a/a548bdfae6369c0d078bab5769f7b66f17f1bfaa6fa28f81d6be6959066b/httptools-0.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df091cf961a3be783d6aebae963cc9b71e00d57fa6f149025075217bc6a55a7b", size = 470831 },
-    { url = "https://files.pythonhosted.org/packages/4d/31/14df99e1c43bd132eec921c2e7e11cda7852f65619bc0fc5bdc2d0cb126c/httptools-0.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f084813239e1eb403ddacd06a30de3d3e09a9b76e7894dcda2b22f8a726e9c60", size = 452631 },
-    { url = "https://files.pythonhosted.org/packages/22/d2/b7e131f7be8d854d48cb6d048113c30f9a46dca0c9a8b08fcb3fcd588cdc/httptools-0.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7347714368fb2b335e9063bc2b96f2f87a9ceffcd9758ac295f8bbcd3ffbc0ca", size = 452910 },
-    { url = "https://files.pythonhosted.org/packages/53/cf/878f3b91e4e6e011eff6d1fa9ca39f7eb17d19c9d7971b04873734112f30/httptools-0.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:cfabda2a5bb85aa2a904ce06d974a3f30fb36cc63d7feaddec05d2050acede96", size = 88205 },
+    { url = "https://files.pythonhosted.org/packages/53/7f/403e5d787dc4942316e515e949b0c8a013d84078a915910e9f391ba9b3ed/httptools-0.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:38e0c83a2ea9746ebbd643bdfb521b9aa4a91703e2cd705c20443405d2fd16a5", size = 206280, upload-time = "2025-10-10T03:54:39.274Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/0d/7f3fd28e2ce311ccc998c388dd1c53b18120fda3b70ebb022b135dc9839b/httptools-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f25bbaf1235e27704f1a7b86cd3304eabc04f569c828101d94a0e605ef7205a5", size = 110004, upload-time = "2025-10-10T03:54:40.403Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655, upload-time = "2025-10-10T03:54:41.347Z" },
+    { url = "https://files.pythonhosted.org/packages/11/7d/71fee6f1844e6fa378f2eddde6c3e41ce3a1fb4b2d81118dd544e3441ec0/httptools-0.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7fe6e96090df46b36ccfaf746f03034e5ab723162bc51b0a4cf58305324036f2", size = 511440, upload-time = "2025-10-10T03:54:42.452Z" },
+    { url = "https://files.pythonhosted.org/packages/22/a5/079d216712a4f3ffa24af4a0381b108aa9c45b7a5cc6eb141f81726b1823/httptools-0.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f72fdbae2dbc6e68b8239defb48e6a5937b12218e6ffc2c7846cc37befa84362", size = 495186, upload-time = "2025-10-10T03:54:43.937Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/025ad7b65278745dee3bd0ebf9314934c4592560878308a6121f7f812084/httptools-0.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e99c7b90a29fd82fea9ef57943d501a16f3404d7b9ee81799d41639bdaae412c", size = 499192, upload-time = "2025-10-10T03:54:45.003Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/de/40a8f202b987d43afc4d54689600ff03ce65680ede2f31df348d7f368b8f/httptools-0.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3e14f530fefa7499334a79b0cf7e7cd2992870eb893526fb097d51b4f2d0f321", size = 86694, upload-time = "2025-10-10T03:54:45.923Z" },
+    { url = "https://files.pythonhosted.org/packages/09/8f/c77b1fcbfd262d422f12da02feb0d218fa228d52485b77b953832105bb90/httptools-0.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6babce6cfa2a99545c60bfef8bee0cc0545413cb0018f617c8059a30ad985de3", size = 202889, upload-time = "2025-10-10T03:54:47.089Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/1a/22887f53602feaa066354867bc49a68fc295c2293433177ee90870a7d517/httptools-0.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:601b7628de7504077dd3dcb3791c6b8694bbd967148a6d1f01806509254fb1ca", size = 108180, upload-time = "2025-10-10T03:54:48.052Z" },
+    { url = "https://files.pythonhosted.org/packages/32/6a/6aaa91937f0010d288d3d124ca2946d48d60c3a5ee7ca62afe870e3ea011/httptools-0.7.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:04c6c0e6c5fb0739c5b8a9eb046d298650a0ff38cf42537fc372b28dc7e4472c", size = 478596, upload-time = "2025-10-10T03:54:48.919Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/70/023d7ce117993107be88d2cbca566a7c1323ccbaf0af7eabf2064fe356f6/httptools-0.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69d4f9705c405ae3ee83d6a12283dc9feba8cc6aaec671b412917e644ab4fa66", size = 473268, upload-time = "2025-10-10T03:54:49.993Z" },
+    { url = "https://files.pythonhosted.org/packages/32/4d/9dd616c38da088e3f436e9a616e1d0cc66544b8cdac405cc4e81c8679fc7/httptools-0.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:44c8f4347d4b31269c8a9205d8a5ee2df5322b09bbbd30f8f862185bb6b05346", size = 455517, upload-time = "2025-10-10T03:54:51.066Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/3a/a6c595c310b7df958e739aae88724e24f9246a514d909547778d776799be/httptools-0.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:465275d76db4d554918aba40bf1cbebe324670f3dfc979eaffaa5d108e2ed650", size = 458337, upload-time = "2025-10-10T03:54:52.196Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/82/88e8d6d2c51edc1cc391b6e044c6c435b6aebe97b1abc33db1b0b24cd582/httptools-0.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:322d00c2068d125bd570f7bf78b2d367dad02b919d8581d7476d8b75b294e3e6", size = 85743, upload-time = "2025-10-10T03:54:53.448Z" },
+    { url = "https://files.pythonhosted.org/packages/34/50/9d095fcbb6de2d523e027a2f304d4551855c2f46e0b82befd718b8b20056/httptools-0.7.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:c08fe65728b8d70b6923ce31e3956f859d5e1e8548e6f22ec520a962c6757270", size = 203619, upload-time = "2025-10-10T03:54:54.321Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f0/89720dc5139ae54b03f861b5e2c55a37dba9a5da7d51e1e824a1f343627f/httptools-0.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7aea2e3c3953521c3c51106ee11487a910d45586e351202474d45472db7d72d3", size = 108714, upload-time = "2025-10-10T03:54:55.163Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/cb/eea88506f191fb552c11787c23f9a405f4c7b0c5799bf73f2249cd4f5228/httptools-0.7.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0e68b8582f4ea9166be62926077a3334064d422cf08ab87d8b74664f8e9058e1", size = 472909, upload-time = "2025-10-10T03:54:56.056Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/4a/a548bdfae6369c0d078bab5769f7b66f17f1bfaa6fa28f81d6be6959066b/httptools-0.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df091cf961a3be783d6aebae963cc9b71e00d57fa6f149025075217bc6a55a7b", size = 470831, upload-time = "2025-10-10T03:54:57.219Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/31/14df99e1c43bd132eec921c2e7e11cda7852f65619bc0fc5bdc2d0cb126c/httptools-0.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f084813239e1eb403ddacd06a30de3d3e09a9b76e7894dcda2b22f8a726e9c60", size = 452631, upload-time = "2025-10-10T03:54:58.219Z" },
+    { url = "https://files.pythonhosted.org/packages/22/d2/b7e131f7be8d854d48cb6d048113c30f9a46dca0c9a8b08fcb3fcd588cdc/httptools-0.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7347714368fb2b335e9063bc2b96f2f87a9ceffcd9758ac295f8bbcd3ffbc0ca", size = 452910, upload-time = "2025-10-10T03:54:59.366Z" },
+    { url = "https://files.pythonhosted.org/packages/53/cf/878f3b91e4e6e011eff6d1fa9ca39f7eb17d19c9d7971b04873734112f30/httptools-0.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:cfabda2a5bb85aa2a904ce06d974a3f30fb36cc63d7feaddec05d2050acede96", size = 88205, upload-time = "2025-10-10T03:55:00.389Z" },
 ]
 
 [[package]]
@@ -412,27 +408,27 @@ dependencies = [
     { name = "httpcore" },
     { name = "idna" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 }
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 },
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
 ]
 
 [[package]]
 name = "idna"
 version = "3.11"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582 }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008 },
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
 ]
 
 [[package]]
 name = "iniconfig"
 version = "2.3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503 }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484 },
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
 ]
 
 [[package]]
@@ -450,18 +446,18 @@ dependencies = [
     { name = "stack-data" },
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e5/61/1810830e8b93c72dcd3c0f150c80a00c3deb229562d9423807ec92c3a539/ipython-8.38.0.tar.gz", hash = "sha256:9cfea8c903ce0867cc2f23199ed8545eb741f3a69420bfcf3743ad1cec856d39", size = 5513996 }
+sdist = { url = "https://files.pythonhosted.org/packages/e5/61/1810830e8b93c72dcd3c0f150c80a00c3deb229562d9423807ec92c3a539/ipython-8.38.0.tar.gz", hash = "sha256:9cfea8c903ce0867cc2f23199ed8545eb741f3a69420bfcf3743ad1cec856d39", size = 5513996, upload-time = "2026-01-05T10:59:06.901Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9f/df/db59624f4c71b39717c423409950ac3f2c8b2ce4b0aac843112c7fb3f721/ipython-8.38.0-py3-none-any.whl", hash = "sha256:750162629d800ac65bb3b543a14e7a74b0e88063eac9b92124d4b2aa3f6d8e86", size = 831813 },
+    { url = "https://files.pythonhosted.org/packages/9f/df/db59624f4c71b39717c423409950ac3f2c8b2ce4b0aac843112c7fb3f721/ipython-8.38.0-py3-none-any.whl", hash = "sha256:750162629d800ac65bb3b543a14e7a74b0e88063eac9b92124d4b2aa3f6d8e86", size = 831813, upload-time = "2026-01-05T10:59:04.239Z" },
 ]
 
 [[package]]
 name = "itsdangerous"
 version = "2.2.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9c/cb/8ac0172223afbccb63986cc25049b154ecfb5e85932587206f42317be31d/itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173", size = 54410 }
+sdist = { url = "https://files.pythonhosted.org/packages/9c/cb/8ac0172223afbccb63986cc25049b154ecfb5e85932587206f42317be31d/itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173", size = 54410, upload-time = "2024-04-16T21:28:15.614Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234 },
+    { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234, upload-time = "2024-04-16T21:28:14.499Z" },
 ]
 
 [[package]]
@@ -471,9 +467,69 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "parso" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287 }
+sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278 },
+    { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" },
+]
+
+[[package]]
+name = "librt"
+version = "0.8.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/56/9c/b4b0c54d84da4a94b37bd44151e46d5e583c9534c7e02250b961b1b6d8a8/librt-0.8.1.tar.gz", hash = "sha256:be46a14693955b3bd96014ccbdb8339ee8c9346fbe11c1b78901b55125f14c73", size = 177471, upload-time = "2026-02-17T16:13:06.101Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/21/d39b0a87ac52fc98f621fb6f8060efb017a767ebbbac2f99fbcbc9ddc0d7/librt-0.8.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a28f2612ab566b17f3698b0da021ff9960610301607c9a5e8eaca62f5e1c350a", size = 66516, upload-time = "2026-02-17T16:11:41.604Z" },
+    { url = "https://files.pythonhosted.org/packages/69/f1/46375e71441c43e8ae335905e069f1c54febee63a146278bcee8782c84fd/librt-0.8.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:60a78b694c9aee2a0f1aaeaa7d101cf713e92e8423a941d2897f4fa37908dab9", size = 68634, upload-time = "2026-02-17T16:11:43.268Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/33/c510de7f93bf1fa19e13423a606d8189a02624a800710f6e6a0a0f0784b3/librt-0.8.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:758509ea3f1eba2a57558e7e98f4659d0ea7670bff49673b0dde18a3c7e6c0eb", size = 198941, upload-time = "2026-02-17T16:11:44.28Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/36/e725903416409a533d92398e88ce665476f275081d0d7d42f9c4951999e5/librt-0.8.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:039b9f2c506bd0ab0f8725aa5ba339c6f0cd19d3b514b50d134789809c24285d", size = 209991, upload-time = "2026-02-17T16:11:45.462Z" },
+    { url = "https://files.pythonhosted.org/packages/30/7a/8d908a152e1875c9f8eac96c97a480df425e657cdb47854b9efaa4998889/librt-0.8.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bb54f1205a3a6ab41a6fd71dfcdcbd278670d3a90ca502a30d9da583105b6f7", size = 224476, upload-time = "2026-02-17T16:11:46.542Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/b8/a22c34f2c485b8903a06f3fe3315341fe6876ef3599792344669db98fcff/librt-0.8.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:05bd41cdee35b0c59c259f870f6da532a2c5ca57db95b5f23689fcb5c9e42440", size = 217518, upload-time = "2026-02-17T16:11:47.746Z" },
+    { url = "https://files.pythonhosted.org/packages/79/6f/5c6fea00357e4f82ba44f81dbfb027921f1ab10e320d4a64e1c408d035d9/librt-0.8.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adfab487facf03f0d0857b8710cf82d0704a309d8ffc33b03d9302b4c64e91a9", size = 225116, upload-time = "2026-02-17T16:11:49.298Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/a0/95ced4e7b1267fe1e2720a111685bcddf0e781f7e9e0ce59d751c44dcfe5/librt-0.8.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:153188fe98a72f206042be10a2c6026139852805215ed9539186312d50a8e972", size = 217751, upload-time = "2026-02-17T16:11:50.49Z" },
+    { url = "https://files.pythonhosted.org/packages/93/c2/0517281cb4d4101c27ab59472924e67f55e375bc46bedae94ac6dc6e1902/librt-0.8.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:dd3c41254ee98604b08bd5b3af5bf0a89740d4ee0711de95b65166bf44091921", size = 218378, upload-time = "2026-02-17T16:11:51.783Z" },
+    { url = "https://files.pythonhosted.org/packages/43/e8/37b3ac108e8976888e559a7b227d0ceac03c384cfd3e7a1c2ee248dbae79/librt-0.8.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e0d138c7ae532908cbb342162b2611dbd4d90c941cd25ab82084aaf71d2c0bd0", size = 241199, upload-time = "2026-02-17T16:11:53.561Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/5b/35812d041c53967fedf551a39399271bbe4257e681236a2cf1a69c8e7fa1/librt-0.8.1-cp312-cp312-win32.whl", hash = "sha256:43353b943613c5d9c49a25aaffdba46f888ec354e71e3529a00cca3f04d66a7a", size = 54917, upload-time = "2026-02-17T16:11:54.758Z" },
+    { url = "https://files.pythonhosted.org/packages/de/d1/fa5d5331b862b9775aaf2a100f5ef86854e5d4407f71bddf102f4421e034/librt-0.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:ff8baf1f8d3f4b6b7257fcb75a501f2a5499d0dda57645baa09d4d0d34b19444", size = 62017, upload-time = "2026-02-17T16:11:55.748Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/7c/c614252f9acda59b01a66e2ddfd243ed1c7e1deab0293332dfbccf862808/librt-0.8.1-cp312-cp312-win_arm64.whl", hash = "sha256:0f2ae3725904f7377e11cc37722d5d401e8b3d5851fb9273d7f4fe04f6b3d37d", size = 52441, upload-time = "2026-02-17T16:11:56.801Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/3c/f614c8e4eaac7cbf2bbdf9528790b21d89e277ee20d57dc6e559c626105f/librt-0.8.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e6bad1cd94f6764e1e21950542f818a09316645337fd5ab9a7acc45d99a8f35", size = 66529, upload-time = "2026-02-17T16:11:57.809Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/96/5836544a45100ae411eda07d29e3d99448e5258b6e9c8059deb92945f5c2/librt-0.8.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cf450f498c30af55551ba4f66b9123b7185362ec8b625a773b3d39aa1a717583", size = 68669, upload-time = "2026-02-17T16:11:58.843Z" },
+    { url = "https://files.pythonhosted.org/packages/06/53/f0b992b57af6d5531bf4677d75c44f095f2366a1741fb695ee462ae04b05/librt-0.8.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:eca45e982fa074090057132e30585a7e8674e9e885d402eae85633e9f449ce6c", size = 199279, upload-time = "2026-02-17T16:11:59.862Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/ad/4848cc16e268d14280d8168aee4f31cea92bbd2b79ce33d3e166f2b4e4fc/librt-0.8.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c3811485fccfda840861905b8c70bba5ec094e02825598bb9d4ca3936857a04", size = 210288, upload-time = "2026-02-17T16:12:00.954Z" },
+    { url = "https://files.pythonhosted.org/packages/52/05/27fdc2e95de26273d83b96742d8d3b7345f2ea2bdbd2405cc504644f2096/librt-0.8.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e4af413908f77294605e28cfd98063f54b2c790561383971d2f52d113d9c363", size = 224809, upload-time = "2026-02-17T16:12:02.108Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/d0/78200a45ba3240cb042bc597d6f2accba9193a2c57d0356268cbbe2d0925/librt-0.8.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5212a5bd7fae98dae95710032902edcd2ec4dc994e883294f75c857b83f9aba0", size = 218075, upload-time = "2026-02-17T16:12:03.631Z" },
+    { url = "https://files.pythonhosted.org/packages/af/72/a210839fa74c90474897124c064ffca07f8d4b347b6574d309686aae7ca6/librt-0.8.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e692aa2d1d604e6ca12d35e51fdc36f4cda6345e28e36374579f7ef3611b3012", size = 225486, upload-time = "2026-02-17T16:12:04.725Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/c1/a03cc63722339ddbf087485f253493e2b013039f5b707e8e6016141130fa/librt-0.8.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4be2a5c926b9770c9e08e717f05737a269b9d0ebc5d2f0060f0fe3fe9ce47acb", size = 218219, upload-time = "2026-02-17T16:12:05.828Z" },
+    { url = "https://files.pythonhosted.org/packages/58/f5/fff6108af0acf941c6f274a946aea0e484bd10cd2dc37610287ce49388c5/librt-0.8.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fd1a720332ea335ceb544cf0a03f81df92abd4bb887679fd1e460976b0e6214b", size = 218750, upload-time = "2026-02-17T16:12:07.09Z" },
+    { url = "https://files.pythonhosted.org/packages/71/67/5a387bfef30ec1e4b4f30562c8586566faf87e47d696768c19feb49e3646/librt-0.8.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2af9e01e0ef80d95ae3c720be101227edae5f2fe7e3dc63d8857fadfc5a1d", size = 241624, upload-time = "2026-02-17T16:12:08.43Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/be/24f8502db11d405232ac1162eb98069ca49c3306c1d75c6ccc61d9af8789/librt-0.8.1-cp313-cp313-win32.whl", hash = "sha256:086a32dbb71336627e78cc1d6ee305a68d038ef7d4c39aaff41ae8c9aa46e91a", size = 54969, upload-time = "2026-02-17T16:12:09.633Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/73/c9fdf6cb2a529c1a092ce769a12d88c8cca991194dfe641b6af12fa964d2/librt-0.8.1-cp313-cp313-win_amd64.whl", hash = "sha256:e11769a1dbda4da7b00a76cfffa67aa47cfa66921d2724539eee4b9ede780b79", size = 62000, upload-time = "2026-02-17T16:12:10.632Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/97/68f80ca3ac4924f250cdfa6e20142a803e5e50fca96ef5148c52ee8c10ea/librt-0.8.1-cp313-cp313-win_arm64.whl", hash = "sha256:924817ab3141aca17893386ee13261f1d100d1ef410d70afe4389f2359fea4f0", size = 52495, upload-time = "2026-02-17T16:12:11.633Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/6a/907ef6800f7bca71b525a05f1839b21f708c09043b1c6aa77b6b827b3996/librt-0.8.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6cfa7fe54fd4d1f47130017351a959fe5804bda7a0bc7e07a2cdbc3fdd28d34f", size = 66081, upload-time = "2026-02-17T16:12:12.766Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/18/25e991cd5640c9fb0f8d91b18797b29066b792f17bf8493da183bf5caabe/librt-0.8.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:228c2409c079f8c11fb2e5d7b277077f694cb93443eb760e00b3b83cb8b3176c", size = 68309, upload-time = "2026-02-17T16:12:13.756Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/36/46820d03f058cfb5a9de5940640ba03165ed8aded69e0733c417bb04df34/librt-0.8.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7aae78ab5e3206181780e56912d1b9bb9f90a7249ce12f0e8bf531d0462dd0fc", size = 196804, upload-time = "2026-02-17T16:12:14.818Z" },
+    { url = "https://files.pythonhosted.org/packages/59/18/5dd0d3b87b8ff9c061849fbdb347758d1f724b9a82241aa908e0ec54ccd0/librt-0.8.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:172d57ec04346b047ca6af181e1ea4858086c80bdf455f61994c4aa6fc3f866c", size = 206907, upload-time = "2026-02-17T16:12:16.513Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/96/ef04902aad1424fd7299b62d1890e803e6ab4018c3044dca5922319c4b97/librt-0.8.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b1977c4ea97ce5eb7755a78fae68d87e4102e4aaf54985e8b56806849cc06a3", size = 221217, upload-time = "2026-02-17T16:12:17.906Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/ff/7e01f2dda84a8f5d280637a2e5827210a8acca9a567a54507ef1c75b342d/librt-0.8.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:10c42e1f6fd06733ef65ae7bebce2872bcafd8d6e6b0a08fe0a05a23b044fb14", size = 214622, upload-time = "2026-02-17T16:12:19.108Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/8c/5b093d08a13946034fed57619742f790faf77058558b14ca36a6e331161e/librt-0.8.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4c8dfa264b9193c4ee19113c985c95f876fae5e51f731494fc4e0cf594990ba7", size = 221987, upload-time = "2026-02-17T16:12:20.331Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/cc/86b0b3b151d40920ad45a94ce0171dec1aebba8a9d72bb3fa00c73ab25dd/librt-0.8.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:01170b6729a438f0dedc4a26ed342e3dc4f02d1000b4b19f980e1877f0c297e6", size = 215132, upload-time = "2026-02-17T16:12:21.54Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/be/8588164a46edf1e69858d952654e216a9a91174688eeefb9efbb38a9c799/librt-0.8.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:7b02679a0d783bdae30d443025b94465d8c3dc512f32f5b5031f93f57ac32071", size = 215195, upload-time = "2026-02-17T16:12:23.073Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f2/0b9279bea735c734d69344ecfe056c1ba211694a72df10f568745c899c76/librt-0.8.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:190b109bb69592a3401fe1ffdea41a2e73370ace2ffdc4a0e8e2b39cdea81b78", size = 237946, upload-time = "2026-02-17T16:12:24.275Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/cc/5f2a34fbc8aeb35314a3641f9956fa9051a947424652fad9882be7a97949/librt-0.8.1-cp314-cp314-win32.whl", hash = "sha256:e70a57ecf89a0f64c24e37f38d3fe217a58169d2fe6ed6d70554964042474023", size = 50689, upload-time = "2026-02-17T16:12:25.766Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/76/cd4d010ab2147339ca2b93e959c3686e964edc6de66ddacc935c325883d7/librt-0.8.1-cp314-cp314-win_amd64.whl", hash = "sha256:7e2f3edca35664499fbb36e4770650c4bd4a08abc1f4458eab9df4ec56389730", size = 57875, upload-time = "2026-02-17T16:12:27.465Z" },
+    { url = "https://files.pythonhosted.org/packages/84/0f/2143cb3c3ca48bd3379dcd11817163ca50781927c4537345d608b5045998/librt-0.8.1-cp314-cp314-win_arm64.whl", hash = "sha256:0d2f82168e55ddefd27c01c654ce52379c0750ddc31ee86b4b266bcf4d65f2a3", size = 48058, upload-time = "2026-02-17T16:12:28.556Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/0e/9b23a87e37baf00311c3efe6b48d6b6c168c29902dfc3f04c338372fd7db/librt-0.8.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c74a2da57a094bd48d03fa5d196da83d2815678385d2978657499063709abe1", size = 68313, upload-time = "2026-02-17T16:12:29.659Z" },
+    { url = "https://files.pythonhosted.org/packages/db/9a/859c41e5a4f1c84200a7d2b92f586aa27133c8243b6cac9926f6e54d01b9/librt-0.8.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a355d99c4c0d8e5b770313b8b247411ed40949ca44e33e46a4789b9293a907ee", size = 70994, upload-time = "2026-02-17T16:12:31.516Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/28/10605366ee599ed34223ac2bf66404c6fb59399f47108215d16d5ad751a8/librt-0.8.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2eb345e8b33fb748227409c9f1233d4df354d6e54091f0e8fc53acdb2ffedeb7", size = 220770, upload-time = "2026-02-17T16:12:33.294Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8d/16ed8fd452dafae9c48d17a6bc1ee3e818fd40ef718d149a8eff2c9f4ea2/librt-0.8.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9be2f15e53ce4e83cc08adc29b26fb5978db62ef2a366fbdf716c8a6c8901040", size = 235409, upload-time = "2026-02-17T16:12:35.443Z" },
+    { url = "https://files.pythonhosted.org/packages/89/1b/7bdf3e49349c134b25db816e4a3db6b94a47ac69d7d46b1e682c2c4949be/librt-0.8.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:785ae29c1f5c6e7c2cde2c7c0e148147f4503da3abc5d44d482068da5322fd9e", size = 246473, upload-time = "2026-02-17T16:12:36.656Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/8a/91fab8e4fd2a24930a17188c7af5380eb27b203d72101c9cc000dbdfd95a/librt-0.8.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1d3a7da44baf692f0c6aeb5b2a09c5e6fc7a703bca9ffa337ddd2e2da53f7732", size = 238866, upload-time = "2026-02-17T16:12:37.849Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/e0/c45a098843fc7c07e18a7f8a24ca8496aecbf7bdcd54980c6ca1aaa79a8e/librt-0.8.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5fc48998000cbc39ec0d5311312dda93ecf92b39aaf184c5e817d5d440b29624", size = 250248, upload-time = "2026-02-17T16:12:39.445Z" },
+    { url = "https://files.pythonhosted.org/packages/82/30/07627de23036640c952cce0c1fe78972e77d7d2f8fd54fa5ef4554ff4a56/librt-0.8.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:e96baa6820280077a78244b2e06e416480ed859bbd8e5d641cf5742919d8beb4", size = 240629, upload-time = "2026-02-17T16:12:40.889Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/c1/55bfe1ee3542eba055616f9098eaf6eddb966efb0ca0f44eaa4aba327307/librt-0.8.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31362dbfe297b23590530007062c32c6f6176f6099646bb2c95ab1b00a57c382", size = 239615, upload-time = "2026-02-17T16:12:42.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/39/191d3d28abc26c9099b19852e6c99f7f6d400b82fa5a4e80291bd3803e19/librt-0.8.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cc3656283d11540ab0ea01978378e73e10002145117055e03722417aeab30994", size = 263001, upload-time = "2026-02-17T16:12:43.627Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/eb/7697f60fbe7042ab4e88f4ee6af496b7f222fffb0a4e3593ef1f29f81652/librt-0.8.1-cp314-cp314t-win32.whl", hash = "sha256:738f08021b3142c2918c03692608baed43bc51144c29e35807682f8070ee2a3a", size = 51328, upload-time = "2026-02-17T16:12:45.148Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/72/34bf2eb7a15414a23e5e70ecb9440c1d3179f393d9349338a91e2781c0fb/librt-0.8.1-cp314-cp314t-win_amd64.whl", hash = "sha256:89815a22daf9c51884fb5dbe4f1ef65ee6a146e0b6a8df05f753e2e4a9359bf4", size = 58722, upload-time = "2026-02-17T16:12:46.85Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/c8/d148e041732d631fc76036f8b30fae4e77b027a1e95b7a84bb522481a940/librt-0.8.1-cp314-cp314t-win_arm64.whl", hash = "sha256:bf512a71a23504ed08103a13c941f763db13fb11177beb3d9244c98c29fb4a61", size = 48755, upload-time = "2026-02-17T16:12:47.943Z" },
 ]
 
 [[package]]
@@ -483,72 +539,72 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markupsafe" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9e/38/bd5b78a920a64d708fe6bc8e0a2c075e1389d53bef8413725c63ba041535/mako-1.3.10.tar.gz", hash = "sha256:99579a6f39583fa7e5630a28c3c1f440e4e97a414b80372649c0ce338da2ea28", size = 392474 }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/38/bd5b78a920a64d708fe6bc8e0a2c075e1389d53bef8413725c63ba041535/mako-1.3.10.tar.gz", hash = "sha256:99579a6f39583fa7e5630a28c3c1f440e4e97a414b80372649c0ce338da2ea28", size = 392474, upload-time = "2025-04-10T12:44:31.16Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/87/fb/99f81ac72ae23375f22b7afdb7642aba97c00a713c217124420147681a2f/mako-1.3.10-py3-none-any.whl", hash = "sha256:baef24a52fc4fc514a0887ac600f9f1cff3d82c61d4d700a1fa84d597b88db59", size = 78509 },
+    { url = "https://files.pythonhosted.org/packages/87/fb/99f81ac72ae23375f22b7afdb7642aba97c00a713c217124420147681a2f/mako-1.3.10-py3-none-any.whl", hash = "sha256:baef24a52fc4fc514a0887ac600f9f1cff3d82c61d4d700a1fa84d597b88db59", size = 78509, upload-time = "2025-04-10T12:50:53.297Z" },
 ]
 
 [[package]]
 name = "markupsafe"
 version = "3.0.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313 }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615 },
-    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020 },
-    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332 },
-    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947 },
-    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962 },
-    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760 },
-    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529 },
-    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015 },
-    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540 },
-    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105 },
-    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906 },
-    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622 },
-    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029 },
-    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374 },
-    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980 },
-    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990 },
-    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784 },
-    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588 },
-    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041 },
-    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543 },
-    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113 },
-    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911 },
-    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658 },
-    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066 },
-    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639 },
-    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569 },
-    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284 },
-    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801 },
-    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769 },
-    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642 },
-    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612 },
-    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200 },
-    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973 },
-    { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619 },
-    { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029 },
-    { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408 },
-    { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005 },
-    { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048 },
-    { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821 },
-    { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606 },
-    { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043 },
-    { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747 },
-    { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341 },
-    { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073 },
-    { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661 },
-    { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069 },
-    { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670 },
-    { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598 },
-    { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261 },
-    { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835 },
-    { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733 },
-    { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672 },
-    { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819 },
-    { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426 },
-    { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146 },
+    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
+    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+    { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" },
+    { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" },
+    { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" },
+    { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" },
+    { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" },
+    { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
 ]
 
 [[package]]
@@ -558,27 +614,78 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110 }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516 },
+    { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" },
+]
+
+[[package]]
+name = "mypy"
+version = "1.19.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "librt", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "mypy-extensions" },
+    { name = "pathspec" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404, upload-time = "2025-12-15T05:03:48.42Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/8a/19bfae96f6615aa8a0604915512e0289b1fad33d5909bf7244f02935d33a/mypy-1.19.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8174a03289288c1f6c46d55cef02379b478bfbc8e358e02047487cad44c6ca1", size = 13206053, upload-time = "2025-12-15T05:03:46.622Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/34/3e63879ab041602154ba2a9f99817bb0c85c4df19a23a1443c8986e4d565/mypy-1.19.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffcebe56eb09ff0c0885e750036a095e23793ba6c2e894e7e63f6d89ad51f22e", size = 12219134, upload-time = "2025-12-15T05:03:24.367Z" },
+    { url = "https://files.pythonhosted.org/packages/89/cc/2db6f0e95366b630364e09845672dbee0cbf0bbe753a204b29a944967cd9/mypy-1.19.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b64d987153888790bcdb03a6473d321820597ab8dd9243b27a92153c4fa50fd2", size = 12731616, upload-time = "2025-12-15T05:02:44.725Z" },
+    { url = "https://files.pythonhosted.org/packages/00/be/dd56c1fd4807bc1eba1cf18b2a850d0de7bacb55e158755eb79f77c41f8e/mypy-1.19.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c35d298c2c4bba75feb2195655dfea8124d855dfd7343bf8b8c055421eaf0cf8", size = 13620847, upload-time = "2025-12-15T05:03:39.633Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/42/332951aae42b79329f743bf1da088cd75d8d4d9acc18fbcbd84f26c1af4e/mypy-1.19.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:34c81968774648ab5ac09c29a375fdede03ba253f8f8287847bd480782f73a6a", size = 13834976, upload-time = "2025-12-15T05:03:08.786Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/63/e7493e5f90e1e085c562bb06e2eb32cae27c5057b9653348d38b47daaecc/mypy-1.19.1-cp312-cp312-win_amd64.whl", hash = "sha256:b10e7c2cd7870ba4ad9b2d8a6102eb5ffc1f16ca35e3de6bfa390c1113029d13", size = 10118104, upload-time = "2025-12-15T05:03:10.834Z" },
+    { url = "https://files.pythonhosted.org/packages/de/9f/a6abae693f7a0c697dbb435aac52e958dc8da44e92e08ba88d2e42326176/mypy-1.19.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e3157c7594ff2ef1634ee058aafc56a82db665c9438fd41b390f3bde1ab12250", size = 13201927, upload-time = "2025-12-15T05:02:29.138Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a4/45c35ccf6e1c65afc23a069f50e2c66f46bd3798cbe0d680c12d12935caa/mypy-1.19.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdb12f69bcc02700c2b47e070238f42cb87f18c0bc1fc4cdb4fb2bc5fd7a3b8b", size = 12206730, upload-time = "2025-12-15T05:03:01.325Z" },
+    { url = "https://files.pythonhosted.org/packages/05/bb/cdcf89678e26b187650512620eec8368fded4cfd99cfcb431e4cdfd19dec/mypy-1.19.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f859fb09d9583a985be9a493d5cfc5515b56b08f7447759a0c5deaf68d80506e", size = 12724581, upload-time = "2025-12-15T05:03:20.087Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/32/dd260d52babf67bad8e6770f8e1102021877ce0edea106e72df5626bb0ec/mypy-1.19.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9a6538e0415310aad77cb94004ca6482330fece18036b5f360b62c45814c4ef", size = 13616252, upload-time = "2025-12-15T05:02:49.036Z" },
+    { url = "https://files.pythonhosted.org/packages/71/d0/5e60a9d2e3bd48432ae2b454b7ef2b62a960ab51292b1eda2a95edd78198/mypy-1.19.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:da4869fc5e7f62a88f3fe0b5c919d1d9f7ea3cef92d3689de2823fd27e40aa75", size = 13840848, upload-time = "2025-12-15T05:02:55.95Z" },
+    { url = "https://files.pythonhosted.org/packages/98/76/d32051fa65ecf6cc8c6610956473abdc9b4c43301107476ac03559507843/mypy-1.19.1-cp313-cp313-win_amd64.whl", hash = "sha256:016f2246209095e8eda7538944daa1d60e1e8134d98983b9fc1e92c1fc0cb8dd", size = 10135510, upload-time = "2025-12-15T05:02:58.438Z" },
+    { url = "https://files.pythonhosted.org/packages/de/eb/b83e75f4c820c4247a58580ef86fcd35165028f191e7e1ba57128c52782d/mypy-1.19.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06e6170bd5836770e8104c8fdd58e5e725cfeb309f0a6c681a811f557e97eac1", size = 13199744, upload-time = "2025-12-15T05:03:30.823Z" },
+    { url = "https://files.pythonhosted.org/packages/94/28/52785ab7bfa165f87fcbb61547a93f98bb20e7f82f90f165a1f69bce7b3d/mypy-1.19.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:804bd67b8054a85447c8954215a906d6eff9cabeabe493fb6334b24f4bfff718", size = 12215815, upload-time = "2025-12-15T05:02:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c6/bdd60774a0dbfb05122e3e925f2e9e846c009e479dcec4821dad881f5b52/mypy-1.19.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21761006a7f497cb0d4de3d8ef4ca70532256688b0523eee02baf9eec895e27b", size = 12740047, upload-time = "2025-12-15T05:03:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2a/66ba933fe6c76bd40d1fe916a83f04fed253152f451a877520b3c4a5e41e/mypy-1.19.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28902ee51f12e0f19e1e16fbe2f8f06b6637f482c459dd393efddd0ec7f82045", size = 13601998, upload-time = "2025-12-15T05:03:13.056Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/da/5055c63e377c5c2418760411fd6a63ee2b96cf95397259038756c042574f/mypy-1.19.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:481daf36a4c443332e2ae9c137dfee878fcea781a2e3f895d54bd3002a900957", size = 13807476, upload-time = "2025-12-15T05:03:17.977Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/09/4ebd873390a063176f06b0dbf1f7783dd87bd120eae7727fa4ae4179b685/mypy-1.19.1-cp314-cp314-win_amd64.whl", hash = "sha256:8bb5c6f6d043655e055be9b542aa5f3bdd30e4f3589163e85f93f3640060509f", size = 10281872, upload-time = "2025-12-15T05:03:05.549Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239, upload-time = "2025-12-15T05:03:07.248Z" },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
 ]
 
 [[package]]
 name = "packaging"
 version = "26.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416 }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366 },
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
 ]
 
 [[package]]
 name = "parso"
 version = "0.8.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", hash = "sha256:2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd", size = 401621 }
+sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", hash = "sha256:2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd", size = 401621, upload-time = "2026-02-09T15:45:24.425Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", hash = "sha256:2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff", size = 106894 },
+    { url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", hash = "sha256:2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff", size = 106894, upload-time = "2026-02-09T15:45:21.391Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "1.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
 ]
 
 [[package]]
@@ -588,18 +695,18 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "ptyprocess" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450 }
+sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772 },
+    { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" },
 ]
 
 [[package]]
 name = "pluggy"
 version = "1.6.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412 }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538 },
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
 ]
 
 [[package]]
@@ -609,36 +716,36 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "wcwidth" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198 }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431 },
+    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
 ]
 
 [[package]]
 name = "ptyprocess"
 version = "0.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762 }
+sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993 },
+    { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" },
 ]
 
 [[package]]
 name = "pure-eval"
 version = "0.2.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752 }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842 },
+    { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" },
 ]
 
 [[package]]
 name = "pycparser"
 version = "3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492 }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172 },
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
 ]
 
 [[package]]
@@ -651,9 +758,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591 }
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580 },
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
 ]
 
 [[package]]
@@ -663,73 +770,77 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952 }
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990 },
-    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003 },
-    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200 },
-    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578 },
-    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504 },
-    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816 },
-    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366 },
-    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698 },
-    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603 },
-    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591 },
-    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068 },
-    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908 },
-    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145 },
-    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179 },
-    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403 },
-    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206 },
-    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307 },
-    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258 },
-    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917 },
-    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186 },
-    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164 },
-    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146 },
-    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788 },
-    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133 },
-    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852 },
-    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679 },
-    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766 },
-    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005 },
-    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622 },
-    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725 },
-    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040 },
-    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691 },
-    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897 },
-    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302 },
-    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877 },
-    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680 },
-    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960 },
-    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102 },
-    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039 },
-    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126 },
-    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489 },
-    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288 },
-    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255 },
-    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760 },
-    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092 },
-    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385 },
-    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832 },
-    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585 },
-    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078 },
-    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914 },
-    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560 },
-    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244 },
-    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955 },
-    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906 },
-    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607 },
-    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769 },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
 ]
 
 [[package]]
 name = "pygments"
 version = "2.19.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631 }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217 },
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
 ]
 
 [[package]]
@@ -743,9 +854,9 @@ dependencies = [
     { name = "pluggy" },
     { name = "pygments" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618 }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750 },
+    { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" },
 ]
 
 [[package]]
@@ -755,136 +866,136 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f2/a8/ecbc8ede70921dd2f544ab1cadd3ff3bf842af27f87bbdea774c7baa1d38/pytest_asyncio-0.25.3.tar.gz", hash = "sha256:fc1da2cf9f125ada7e710b4ddad05518d4cee187ae9412e9ac9271003497f07a", size = 54239 }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/a8/ecbc8ede70921dd2f544ab1cadd3ff3bf842af27f87bbdea774c7baa1d38/pytest_asyncio-0.25.3.tar.gz", hash = "sha256:fc1da2cf9f125ada7e710b4ddad05518d4cee187ae9412e9ac9271003497f07a", size = 54239, upload-time = "2025-01-28T18:37:58.729Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/67/17/3493c5624e48fd97156ebaec380dcaafee9506d7e2c46218ceebbb57d7de/pytest_asyncio-0.25.3-py3-none-any.whl", hash = "sha256:9e89518e0f9bd08928f97a3482fdc4e244df17529460bc038291ccaf8f85c7c3", size = 19467 },
+    { url = "https://files.pythonhosted.org/packages/67/17/3493c5624e48fd97156ebaec380dcaafee9506d7e2c46218ceebbb57d7de/pytest_asyncio-0.25.3-py3-none-any.whl", hash = "sha256:9e89518e0f9bd08928f97a3482fdc4e244df17529460bc038291ccaf8f85c7c3", size = 19467, upload-time = "2025-01-28T18:37:56.798Z" },
 ]
 
 [[package]]
 name = "python-dotenv"
 version = "1.2.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221 }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230 },
+    { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" },
 ]
 
 [[package]]
 name = "python-multipart"
 version = "0.0.22"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612 }
+sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612, upload-time = "2026-01-25T10:15:56.219Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579 },
+    { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579, upload-time = "2026-01-25T10:15:54.811Z" },
 ]
 
 [[package]]
 name = "pyyaml"
 version = "6.0.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960 }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063 },
-    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973 },
-    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116 },
-    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011 },
-    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870 },
-    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089 },
-    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181 },
-    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658 },
-    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003 },
-    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344 },
-    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669 },
-    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252 },
-    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081 },
-    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159 },
-    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626 },
-    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613 },
-    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115 },
-    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427 },
-    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090 },
-    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246 },
-    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814 },
-    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809 },
-    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454 },
-    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355 },
-    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175 },
-    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228 },
-    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194 },
-    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429 },
-    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912 },
-    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108 },
-    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641 },
-    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901 },
-    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132 },
-    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261 },
-    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272 },
-    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923 },
-    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062 },
-    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341 },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
 ]
 
 [[package]]
 name = "rapidfuzz"
 version = "3.14.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d3/28/9d808fe62375b9aab5ba92fa9b29371297b067c2790b2d7cda648b1e2f8d/rapidfuzz-3.14.3.tar.gz", hash = "sha256:2491937177868bc4b1e469087601d53f925e8d270ccc21e07404b4b5814b7b5f", size = 57863900 }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/28/9d808fe62375b9aab5ba92fa9b29371297b067c2790b2d7cda648b1e2f8d/rapidfuzz-3.14.3.tar.gz", hash = "sha256:2491937177868bc4b1e469087601d53f925e8d270ccc21e07404b4b5814b7b5f", size = 57863900, upload-time = "2025-11-01T11:54:52.321Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/8e/3c215e860b458cfbedb3ed73bc72e98eb7e0ed72f6b48099604a7a3260c2/rapidfuzz-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:685c93ea961d135893b5984a5a9851637d23767feabe414ec974f43babbd8226", size = 1945306 },
-    { url = "https://files.pythonhosted.org/packages/36/d9/31b33512015c899f4a6e6af64df8dfe8acddf4c8b40a4b3e0e6e1bcd00e5/rapidfuzz-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fa7c8f26f009f8c673fbfb443792f0cf8cf50c4e18121ff1e285b5e08a94fbdb", size = 1390788 },
-    { url = "https://files.pythonhosted.org/packages/a9/67/2ee6f8de6e2081ccd560a571d9c9063184fe467f484a17fa90311a7f4a2e/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:57f878330c8d361b2ce76cebb8e3e1dc827293b6abf404e67d53260d27b5d941", size = 1374580 },
-    { url = "https://files.pythonhosted.org/packages/30/83/80d22997acd928eda7deadc19ccd15883904622396d6571e935993e0453a/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c5f545f454871e6af05753a0172849c82feaf0f521c5ca62ba09e1b382d6382", size = 3154947 },
-    { url = "https://files.pythonhosted.org/packages/5b/cf/9f49831085a16384695f9fb096b99662f589e30b89b4a589a1ebc1a19d34/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:07aa0b5d8863e3151e05026a28e0d924accf0a7a3b605da978f0359bb804df43", size = 1223872 },
-    { url = "https://files.pythonhosted.org/packages/c8/0f/41ee8034e744b871c2e071ef0d360686f5ccfe5659f4fd96c3ec406b3c8b/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73b07566bc7e010e7b5bd490fb04bb312e820970180df6b5655e9e6224c137db", size = 2392512 },
-    { url = "https://files.pythonhosted.org/packages/da/86/280038b6b0c2ccec54fb957c732ad6b41cc1fd03b288d76545b9cf98343f/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6de00eb84c71476af7d3110cf25d8fe7c792d7f5fa86764ef0b4ca97e78ca3ed", size = 2521398 },
-    { url = "https://files.pythonhosted.org/packages/fa/7b/05c26f939607dca0006505e3216248ae2de631e39ef94dd63dbbf0860021/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d7843a1abf0091773a530636fdd2a49a41bcae22f9910b86b4f903e76ddc82dc", size = 4259416 },
-    { url = "https://files.pythonhosted.org/packages/40/eb/9e3af4103d91788f81111af1b54a28de347cdbed8eaa6c91d5e98a889aab/rapidfuzz-3.14.3-cp312-cp312-win32.whl", hash = "sha256:dea97ac3ca18cd3ba8f3d04b5c1fe4aa60e58e8d9b7793d3bd595fdb04128d7a", size = 1709527 },
-    { url = "https://files.pythonhosted.org/packages/b8/63/d06ecce90e2cf1747e29aeab9f823d21e5877a4c51b79720b2d3be7848f8/rapidfuzz-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:b5100fd6bcee4d27f28f4e0a1c6b5127bc8ba7c2a9959cad9eab0bf4a7ab3329", size = 1538989 },
-    { url = "https://files.pythonhosted.org/packages/fc/6d/beee32dcda64af8128aab3ace2ccb33d797ed58c434c6419eea015fec779/rapidfuzz-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:4e49c9e992bc5fc873bd0fff7ef16a4405130ec42f2ce3d2b735ba5d3d4eb70f", size = 811161 },
-    { url = "https://files.pythonhosted.org/packages/e4/4f/0d94d09646853bd26978cb3a7541b6233c5760687777fa97da8de0d9a6ac/rapidfuzz-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dbcb726064b12f356bf10fffdb6db4b6dce5390b23627c08652b3f6e49aa56ae", size = 1939646 },
-    { url = "https://files.pythonhosted.org/packages/b6/eb/f96aefc00f3bbdbab9c0657363ea8437a207d7545ac1c3789673e05d80bd/rapidfuzz-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1704fc70d214294e554a2421b473779bcdeef715881c5e927dc0f11e1692a0ff", size = 1385512 },
-    { url = "https://files.pythonhosted.org/packages/26/34/71c4f7749c12ee223dba90017a5947e8f03731a7cc9f489b662a8e9e643d/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc65e72790ddfd310c2c8912b45106e3800fefe160b0c2ef4d6b6fec4e826457", size = 1373571 },
-    { url = "https://files.pythonhosted.org/packages/32/00/ec8597a64f2be301ce1ee3290d067f49f6a7afb226b67d5f15b56d772ba5/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43e38c1305cffae8472572a0584d4ffc2f130865586a81038ca3965301f7c97c", size = 3156759 },
-    { url = "https://files.pythonhosted.org/packages/61/d5/b41eeb4930501cc899d5a9a7b5c9a33d85a670200d7e81658626dcc0ecc0/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:e195a77d06c03c98b3fc06b8a28576ba824392ce40de8c708f96ce04849a052e", size = 1222067 },
-    { url = "https://files.pythonhosted.org/packages/2a/7d/6d9abb4ffd1027c6ed837b425834f3bed8344472eb3a503ab55b3407c721/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1b7ef2f4b8583a744338a18f12c69693c194fb6777c0e9ada98cd4d9e8f09d10", size = 2394775 },
-    { url = "https://files.pythonhosted.org/packages/15/ce/4f3ab4c401c5a55364da1ffff8cc879fc97b4e5f4fa96033827da491a973/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:a2135b138bcdcb4c3742d417f215ac2d8c2b87bde15b0feede231ae95f09ec41", size = 2526123 },
-    { url = "https://files.pythonhosted.org/packages/c1/4b/54f804975376a328f57293bd817c12c9036171d15cf7292032e3f5820b2d/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:33a325ed0e8e1aa20c3e75f8ab057a7b248fdea7843c2a19ade0008906c14af0", size = 4262874 },
-    { url = "https://files.pythonhosted.org/packages/e9/b6/958db27d8a29a50ee6edd45d33debd3ce732e7209183a72f57544cd5fe22/rapidfuzz-3.14.3-cp313-cp313-win32.whl", hash = "sha256:8383b6d0d92f6cd008f3c9216535be215a064b2cc890398a678b56e6d280cb63", size = 1707972 },
-    { url = "https://files.pythonhosted.org/packages/07/75/fde1f334b0cec15b5946d9f84d73250fbfcc73c236b4bc1b25129d90876b/rapidfuzz-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:e6b5e3036976f0fde888687d91be86d81f9ac5f7b02e218913c38285b756be6c", size = 1537011 },
-    { url = "https://files.pythonhosted.org/packages/2e/d7/d83fe001ce599dc7ead57ba1debf923dc961b6bdce522b741e6b8c82f55c/rapidfuzz-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:7ba009977601d8b0828bfac9a110b195b3e4e79b350dcfa48c11269a9f1918a0", size = 810744 },
-    { url = "https://files.pythonhosted.org/packages/92/13/a486369e63ff3c1a58444d16b15c5feb943edd0e6c28a1d7d67cb8946b8f/rapidfuzz-3.14.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a0a28add871425c2fe94358c6300bbeb0bc2ed828ca003420ac6825408f5a424", size = 1967702 },
-    { url = "https://files.pythonhosted.org/packages/f1/82/efad25e260b7810f01d6b69122685e355bed78c94a12784bac4e0beb2afb/rapidfuzz-3.14.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:010e12e2411a4854b0434f920e72b717c43f8ec48d57e7affe5c42ecfa05dd0e", size = 1410702 },
-    { url = "https://files.pythonhosted.org/packages/ba/1a/34c977b860cde91082eae4a97ae503f43e0d84d4af301d857679b66f9869/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cfc3d57abd83c734d1714ec39c88a34dd69c85474918ebc21296f1e61eb5ca8", size = 1382337 },
-    { url = "https://files.pythonhosted.org/packages/88/74/f50ea0e24a5880a9159e8fd256b84d8f4634c2f6b4f98028bdd31891d907/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89acb8cbb52904f763e5ac238083b9fc193bed8d1f03c80568b20e4cef43a519", size = 3165563 },
-    { url = "https://files.pythonhosted.org/packages/e8/7a/e744359404d7737049c26099423fc54bcbf303de5d870d07d2fb1410f567/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_31_armv7l.whl", hash = "sha256:7d9af908c2f371bfb9c985bd134e295038e3031e666e4b2ade1e7cb7f5af2f1a", size = 1214727 },
-    { url = "https://files.pythonhosted.org/packages/d3/2e/87adfe14ce75768ec6c2b8acd0e05e85e84be4be5e3d283cdae360afc4fe/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1f1925619627f8798f8c3a391d81071336942e5fe8467bc3c567f982e7ce2897", size = 2403349 },
-    { url = "https://files.pythonhosted.org/packages/70/17/6c0b2b2bff9c8b12e12624c07aa22e922b0c72a490f180fa9183d1ef2c75/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:152555187360978119e98ce3e8263d70dd0c40c7541193fc302e9b7125cf8f58", size = 2507596 },
-    { url = "https://files.pythonhosted.org/packages/c3/d1/87852a7cbe4da7b962174c749a47433881a63a817d04f3e385ea9babcd9e/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:52619d25a09546b8db078981ca88939d72caa6b8701edd8b22e16482a38e799f", size = 4273595 },
-    { url = "https://files.pythonhosted.org/packages/c1/ab/1d0354b7d1771a28fa7fe089bc23acec2bdd3756efa2419f463e3ed80e16/rapidfuzz-3.14.3-cp313-cp313t-win32.whl", hash = "sha256:489ce98a895c98cad284f0a47960c3e264c724cb4cfd47a1430fa091c0c25204", size = 1757773 },
-    { url = "https://files.pythonhosted.org/packages/0b/0c/71ef356adc29e2bdf74cd284317b34a16b80258fa0e7e242dd92cc1e6d10/rapidfuzz-3.14.3-cp313-cp313t-win_amd64.whl", hash = "sha256:656e52b054d5b5c2524169240e50cfa080b04b1c613c5f90a2465e84888d6f15", size = 1576797 },
-    { url = "https://files.pythonhosted.org/packages/fe/d2/0e64fc27bb08d4304aa3d11154eb5480bcf5d62d60140a7ee984dc07468a/rapidfuzz-3.14.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c7e40c0a0af02ad6e57e89f62bef8604f55a04ecae90b0ceeda591bbf5923317", size = 829940 },
-    { url = "https://files.pythonhosted.org/packages/32/6f/1b88aaeade83abc5418788f9e6b01efefcd1a69d65ded37d89cd1662be41/rapidfuzz-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:442125473b247227d3f2de807a11da6c08ccf536572d1be943f8e262bae7e4ea", size = 1942086 },
-    { url = "https://files.pythonhosted.org/packages/a0/2c/b23861347436cb10f46c2bd425489ec462790faaa360a54a7ede5f78de88/rapidfuzz-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ec0c8c0c3d4f97ced46b2e191e883f8c82dbbf6d5ebc1842366d7eff13cd5a6", size = 1386993 },
-    { url = "https://files.pythonhosted.org/packages/83/86/5d72e2c060aa1fbdc1f7362d938f6b237dff91f5b9fc5dd7cc297e112250/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2dc37bc20272f388b8c3a4eba4febc6e77e50a8f450c472def4751e7678f55e4", size = 1379126 },
-    { url = "https://files.pythonhosted.org/packages/c9/bc/ef2cee3e4d8b3fc22705ff519f0d487eecc756abdc7c25d53686689d6cf2/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dee362e7e79bae940a5e2b3f6d09c6554db6a4e301cc68343886c08be99844f1", size = 3159304 },
-    { url = "https://files.pythonhosted.org/packages/a0/36/dc5f2f62bbc7bc90be1f75eeaf49ed9502094bb19290dfb4747317b17f12/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:4b39921df948388a863f0e267edf2c36302983459b021ab928d4b801cbe6a421", size = 1218207 },
-    { url = "https://files.pythonhosted.org/packages/df/7e/8f4be75c1bc62f47edf2bbbe2370ee482fae655ebcc4718ac3827ead3904/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:beda6aa9bc44d1d81242e7b291b446be352d3451f8217fcb068fc2933927d53b", size = 2401245 },
-    { url = "https://files.pythonhosted.org/packages/05/38/f7c92759e1bb188dd05b80d11c630ba59b8d7856657baf454ff56059c2ab/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:6a014ba09657abfcfeed64b7d09407acb29af436d7fc075b23a298a7e4a6b41c", size = 2518308 },
-    { url = "https://files.pythonhosted.org/packages/c7/ac/85820f70fed5ecb5f1d9a55f1e1e2090ef62985ef41db289b5ac5ec56e28/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:32eeafa3abce138bb725550c0e228fc7eaeec7059aa8093d9cbbec2b58c2371a", size = 4265011 },
-    { url = "https://files.pythonhosted.org/packages/46/a9/616930721ea9835c918af7cde22bff17f9db3639b0c1a7f96684be7f5630/rapidfuzz-3.14.3-cp314-cp314-win32.whl", hash = "sha256:adb44d996fc610c7da8c5048775b21db60dd63b1548f078e95858c05c86876a3", size = 1742245 },
-    { url = "https://files.pythonhosted.org/packages/06/8a/f2fa5e9635b1ccafda4accf0e38246003f69982d7c81f2faa150014525a4/rapidfuzz-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:f3d15d8527e2b293e38ce6e437631af0708df29eafd7c9fc48210854c94472f9", size = 1584856 },
-    { url = "https://files.pythonhosted.org/packages/ef/97/09e20663917678a6d60d8e0e29796db175b1165e2079830430342d5298be/rapidfuzz-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:576e4b9012a67e0bf54fccb69a7b6c94d4e86a9540a62f1a5144977359133583", size = 833490 },
-    { url = "https://files.pythonhosted.org/packages/03/1b/6b6084576ba87bf21877c77218a0c97ba98cb285b0c02eaaee3acd7c4513/rapidfuzz-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:cec3c0da88562727dd5a5a364bd9efeb535400ff0bfb1443156dd139a1dd7b50", size = 1968658 },
-    { url = "https://files.pythonhosted.org/packages/38/c0/fb02a0db80d95704b0a6469cc394e8c38501abf7e1c0b2afe3261d1510c2/rapidfuzz-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d1fa009f8b1100e4880868137e7bf0501422898f7674f2adcd85d5a67f041296", size = 1410742 },
-    { url = "https://files.pythonhosted.org/packages/a4/72/3fbf12819fc6afc8ec75a45204013b40979d068971e535a7f3512b05e765/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b86daa7419b5e8b180690efd1fdbac43ff19230803282521c5b5a9c83977655", size = 1382810 },
-    { url = "https://files.pythonhosted.org/packages/0f/18/0f1991d59bb7eee28922a00f79d83eafa8c7bfb4e8edebf4af2a160e7196/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7bd1816db05d6c5ffb3a4df0a2b7b56fb8c81ef584d08e37058afa217da91b1", size = 3166349 },
-    { url = "https://files.pythonhosted.org/packages/0d/f0/baa958b1989c8f88c78bbb329e969440cf330b5a01a982669986495bb980/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:33da4bbaf44e9755b0ce192597f3bde7372fe2e381ab305f41b707a95ac57aa7", size = 1214994 },
-    { url = "https://files.pythonhosted.org/packages/e4/a0/cd12ec71f9b2519a3954febc5740291cceabc64c87bc6433afcb36259f3b/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3fecce764cf5a991ee2195a844196da840aba72029b2612f95ac68a8b74946bf", size = 2403919 },
-    { url = "https://files.pythonhosted.org/packages/0b/ce/019bd2176c1644098eced4f0595cb4b3ef52e4941ac9a5854f209d0a6e16/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:ecd7453e02cf072258c3a6b8e930230d789d5d46cc849503729f9ce475d0e785", size = 2508346 },
-    { url = "https://files.pythonhosted.org/packages/23/f8/be16c68e2c9e6c4f23e8f4adbb7bccc9483200087ed28ff76c5312da9b14/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea188aa00e9bcae8c8411f006a5f2f06c4607a02f24eab0d8dc58566aa911f35", size = 4274105 },
-    { url = "https://files.pythonhosted.org/packages/a1/d1/5ab148e03f7e6ec8cd220ccf7af74d3aaa4de26dd96df58936beb7cba820/rapidfuzz-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:7ccbf68100c170e9a0581accbe9291850936711548c6688ce3bfb897b8c589ad", size = 1793465 },
-    { url = "https://files.pythonhosted.org/packages/cd/97/433b2d98e97abd9fff1c470a109b311669f44cdec8d0d5aa250aceaed1fb/rapidfuzz-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:9ec02e62ae765a318d6de38df609c57fc6dacc65c0ed1fd489036834fd8a620c", size = 1623491 },
-    { url = "https://files.pythonhosted.org/packages/e2/f6/e2176eb94f94892441bce3ddc514c179facb65db245e7ce3356965595b19/rapidfuzz-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:e805e52322ae29aa945baf7168b6c898120fbc16d2b8f940b658a5e9e3999253", size = 851487 },
+    { url = "https://files.pythonhosted.org/packages/fa/8e/3c215e860b458cfbedb3ed73bc72e98eb7e0ed72f6b48099604a7a3260c2/rapidfuzz-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:685c93ea961d135893b5984a5a9851637d23767feabe414ec974f43babbd8226", size = 1945306, upload-time = "2025-11-01T11:53:06.452Z" },
+    { url = "https://files.pythonhosted.org/packages/36/d9/31b33512015c899f4a6e6af64df8dfe8acddf4c8b40a4b3e0e6e1bcd00e5/rapidfuzz-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fa7c8f26f009f8c673fbfb443792f0cf8cf50c4e18121ff1e285b5e08a94fbdb", size = 1390788, upload-time = "2025-11-01T11:53:08.721Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/67/2ee6f8de6e2081ccd560a571d9c9063184fe467f484a17fa90311a7f4a2e/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:57f878330c8d361b2ce76cebb8e3e1dc827293b6abf404e67d53260d27b5d941", size = 1374580, upload-time = "2025-11-01T11:53:10.164Z" },
+    { url = "https://files.pythonhosted.org/packages/30/83/80d22997acd928eda7deadc19ccd15883904622396d6571e935993e0453a/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c5f545f454871e6af05753a0172849c82feaf0f521c5ca62ba09e1b382d6382", size = 3154947, upload-time = "2025-11-01T11:53:12.093Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/cf/9f49831085a16384695f9fb096b99662f589e30b89b4a589a1ebc1a19d34/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:07aa0b5d8863e3151e05026a28e0d924accf0a7a3b605da978f0359bb804df43", size = 1223872, upload-time = "2025-11-01T11:53:13.664Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/0f/41ee8034e744b871c2e071ef0d360686f5ccfe5659f4fd96c3ec406b3c8b/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73b07566bc7e010e7b5bd490fb04bb312e820970180df6b5655e9e6224c137db", size = 2392512, upload-time = "2025-11-01T11:53:15.109Z" },
+    { url = "https://files.pythonhosted.org/packages/da/86/280038b6b0c2ccec54fb957c732ad6b41cc1fd03b288d76545b9cf98343f/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6de00eb84c71476af7d3110cf25d8fe7c792d7f5fa86764ef0b4ca97e78ca3ed", size = 2521398, upload-time = "2025-11-01T11:53:17.146Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/7b/05c26f939607dca0006505e3216248ae2de631e39ef94dd63dbbf0860021/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d7843a1abf0091773a530636fdd2a49a41bcae22f9910b86b4f903e76ddc82dc", size = 4259416, upload-time = "2025-11-01T11:53:19.34Z" },
+    { url = "https://files.pythonhosted.org/packages/40/eb/9e3af4103d91788f81111af1b54a28de347cdbed8eaa6c91d5e98a889aab/rapidfuzz-3.14.3-cp312-cp312-win32.whl", hash = "sha256:dea97ac3ca18cd3ba8f3d04b5c1fe4aa60e58e8d9b7793d3bd595fdb04128d7a", size = 1709527, upload-time = "2025-11-01T11:53:20.949Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/63/d06ecce90e2cf1747e29aeab9f823d21e5877a4c51b79720b2d3be7848f8/rapidfuzz-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:b5100fd6bcee4d27f28f4e0a1c6b5127bc8ba7c2a9959cad9eab0bf4a7ab3329", size = 1538989, upload-time = "2025-11-01T11:53:22.428Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/6d/beee32dcda64af8128aab3ace2ccb33d797ed58c434c6419eea015fec779/rapidfuzz-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:4e49c9e992bc5fc873bd0fff7ef16a4405130ec42f2ce3d2b735ba5d3d4eb70f", size = 811161, upload-time = "2025-11-01T11:53:23.811Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/4f/0d94d09646853bd26978cb3a7541b6233c5760687777fa97da8de0d9a6ac/rapidfuzz-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dbcb726064b12f356bf10fffdb6db4b6dce5390b23627c08652b3f6e49aa56ae", size = 1939646, upload-time = "2025-11-01T11:53:25.292Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/eb/f96aefc00f3bbdbab9c0657363ea8437a207d7545ac1c3789673e05d80bd/rapidfuzz-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1704fc70d214294e554a2421b473779bcdeef715881c5e927dc0f11e1692a0ff", size = 1385512, upload-time = "2025-11-01T11:53:27.594Z" },
+    { url = "https://files.pythonhosted.org/packages/26/34/71c4f7749c12ee223dba90017a5947e8f03731a7cc9f489b662a8e9e643d/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc65e72790ddfd310c2c8912b45106e3800fefe160b0c2ef4d6b6fec4e826457", size = 1373571, upload-time = "2025-11-01T11:53:29.096Z" },
+    { url = "https://files.pythonhosted.org/packages/32/00/ec8597a64f2be301ce1ee3290d067f49f6a7afb226b67d5f15b56d772ba5/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43e38c1305cffae8472572a0584d4ffc2f130865586a81038ca3965301f7c97c", size = 3156759, upload-time = "2025-11-01T11:53:30.777Z" },
+    { url = "https://files.pythonhosted.org/packages/61/d5/b41eeb4930501cc899d5a9a7b5c9a33d85a670200d7e81658626dcc0ecc0/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:e195a77d06c03c98b3fc06b8a28576ba824392ce40de8c708f96ce04849a052e", size = 1222067, upload-time = "2025-11-01T11:53:32.334Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/7d/6d9abb4ffd1027c6ed837b425834f3bed8344472eb3a503ab55b3407c721/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1b7ef2f4b8583a744338a18f12c69693c194fb6777c0e9ada98cd4d9e8f09d10", size = 2394775, upload-time = "2025-11-01T11:53:34.24Z" },
+    { url = "https://files.pythonhosted.org/packages/15/ce/4f3ab4c401c5a55364da1ffff8cc879fc97b4e5f4fa96033827da491a973/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:a2135b138bcdcb4c3742d417f215ac2d8c2b87bde15b0feede231ae95f09ec41", size = 2526123, upload-time = "2025-11-01T11:53:35.779Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/4b/54f804975376a328f57293bd817c12c9036171d15cf7292032e3f5820b2d/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:33a325ed0e8e1aa20c3e75f8ab057a7b248fdea7843c2a19ade0008906c14af0", size = 4262874, upload-time = "2025-11-01T11:53:37.866Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/b6/958db27d8a29a50ee6edd45d33debd3ce732e7209183a72f57544cd5fe22/rapidfuzz-3.14.3-cp313-cp313-win32.whl", hash = "sha256:8383b6d0d92f6cd008f3c9216535be215a064b2cc890398a678b56e6d280cb63", size = 1707972, upload-time = "2025-11-01T11:53:39.442Z" },
+    { url = "https://files.pythonhosted.org/packages/07/75/fde1f334b0cec15b5946d9f84d73250fbfcc73c236b4bc1b25129d90876b/rapidfuzz-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:e6b5e3036976f0fde888687d91be86d81f9ac5f7b02e218913c38285b756be6c", size = 1537011, upload-time = "2025-11-01T11:53:40.92Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/d7/d83fe001ce599dc7ead57ba1debf923dc961b6bdce522b741e6b8c82f55c/rapidfuzz-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:7ba009977601d8b0828bfac9a110b195b3e4e79b350dcfa48c11269a9f1918a0", size = 810744, upload-time = "2025-11-01T11:53:42.723Z" },
+    { url = "https://files.pythonhosted.org/packages/92/13/a486369e63ff3c1a58444d16b15c5feb943edd0e6c28a1d7d67cb8946b8f/rapidfuzz-3.14.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a0a28add871425c2fe94358c6300bbeb0bc2ed828ca003420ac6825408f5a424", size = 1967702, upload-time = "2025-11-01T11:53:44.554Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/82/efad25e260b7810f01d6b69122685e355bed78c94a12784bac4e0beb2afb/rapidfuzz-3.14.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:010e12e2411a4854b0434f920e72b717c43f8ec48d57e7affe5c42ecfa05dd0e", size = 1410702, upload-time = "2025-11-01T11:53:46.066Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/1a/34c977b860cde91082eae4a97ae503f43e0d84d4af301d857679b66f9869/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cfc3d57abd83c734d1714ec39c88a34dd69c85474918ebc21296f1e61eb5ca8", size = 1382337, upload-time = "2025-11-01T11:53:47.62Z" },
+    { url = "https://files.pythonhosted.org/packages/88/74/f50ea0e24a5880a9159e8fd256b84d8f4634c2f6b4f98028bdd31891d907/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89acb8cbb52904f763e5ac238083b9fc193bed8d1f03c80568b20e4cef43a519", size = 3165563, upload-time = "2025-11-01T11:53:49.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/7a/e744359404d7737049c26099423fc54bcbf303de5d870d07d2fb1410f567/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_31_armv7l.whl", hash = "sha256:7d9af908c2f371bfb9c985bd134e295038e3031e666e4b2ade1e7cb7f5af2f1a", size = 1214727, upload-time = "2025-11-01T11:53:50.883Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/2e/87adfe14ce75768ec6c2b8acd0e05e85e84be4be5e3d283cdae360afc4fe/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1f1925619627f8798f8c3a391d81071336942e5fe8467bc3c567f982e7ce2897", size = 2403349, upload-time = "2025-11-01T11:53:52.322Z" },
+    { url = "https://files.pythonhosted.org/packages/70/17/6c0b2b2bff9c8b12e12624c07aa22e922b0c72a490f180fa9183d1ef2c75/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:152555187360978119e98ce3e8263d70dd0c40c7541193fc302e9b7125cf8f58", size = 2507596, upload-time = "2025-11-01T11:53:53.835Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/d1/87852a7cbe4da7b962174c749a47433881a63a817d04f3e385ea9babcd9e/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:52619d25a09546b8db078981ca88939d72caa6b8701edd8b22e16482a38e799f", size = 4273595, upload-time = "2025-11-01T11:53:55.961Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ab/1d0354b7d1771a28fa7fe089bc23acec2bdd3756efa2419f463e3ed80e16/rapidfuzz-3.14.3-cp313-cp313t-win32.whl", hash = "sha256:489ce98a895c98cad284f0a47960c3e264c724cb4cfd47a1430fa091c0c25204", size = 1757773, upload-time = "2025-11-01T11:53:57.628Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/0c/71ef356adc29e2bdf74cd284317b34a16b80258fa0e7e242dd92cc1e6d10/rapidfuzz-3.14.3-cp313-cp313t-win_amd64.whl", hash = "sha256:656e52b054d5b5c2524169240e50cfa080b04b1c613c5f90a2465e84888d6f15", size = 1576797, upload-time = "2025-11-01T11:53:59.455Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/d2/0e64fc27bb08d4304aa3d11154eb5480bcf5d62d60140a7ee984dc07468a/rapidfuzz-3.14.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c7e40c0a0af02ad6e57e89f62bef8604f55a04ecae90b0ceeda591bbf5923317", size = 829940, upload-time = "2025-11-01T11:54:01.1Z" },
+    { url = "https://files.pythonhosted.org/packages/32/6f/1b88aaeade83abc5418788f9e6b01efefcd1a69d65ded37d89cd1662be41/rapidfuzz-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:442125473b247227d3f2de807a11da6c08ccf536572d1be943f8e262bae7e4ea", size = 1942086, upload-time = "2025-11-01T11:54:02.592Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/2c/b23861347436cb10f46c2bd425489ec462790faaa360a54a7ede5f78de88/rapidfuzz-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ec0c8c0c3d4f97ced46b2e191e883f8c82dbbf6d5ebc1842366d7eff13cd5a6", size = 1386993, upload-time = "2025-11-01T11:54:04.12Z" },
+    { url = "https://files.pythonhosted.org/packages/83/86/5d72e2c060aa1fbdc1f7362d938f6b237dff91f5b9fc5dd7cc297e112250/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2dc37bc20272f388b8c3a4eba4febc6e77e50a8f450c472def4751e7678f55e4", size = 1379126, upload-time = "2025-11-01T11:54:05.777Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/bc/ef2cee3e4d8b3fc22705ff519f0d487eecc756abdc7c25d53686689d6cf2/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dee362e7e79bae940a5e2b3f6d09c6554db6a4e301cc68343886c08be99844f1", size = 3159304, upload-time = "2025-11-01T11:54:07.351Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/36/dc5f2f62bbc7bc90be1f75eeaf49ed9502094bb19290dfb4747317b17f12/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:4b39921df948388a863f0e267edf2c36302983459b021ab928d4b801cbe6a421", size = 1218207, upload-time = "2025-11-01T11:54:09.641Z" },
+    { url = "https://files.pythonhosted.org/packages/df/7e/8f4be75c1bc62f47edf2bbbe2370ee482fae655ebcc4718ac3827ead3904/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:beda6aa9bc44d1d81242e7b291b446be352d3451f8217fcb068fc2933927d53b", size = 2401245, upload-time = "2025-11-01T11:54:11.543Z" },
+    { url = "https://files.pythonhosted.org/packages/05/38/f7c92759e1bb188dd05b80d11c630ba59b8d7856657baf454ff56059c2ab/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:6a014ba09657abfcfeed64b7d09407acb29af436d7fc075b23a298a7e4a6b41c", size = 2518308, upload-time = "2025-11-01T11:54:13.134Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/ac/85820f70fed5ecb5f1d9a55f1e1e2090ef62985ef41db289b5ac5ec56e28/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:32eeafa3abce138bb725550c0e228fc7eaeec7059aa8093d9cbbec2b58c2371a", size = 4265011, upload-time = "2025-11-01T11:54:15.087Z" },
+    { url = "https://files.pythonhosted.org/packages/46/a9/616930721ea9835c918af7cde22bff17f9db3639b0c1a7f96684be7f5630/rapidfuzz-3.14.3-cp314-cp314-win32.whl", hash = "sha256:adb44d996fc610c7da8c5048775b21db60dd63b1548f078e95858c05c86876a3", size = 1742245, upload-time = "2025-11-01T11:54:17.19Z" },
+    { url = "https://files.pythonhosted.org/packages/06/8a/f2fa5e9635b1ccafda4accf0e38246003f69982d7c81f2faa150014525a4/rapidfuzz-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:f3d15d8527e2b293e38ce6e437631af0708df29eafd7c9fc48210854c94472f9", size = 1584856, upload-time = "2025-11-01T11:54:18.764Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/97/09e20663917678a6d60d8e0e29796db175b1165e2079830430342d5298be/rapidfuzz-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:576e4b9012a67e0bf54fccb69a7b6c94d4e86a9540a62f1a5144977359133583", size = 833490, upload-time = "2025-11-01T11:54:20.753Z" },
+    { url = "https://files.pythonhosted.org/packages/03/1b/6b6084576ba87bf21877c77218a0c97ba98cb285b0c02eaaee3acd7c4513/rapidfuzz-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:cec3c0da88562727dd5a5a364bd9efeb535400ff0bfb1443156dd139a1dd7b50", size = 1968658, upload-time = "2025-11-01T11:54:22.25Z" },
+    { url = "https://files.pythonhosted.org/packages/38/c0/fb02a0db80d95704b0a6469cc394e8c38501abf7e1c0b2afe3261d1510c2/rapidfuzz-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d1fa009f8b1100e4880868137e7bf0501422898f7674f2adcd85d5a67f041296", size = 1410742, upload-time = "2025-11-01T11:54:23.863Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/72/3fbf12819fc6afc8ec75a45204013b40979d068971e535a7f3512b05e765/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b86daa7419b5e8b180690efd1fdbac43ff19230803282521c5b5a9c83977655", size = 1382810, upload-time = "2025-11-01T11:54:25.571Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/18/0f1991d59bb7eee28922a00f79d83eafa8c7bfb4e8edebf4af2a160e7196/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7bd1816db05d6c5ffb3a4df0a2b7b56fb8c81ef584d08e37058afa217da91b1", size = 3166349, upload-time = "2025-11-01T11:54:27.195Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f0/baa958b1989c8f88c78bbb329e969440cf330b5a01a982669986495bb980/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:33da4bbaf44e9755b0ce192597f3bde7372fe2e381ab305f41b707a95ac57aa7", size = 1214994, upload-time = "2025-11-01T11:54:28.821Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/a0/cd12ec71f9b2519a3954febc5740291cceabc64c87bc6433afcb36259f3b/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3fecce764cf5a991ee2195a844196da840aba72029b2612f95ac68a8b74946bf", size = 2403919, upload-time = "2025-11-01T11:54:30.393Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/ce/019bd2176c1644098eced4f0595cb4b3ef52e4941ac9a5854f209d0a6e16/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:ecd7453e02cf072258c3a6b8e930230d789d5d46cc849503729f9ce475d0e785", size = 2508346, upload-time = "2025-11-01T11:54:32.048Z" },
+    { url = "https://files.pythonhosted.org/packages/23/f8/be16c68e2c9e6c4f23e8f4adbb7bccc9483200087ed28ff76c5312da9b14/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea188aa00e9bcae8c8411f006a5f2f06c4607a02f24eab0d8dc58566aa911f35", size = 4274105, upload-time = "2025-11-01T11:54:33.701Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/d1/5ab148e03f7e6ec8cd220ccf7af74d3aaa4de26dd96df58936beb7cba820/rapidfuzz-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:7ccbf68100c170e9a0581accbe9291850936711548c6688ce3bfb897b8c589ad", size = 1793465, upload-time = "2025-11-01T11:54:35.331Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/97/433b2d98e97abd9fff1c470a109b311669f44cdec8d0d5aa250aceaed1fb/rapidfuzz-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:9ec02e62ae765a318d6de38df609c57fc6dacc65c0ed1fd489036834fd8a620c", size = 1623491, upload-time = "2025-11-01T11:54:38.085Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/f6/e2176eb94f94892441bce3ddc514c179facb65db245e7ce3356965595b19/rapidfuzz-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:e805e52322ae29aa945baf7168b6c898120fbc16d2b8f940b658a5e9e3999253", size = 851487, upload-time = "2025-11-01T11:54:40.176Z" },
 ]
 
 [[package]]
@@ -897,9 +1008,34 @@ dependencies = [
     { name = "idna" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517 }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738 },
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/31/d6e536cdebb6568ae75a7f00e4b4819ae0ad2640c3604c305a0428680b0c/ruff-0.15.4.tar.gz", hash = "sha256:3412195319e42d634470cc97aa9803d07e9d5c9223b99bcb1518f0c725f26ae1", size = 4569550, upload-time = "2026-02-26T20:04:14.959Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/82/c11a03cfec3a4d26a0ea1e571f0f44be5993b923f905eeddfc397c13d360/ruff-0.15.4-py3-none-linux_armv6l.whl", hash = "sha256:a1810931c41606c686bae8b5b9a8072adac2f611bb433c0ba476acba17a332e0", size = 10453333, upload-time = "2026-02-26T20:04:20.093Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/5d/6a1f271f6e31dffb31855996493641edc3eef8077b883eaf007a2f1c2976/ruff-0.15.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5a1632c66672b8b4d3e1d1782859e98d6e0b4e70829530666644286600a33992", size = 10853356, upload-time = "2026-02-26T20:04:05.808Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/d8/0fab9f8842b83b1a9c2bf81b85063f65e93fb512e60effa95b0be49bfc54/ruff-0.15.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a4386ba2cd6c0f4ff75252845906acc7c7c8e1ac567b7bc3d373686ac8c222ba", size = 10187434, upload-time = "2026-02-26T20:03:54.656Z" },
+    { url = "https://files.pythonhosted.org/packages/85/cc/cc220fd9394eff5db8d94dec199eec56dd6c9f3651d8869d024867a91030/ruff-0.15.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2496488bdfd3732747558b6f95ae427ff066d1fcd054daf75f5a50674411e75", size = 10535456, upload-time = "2026-02-26T20:03:52.738Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/0f/bced38fa5cf24373ec767713c8e4cadc90247f3863605fb030e597878661/ruff-0.15.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3f1c4893841ff2d54cbda1b2860fa3260173df5ddd7b95d370186f8a5e66a4ac", size = 10287772, upload-time = "2026-02-26T20:04:08.138Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/90/58a1802d84fed15f8f281925b21ab3cecd813bde52a8ca033a4de8ab0e7a/ruff-0.15.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:820b8766bd65503b6c30aaa6331e8ef3a6e564f7999c844e9a547c40179e440a", size = 11049051, upload-time = "2026-02-26T20:04:03.53Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ac/b7ad36703c35f3866584564dc15f12f91cb1a26a897dc2fd13d7cb3ae1af/ruff-0.15.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9fb74bab47139c1751f900f857fa503987253c3ef89129b24ed375e72873e85", size = 11890494, upload-time = "2026-02-26T20:04:10.497Z" },
+    { url = "https://files.pythonhosted.org/packages/93/3d/3eb2f47a39a8b0da99faf9c54d3eb24720add1e886a5309d4d1be73a6380/ruff-0.15.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f80c98765949c518142b3a50a5db89343aa90f2c2bf7799de9986498ae6176db", size = 11326221, upload-time = "2026-02-26T20:04:12.84Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/90/bf134f4c1e5243e62690e09d63c55df948a74084c8ac3e48a88468314da6/ruff-0.15.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:451a2e224151729b3b6c9ffb36aed9091b2996fe4bdbd11f47e27d8f2e8888ec", size = 11168459, upload-time = "2026-02-26T20:04:00.969Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/e5/a64d27688789b06b5d55162aafc32059bb8c989c61a5139a36e1368285eb/ruff-0.15.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a8f157f2e583c513c4f5f896163a93198297371f34c04220daf40d133fdd4f7f", size = 11104366, upload-time = "2026-02-26T20:03:48.099Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/f6/32d1dcb66a2559763fc3027bdd65836cad9eb09d90f2ed6a63d8e9252b02/ruff-0.15.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:917cc68503357021f541e69b35361c99387cdbbf99bd0ea4aa6f28ca99ff5338", size = 10510887, upload-time = "2026-02-26T20:03:45.771Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/92/22d1ced50971c5b6433aed166fcef8c9343f567a94cf2b9d9089f6aa80fe/ruff-0.15.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e9737c8161da79fd7cfec19f1e35620375bd8b2a50c3e77fa3d2c16f574105cc", size = 10285939, upload-time = "2026-02-26T20:04:22.42Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/f4/7c20aec3143837641a02509a4668fb146a642fd1211846634edc17eb5563/ruff-0.15.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:291258c917539e18f6ba40482fe31d6f5ac023994ee11d7bdafd716f2aab8a68", size = 10765471, upload-time = "2026-02-26T20:03:58.924Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/09/6d2f7586f09a16120aebdff8f64d962d7c4348313c77ebb29c566cefc357/ruff-0.15.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3f83c45911da6f2cd5936c436cf86b9f09f09165f033a99dcf7477e34041cbc3", size = 11263382, upload-time = "2026-02-26T20:04:24.424Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/fa/2ef715a1cd329ef47c1a050e10dee91a9054b7ce2fcfdd6a06d139afb7ec/ruff-0.15.4-py3-none-win32.whl", hash = "sha256:65594a2d557d4ee9f02834fcdf0a28daa8b3b9f6cb2cb93846025a36db47ef22", size = 10506664, upload-time = "2026-02-26T20:03:50.56Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/a8/c688ef7e29983976820d18710f955751d9f4d4eb69df658af3d006e2ba3e/ruff-0.15.4-py3-none-win_amd64.whl", hash = "sha256:04196ad44f0df220c2ece5b0e959c2f37c777375ec744397d21d15b50a75264f", size = 11651048, upload-time = "2026-02-26T20:04:17.191Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/0a/9e1be9035b37448ce2e68c978f0591da94389ade5a5abafa4cf99985d1b2/ruff-0.15.4-py3-none-win_arm64.whl", hash = "sha256:60d5177e8cfc70e51b9c5fad936c634872a74209f934c1e79107d11787ad5453", size = 10966776, upload-time = "2026-02-26T20:03:56.908Z" },
 ]
 
 [[package]]
@@ -923,8 +1059,10 @@ dependencies = [
 
 [package.optional-dependencies]
 dev = [
+    { name = "mypy" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
+    { name = "ruff" },
 ]
 
 [package.metadata]
@@ -936,10 +1074,12 @@ requires-dist = [
     { name = "fastapi", specifier = ">=0.116,<0.117" },
     { name = "httpx", specifier = ">=0.28,<0.29" },
     { name = "itsdangerous", specifier = ">=2.2,<3.0" },
+    { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.14" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.3,<9.0" },
     { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.25,<0.26" },
     { name = "python-multipart", specifier = ">=0.0.9,<0.1" },
     { name = "rapidfuzz", specifier = ">=3.14.3" },
+    { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.9" },
     { name = "sqlalchemy", specifier = ">=2.0,<2.1" },
     { name = "tenacity", specifier = ">=9.1.4" },
     { name = "uvicorn", extras = ["standard"], specifier = ">=0.34,<0.35" },
@@ -954,38 +1094,38 @@ dependencies = [
     { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/06/aa/9ce0f3e7a9829ead5c8ce549392f33a12c4555a6c0609bb27d882e9c7ddf/sqlalchemy-2.0.46.tar.gz", hash = "sha256:cf36851ee7219c170bb0793dbc3da3e80c582e04a5437bc601bfe8c85c9216d7", size = 9865393 }
+sdist = { url = "https://files.pythonhosted.org/packages/06/aa/9ce0f3e7a9829ead5c8ce549392f33a12c4555a6c0609bb27d882e9c7ddf/sqlalchemy-2.0.46.tar.gz", hash = "sha256:cf36851ee7219c170bb0793dbc3da3e80c582e04a5437bc601bfe8c85c9216d7", size = 9865393, upload-time = "2026-01-21T18:03:45.119Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b6/35/d16bfa235c8b7caba3730bba43e20b1e376d2224f407c178fbf59559f23e/sqlalchemy-2.0.46-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a9a72b0da8387f15d5810f1facca8f879de9b85af8c645138cba61ea147968c", size = 2153405 },
-    { url = "https://files.pythonhosted.org/packages/06/6c/3192e24486749862f495ddc6584ed730c0c994a67550ec395d872a2ad650/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2347c3f0efc4de367ba00218e0ae5c4ba2306e47216ef80d6e31761ac97cb0b9", size = 3334702 },
-    { url = "https://files.pythonhosted.org/packages/ea/a2/b9f33c8d68a3747d972a0bb758c6b63691f8fb8a49014bc3379ba15d4274/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9094c8b3197db12aa6f05c51c05daaad0a92b8c9af5388569847b03b1007fb1b", size = 3347664 },
-    { url = "https://files.pythonhosted.org/packages/aa/d2/3e59e2a91eaec9db7e8dc6b37b91489b5caeb054f670f32c95bcba98940f/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37fee2164cf21417478b6a906adc1a91d69ae9aba8f9533e67ce882f4bb1de53", size = 3277372 },
-    { url = "https://files.pythonhosted.org/packages/dd/dd/67bc2e368b524e2192c3927b423798deda72c003e73a1e94c21e74b20a85/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b1e14b2f6965a685c7128bd315e27387205429c2e339eeec55cb75ca4ab0ea2e", size = 3312425 },
-    { url = "https://files.pythonhosted.org/packages/43/82/0ecd68e172bfe62247e96cb47867c2d68752566811a4e8c9d8f6e7c38a65/sqlalchemy-2.0.46-cp312-cp312-win32.whl", hash = "sha256:412f26bb4ba942d52016edc8d12fb15d91d3cd46b0047ba46e424213ad407bcb", size = 2113155 },
-    { url = "https://files.pythonhosted.org/packages/bc/2a/2821a45742073fc0331dc132552b30de68ba9563230853437cac54b2b53e/sqlalchemy-2.0.46-cp312-cp312-win_amd64.whl", hash = "sha256:ea3cd46b6713a10216323cda3333514944e510aa691c945334713fca6b5279ff", size = 2140078 },
-    { url = "https://files.pythonhosted.org/packages/b3/4b/fa7838fe20bb752810feed60e45625a9a8b0102c0c09971e2d1d95362992/sqlalchemy-2.0.46-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:93a12da97cca70cea10d4b4fc602589c4511f96c1f8f6c11817620c021d21d00", size = 2150268 },
-    { url = "https://files.pythonhosted.org/packages/46/c1/b34dccd712e8ea846edf396e00973dda82d598cb93762e55e43e6835eba9/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af865c18752d416798dae13f83f38927c52f085c52e2f32b8ab0fef46fdd02c2", size = 3276511 },
-    { url = "https://files.pythonhosted.org/packages/96/48/a04d9c94753e5d5d096c628c82a98c4793b9c08ca0e7155c3eb7d7db9f24/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d679b5f318423eacb61f933a9a0f75535bfca7056daeadbf6bd5bcee6183aee", size = 3292881 },
-    { url = "https://files.pythonhosted.org/packages/be/f4/06eda6e91476f90a7d8058f74311cb65a2fb68d988171aced81707189131/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64901e08c33462acc9ec3bad27fc7a5c2b6491665f2aa57564e57a4f5d7c52ad", size = 3224559 },
-    { url = "https://files.pythonhosted.org/packages/ab/a2/d2af04095412ca6345ac22b33b89fe8d6f32a481e613ffcb2377d931d8d0/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8ac45e8f4eaac0f9f8043ea0e224158855c6a4329fd4ee37c45c61e3beb518e", size = 3262728 },
-    { url = "https://files.pythonhosted.org/packages/31/48/1980c7caa5978a3b8225b4d230e69a2a6538a3562b8b31cea679b6933c83/sqlalchemy-2.0.46-cp313-cp313-win32.whl", hash = "sha256:8d3b44b3d0ab2f1319d71d9863d76eeb46766f8cf9e921ac293511804d39813f", size = 2111295 },
-    { url = "https://files.pythonhosted.org/packages/2d/54/f8d65bbde3d877617c4720f3c9f60e99bb7266df0d5d78b6e25e7c149f35/sqlalchemy-2.0.46-cp313-cp313-win_amd64.whl", hash = "sha256:77f8071d8fbcbb2dd11b7fd40dedd04e8ebe2eb80497916efedba844298065ef", size = 2137076 },
-    { url = "https://files.pythonhosted.org/packages/56/ba/9be4f97c7eb2b9d5544f2624adfc2853e796ed51d2bb8aec90bc94b7137e/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1e8cc6cc01da346dc92d9509a63033b9b1bda4fed7a7a7807ed385c7dccdc10", size = 3556533 },
-    { url = "https://files.pythonhosted.org/packages/20/a6/b1fc6634564dbb4415b7ed6419cdfeaadefd2c39cdab1e3aa07a5f2474c2/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96c7cca1a4babaaf3bfff3e4e606e38578856917e52f0384635a95b226c87764", size = 3523208 },
-    { url = "https://files.pythonhosted.org/packages/a1/d8/41e0bdfc0f930ff236f86fccd12962d8fa03713f17ed57332d38af6a3782/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b2a9f9aee38039cf4755891a1e50e1effcc42ea6ba053743f452c372c3152b1b", size = 3464292 },
-    { url = "https://files.pythonhosted.org/packages/f0/8b/9dcbec62d95bea85f5ecad9b8d65b78cc30fb0ffceeb3597961f3712549b/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:db23b1bf8cfe1f7fda19018e7207b20cdb5168f83c437ff7e95d19e39289c447", size = 3473497 },
-    { url = "https://files.pythonhosted.org/packages/e9/f8/5ecdfc73383ec496de038ed1614de9e740a82db9ad67e6e4514ebc0708a3/sqlalchemy-2.0.46-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:56bdd261bfd0895452006d5316cbf35739c53b9bb71a170a331fa0ea560b2ada", size = 2152079 },
-    { url = "https://files.pythonhosted.org/packages/e5/bf/eba3036be7663ce4d9c050bc3d63794dc29fbe01691f2bf5ccb64e048d20/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33e462154edb9493f6c3ad2125931e273bbd0be8ae53f3ecd1c161ea9a1dd366", size = 3272216 },
-    { url = "https://files.pythonhosted.org/packages/05/45/1256fb597bb83b58a01ddb600c59fe6fdf0e5afe333f0456ed75c0f8d7bd/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bcdce05f056622a632f1d44bb47dbdb677f58cad393612280406ce37530eb6d", size = 3277208 },
-    { url = "https://files.pythonhosted.org/packages/d9/a0/2053b39e4e63b5d7ceb3372cface0859a067c1ddbd575ea7e9985716f771/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e84b09a9b0f19accedcbeff5c2caf36e0dd537341a33aad8d680336152dc34e", size = 3221994 },
-    { url = "https://files.pythonhosted.org/packages/1e/87/97713497d9502553c68f105a1cb62786ba1ee91dea3852ae4067ed956a50/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4f52f7291a92381e9b4de9050b0a65ce5d6a763333406861e33906b8aa4906bf", size = 3243990 },
-    { url = "https://files.pythonhosted.org/packages/a8/87/5d1b23548f420ff823c236f8bea36b1a997250fd2f892e44a3838ca424f4/sqlalchemy-2.0.46-cp314-cp314-win32.whl", hash = "sha256:70ed2830b169a9960193f4d4322d22be5c0925357d82cbf485b3369893350908", size = 2114215 },
-    { url = "https://files.pythonhosted.org/packages/3a/20/555f39cbcf0c10cf452988b6a93c2a12495035f68b3dbd1a408531049d31/sqlalchemy-2.0.46-cp314-cp314-win_amd64.whl", hash = "sha256:3c32e993bc57be6d177f7d5d31edb93f30726d798ad86ff9066d75d9bf2e0b6b", size = 2139867 },
-    { url = "https://files.pythonhosted.org/packages/3e/f0/f96c8057c982d9d8a7a68f45d69c674bc6f78cad401099692fe16521640a/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4dafb537740eef640c4d6a7c254611dca2df87eaf6d14d6a5fca9d1f4c3fc0fa", size = 3561202 },
-    { url = "https://files.pythonhosted.org/packages/d7/53/3b37dda0a5b137f21ef608d8dfc77b08477bab0fe2ac9d3e0a66eaeab6fc/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42a1643dc5427b69aca967dae540a90b0fbf57eaf248f13a90ea5930e0966863", size = 3526296 },
-    { url = "https://files.pythonhosted.org/packages/33/75/f28622ba6dde79cd545055ea7bd4062dc934e0621f7b3be2891f8563f8de/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ff33c6e6ad006bbc0f34f5faf941cfc62c45841c64c0a058ac38c799f15b5ede", size = 3470008 },
-    { url = "https://files.pythonhosted.org/packages/a9/42/4afecbbc38d5e99b18acef446453c76eec6fbd03db0a457a12a056836e22/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82ec52100ec1e6ec671563bbd02d7c7c8d0b9e71a0723c72f22ecf52d1755330", size = 3476137 },
-    { url = "https://files.pythonhosted.org/packages/fc/a1/9c4efa03300926601c19c18582531b45aededfb961ab3c3585f1e24f120b/sqlalchemy-2.0.46-py3-none-any.whl", hash = "sha256:f9c11766e7e7c0a2767dda5acb006a118640c9fc0a4104214b96269bfb78399e", size = 1937882 },
+    { url = "https://files.pythonhosted.org/packages/b6/35/d16bfa235c8b7caba3730bba43e20b1e376d2224f407c178fbf59559f23e/sqlalchemy-2.0.46-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a9a72b0da8387f15d5810f1facca8f879de9b85af8c645138cba61ea147968c", size = 2153405, upload-time = "2026-01-21T19:05:54.143Z" },
+    { url = "https://files.pythonhosted.org/packages/06/6c/3192e24486749862f495ddc6584ed730c0c994a67550ec395d872a2ad650/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2347c3f0efc4de367ba00218e0ae5c4ba2306e47216ef80d6e31761ac97cb0b9", size = 3334702, upload-time = "2026-01-21T18:46:45.384Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/a2/b9f33c8d68a3747d972a0bb758c6b63691f8fb8a49014bc3379ba15d4274/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9094c8b3197db12aa6f05c51c05daaad0a92b8c9af5388569847b03b1007fb1b", size = 3347664, upload-time = "2026-01-21T18:40:09.979Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/d2/3e59e2a91eaec9db7e8dc6b37b91489b5caeb054f670f32c95bcba98940f/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37fee2164cf21417478b6a906adc1a91d69ae9aba8f9533e67ce882f4bb1de53", size = 3277372, upload-time = "2026-01-21T18:46:47.168Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/dd/67bc2e368b524e2192c3927b423798deda72c003e73a1e94c21e74b20a85/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b1e14b2f6965a685c7128bd315e27387205429c2e339eeec55cb75ca4ab0ea2e", size = 3312425, upload-time = "2026-01-21T18:40:11.548Z" },
+    { url = "https://files.pythonhosted.org/packages/43/82/0ecd68e172bfe62247e96cb47867c2d68752566811a4e8c9d8f6e7c38a65/sqlalchemy-2.0.46-cp312-cp312-win32.whl", hash = "sha256:412f26bb4ba942d52016edc8d12fb15d91d3cd46b0047ba46e424213ad407bcb", size = 2113155, upload-time = "2026-01-21T18:42:49.748Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/2a/2821a45742073fc0331dc132552b30de68ba9563230853437cac54b2b53e/sqlalchemy-2.0.46-cp312-cp312-win_amd64.whl", hash = "sha256:ea3cd46b6713a10216323cda3333514944e510aa691c945334713fca6b5279ff", size = 2140078, upload-time = "2026-01-21T18:42:51.197Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/4b/fa7838fe20bb752810feed60e45625a9a8b0102c0c09971e2d1d95362992/sqlalchemy-2.0.46-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:93a12da97cca70cea10d4b4fc602589c4511f96c1f8f6c11817620c021d21d00", size = 2150268, upload-time = "2026-01-21T19:05:56.621Z" },
+    { url = "https://files.pythonhosted.org/packages/46/c1/b34dccd712e8ea846edf396e00973dda82d598cb93762e55e43e6835eba9/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af865c18752d416798dae13f83f38927c52f085c52e2f32b8ab0fef46fdd02c2", size = 3276511, upload-time = "2026-01-21T18:46:49.022Z" },
+    { url = "https://files.pythonhosted.org/packages/96/48/a04d9c94753e5d5d096c628c82a98c4793b9c08ca0e7155c3eb7d7db9f24/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d679b5f318423eacb61f933a9a0f75535bfca7056daeadbf6bd5bcee6183aee", size = 3292881, upload-time = "2026-01-21T18:40:13.089Z" },
+    { url = "https://files.pythonhosted.org/packages/be/f4/06eda6e91476f90a7d8058f74311cb65a2fb68d988171aced81707189131/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64901e08c33462acc9ec3bad27fc7a5c2b6491665f2aa57564e57a4f5d7c52ad", size = 3224559, upload-time = "2026-01-21T18:46:50.974Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a2/d2af04095412ca6345ac22b33b89fe8d6f32a481e613ffcb2377d931d8d0/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8ac45e8f4eaac0f9f8043ea0e224158855c6a4329fd4ee37c45c61e3beb518e", size = 3262728, upload-time = "2026-01-21T18:40:14.883Z" },
+    { url = "https://files.pythonhosted.org/packages/31/48/1980c7caa5978a3b8225b4d230e69a2a6538a3562b8b31cea679b6933c83/sqlalchemy-2.0.46-cp313-cp313-win32.whl", hash = "sha256:8d3b44b3d0ab2f1319d71d9863d76eeb46766f8cf9e921ac293511804d39813f", size = 2111295, upload-time = "2026-01-21T18:42:52.366Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/54/f8d65bbde3d877617c4720f3c9f60e99bb7266df0d5d78b6e25e7c149f35/sqlalchemy-2.0.46-cp313-cp313-win_amd64.whl", hash = "sha256:77f8071d8fbcbb2dd11b7fd40dedd04e8ebe2eb80497916efedba844298065ef", size = 2137076, upload-time = "2026-01-21T18:42:53.924Z" },
+    { url = "https://files.pythonhosted.org/packages/56/ba/9be4f97c7eb2b9d5544f2624adfc2853e796ed51d2bb8aec90bc94b7137e/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1e8cc6cc01da346dc92d9509a63033b9b1bda4fed7a7a7807ed385c7dccdc10", size = 3556533, upload-time = "2026-01-21T18:33:06.636Z" },
+    { url = "https://files.pythonhosted.org/packages/20/a6/b1fc6634564dbb4415b7ed6419cdfeaadefd2c39cdab1e3aa07a5f2474c2/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96c7cca1a4babaaf3bfff3e4e606e38578856917e52f0384635a95b226c87764", size = 3523208, upload-time = "2026-01-21T18:45:08.436Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/d8/41e0bdfc0f930ff236f86fccd12962d8fa03713f17ed57332d38af6a3782/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b2a9f9aee38039cf4755891a1e50e1effcc42ea6ba053743f452c372c3152b1b", size = 3464292, upload-time = "2026-01-21T18:33:08.208Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/8b/9dcbec62d95bea85f5ecad9b8d65b78cc30fb0ffceeb3597961f3712549b/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:db23b1bf8cfe1f7fda19018e7207b20cdb5168f83c437ff7e95d19e39289c447", size = 3473497, upload-time = "2026-01-21T18:45:10.552Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/f8/5ecdfc73383ec496de038ed1614de9e740a82db9ad67e6e4514ebc0708a3/sqlalchemy-2.0.46-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:56bdd261bfd0895452006d5316cbf35739c53b9bb71a170a331fa0ea560b2ada", size = 2152079, upload-time = "2026-01-21T19:05:58.477Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/bf/eba3036be7663ce4d9c050bc3d63794dc29fbe01691f2bf5ccb64e048d20/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33e462154edb9493f6c3ad2125931e273bbd0be8ae53f3ecd1c161ea9a1dd366", size = 3272216, upload-time = "2026-01-21T18:46:52.634Z" },
+    { url = "https://files.pythonhosted.org/packages/05/45/1256fb597bb83b58a01ddb600c59fe6fdf0e5afe333f0456ed75c0f8d7bd/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bcdce05f056622a632f1d44bb47dbdb677f58cad393612280406ce37530eb6d", size = 3277208, upload-time = "2026-01-21T18:40:16.38Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/a0/2053b39e4e63b5d7ceb3372cface0859a067c1ddbd575ea7e9985716f771/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e84b09a9b0f19accedcbeff5c2caf36e0dd537341a33aad8d680336152dc34e", size = 3221994, upload-time = "2026-01-21T18:46:54.622Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/87/97713497d9502553c68f105a1cb62786ba1ee91dea3852ae4067ed956a50/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4f52f7291a92381e9b4de9050b0a65ce5d6a763333406861e33906b8aa4906bf", size = 3243990, upload-time = "2026-01-21T18:40:18.253Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/87/5d1b23548f420ff823c236f8bea36b1a997250fd2f892e44a3838ca424f4/sqlalchemy-2.0.46-cp314-cp314-win32.whl", hash = "sha256:70ed2830b169a9960193f4d4322d22be5c0925357d82cbf485b3369893350908", size = 2114215, upload-time = "2026-01-21T18:42:55.232Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/20/555f39cbcf0c10cf452988b6a93c2a12495035f68b3dbd1a408531049d31/sqlalchemy-2.0.46-cp314-cp314-win_amd64.whl", hash = "sha256:3c32e993bc57be6d177f7d5d31edb93f30726d798ad86ff9066d75d9bf2e0b6b", size = 2139867, upload-time = "2026-01-21T18:42:56.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/f0/f96c8057c982d9d8a7a68f45d69c674bc6f78cad401099692fe16521640a/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4dafb537740eef640c4d6a7c254611dca2df87eaf6d14d6a5fca9d1f4c3fc0fa", size = 3561202, upload-time = "2026-01-21T18:33:10.337Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/53/3b37dda0a5b137f21ef608d8dfc77b08477bab0fe2ac9d3e0a66eaeab6fc/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42a1643dc5427b69aca967dae540a90b0fbf57eaf248f13a90ea5930e0966863", size = 3526296, upload-time = "2026-01-21T18:45:12.657Z" },
+    { url = "https://files.pythonhosted.org/packages/33/75/f28622ba6dde79cd545055ea7bd4062dc934e0621f7b3be2891f8563f8de/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ff33c6e6ad006bbc0f34f5faf941cfc62c45841c64c0a058ac38c799f15b5ede", size = 3470008, upload-time = "2026-01-21T18:33:11.725Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/42/4afecbbc38d5e99b18acef446453c76eec6fbd03db0a457a12a056836e22/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82ec52100ec1e6ec671563bbd02d7c7c8d0b9e71a0723c72f22ecf52d1755330", size = 3476137, upload-time = "2026-01-21T18:45:15.001Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/a1/9c4efa03300926601c19c18582531b45aededfb961ab3c3585f1e24f120b/sqlalchemy-2.0.46-py3-none-any.whl", hash = "sha256:f9c11766e7e7c0a2767dda5acb006a118640c9fc0a4104214b96269bfb78399e", size = 1937882, upload-time = "2026-01-21T18:22:10.456Z" },
 ]
 
 [[package]]
@@ -997,9 +1137,9 @@ dependencies = [
     { name = "executing" },
     { name = "pure-eval" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707 }
+sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521 },
+    { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" },
 ]
 
 [[package]]
@@ -1010,36 +1150,36 @@ dependencies = [
     { name = "anyio" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a7/a5/d6f429d43394057b67a6b5bbe6eae2f77a6bf7459d961fdb224bf206eee6/starlette-0.48.0.tar.gz", hash = "sha256:7e8cee469a8ab2352911528110ce9088fdc6a37d9876926e73da7ce4aa4c7a46", size = 2652949 }
+sdist = { url = "https://files.pythonhosted.org/packages/a7/a5/d6f429d43394057b67a6b5bbe6eae2f77a6bf7459d961fdb224bf206eee6/starlette-0.48.0.tar.gz", hash = "sha256:7e8cee469a8ab2352911528110ce9088fdc6a37d9876926e73da7ce4aa4c7a46", size = 2652949, upload-time = "2025-09-13T08:41:05.699Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/72/2db2f49247d0a18b4f1bb9a5a39a0162869acf235f3a96418363947b3d46/starlette-0.48.0-py3-none-any.whl", hash = "sha256:0764ca97b097582558ecb498132ed0c7d942f233f365b86ba37770e026510659", size = 73736 },
+    { url = "https://files.pythonhosted.org/packages/be/72/2db2f49247d0a18b4f1bb9a5a39a0162869acf235f3a96418363947b3d46/starlette-0.48.0-py3-none-any.whl", hash = "sha256:0764ca97b097582558ecb498132ed0c7d942f233f365b86ba37770e026510659", size = 73736, upload-time = "2025-09-13T08:41:03.869Z" },
 ]
 
 [[package]]
 name = "tenacity"
 version = "9.1.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413 }
+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926 },
+    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },
 ]
 
 [[package]]
 name = "traitlets"
 version = "5.14.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621 }
+sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 },
+    { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" },
 ]
 
 [[package]]
 name = "typing-extensions"
 version = "4.15.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391 }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614 },
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
 ]
 
 [[package]]
@@ -1049,18 +1189,18 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949 }
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611 },
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
 ]
 
 [[package]]
 name = "urllib3"
 version = "2.6.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556 }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584 },
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
 ]
 
 [[package]]
@@ -1071,9 +1211,9 @@ dependencies = [
     { name = "click" },
     { name = "h11" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/de/ad/713be230bcda622eaa35c28f0d328c3675c371238470abdea52417f17a8e/uvicorn-0.34.3.tar.gz", hash = "sha256:35919a9a979d7a59334b6b10e05d77c1d0d574c50e0fc98b8b1a0f165708b55a", size = 76631 }
+sdist = { url = "https://files.pythonhosted.org/packages/de/ad/713be230bcda622eaa35c28f0d328c3675c371238470abdea52417f17a8e/uvicorn-0.34.3.tar.gz", hash = "sha256:35919a9a979d7a59334b6b10e05d77c1d0d574c50e0fc98b8b1a0f165708b55a", size = 76631, upload-time = "2025-06-01T07:48:17.531Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6d/0d/8adfeaa62945f90d19ddc461c55f4a50c258af7662d34b6a3d5d1f8646f6/uvicorn-0.34.3-py3-none-any.whl", hash = "sha256:16246631db62bdfbf069b0645177d6e8a77ba950cfedbfd093acef9444e4d885", size = 62431 },
+    { url = "https://files.pythonhosted.org/packages/6d/0d/8adfeaa62945f90d19ddc461c55f4a50c258af7662d34b6a3d5d1f8646f6/uvicorn-0.34.3-py3-none-any.whl", hash = "sha256:16246631db62bdfbf069b0645177d6e8a77ba950cfedbfd093acef9444e4d885", size = 62431, upload-time = "2025-06-01T07:48:15.664Z" },
 ]
 
 [package.optional-dependencies]
@@ -1091,32 +1231,32 @@ standard = [
 name = "uvloop"
 version = "0.22.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250 }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936 },
-    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769 },
-    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413 },
-    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307 },
-    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970 },
-    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343 },
-    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611 },
-    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811 },
-    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562 },
-    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890 },
-    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472 },
-    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051 },
-    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067 },
-    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423 },
-    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437 },
-    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101 },
-    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158 },
-    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360 },
-    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790 },
-    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783 },
-    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548 },
-    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065 },
-    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384 },
-    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730 },
+    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
+    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" },
+    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" },
+    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" },
+    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" },
+    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" },
+    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" },
+    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
 ]
 
 [[package]]
@@ -1126,119 +1266,119 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440 }
+sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745 },
-    { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769 },
-    { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374 },
-    { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485 },
-    { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813 },
-    { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816 },
-    { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186 },
-    { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812 },
-    { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196 },
-    { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657 },
-    { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042 },
-    { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410 },
-    { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209 },
-    { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321 },
-    { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783 },
-    { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279 },
-    { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405 },
-    { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976 },
-    { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506 },
-    { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936 },
-    { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147 },
-    { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007 },
-    { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280 },
-    { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056 },
-    { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162 },
-    { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909 },
-    { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389 },
-    { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964 },
-    { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114 },
-    { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264 },
-    { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877 },
-    { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176 },
-    { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577 },
-    { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425 },
-    { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826 },
-    { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208 },
-    { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315 },
-    { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869 },
-    { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919 },
-    { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845 },
-    { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027 },
-    { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615 },
-    { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836 },
-    { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099 },
-    { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626 },
-    { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519 },
-    { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078 },
-    { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664 },
-    { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154 },
-    { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820 },
-    { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510 },
-    { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408 },
-    { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968 },
-    { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096 },
-    { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040 },
-    { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847 },
-    { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072 },
-    { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104 },
-    { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112 },
+    { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" },
+    { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" },
+    { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042, upload-time = "2025-10-14T15:04:59.046Z" },
+    { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" },
+    { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209, upload-time = "2025-10-14T15:05:01.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" },
+    { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" },
+    { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" },
+    { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" },
+    { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" },
+    { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" },
+    { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" },
+    { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" },
+    { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" },
+    { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" },
+    { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" },
+    { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" },
+    { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" },
+    { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" },
+    { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" },
 ]
 
 [[package]]
 name = "wcwidth"
 version = "0.6.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684 }
+sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684, upload-time = "2026-02-06T19:19:40.919Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189 },
+    { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" },
 ]
 
 [[package]]
 name = "websockets"
 version = "16.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346 }
+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365 },
-    { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038 },
-    { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328 },
-    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915 },
-    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152 },
-    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583 },
-    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880 },
-    { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261 },
-    { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693 },
-    { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364 },
-    { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039 },
-    { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323 },
-    { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975 },
-    { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203 },
-    { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653 },
-    { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920 },
-    { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255 },
-    { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689 },
-    { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406 },
-    { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085 },
-    { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328 },
-    { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044 },
-    { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279 },
-    { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711 },
-    { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982 },
-    { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915 },
-    { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381 },
-    { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737 },
-    { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268 },
-    { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486 },
-    { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331 },
-    { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501 },
-    { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062 },
-    { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356 },
-    { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085 },
-    { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531 },
-    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598 },
+    { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" },
+    { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" },
+    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" },
+    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" },
+    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" },
+    { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261, upload-time = "2026-01-10T09:22:56.251Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693, upload-time = "2026-01-10T09:22:57.478Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406, upload-time = "2026-01-10T09:23:12.178Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085, upload-time = "2026-01-10T09:23:13.511Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328, upload-time = "2026-01-10T09:23:14.727Z" },
+    { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044, upload-time = "2026-01-10T09:23:15.939Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279, upload-time = "2026-01-10T09:23:17.148Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711, upload-time = "2026-01-10T09:23:18.372Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982, upload-time = "2026-01-10T09:23:19.652Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915, upload-time = "2026-01-10T09:23:21.458Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381, upload-time = "2026-01-10T09:23:22.715Z" },
+    { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737, upload-time = "2026-01-10T09:23:24.523Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268, upload-time = "2026-01-10T09:23:25.781Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486, upload-time = "2026-01-10T09:23:27.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331, upload-time = "2026-01-10T09:23:28.259Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501, upload-time = "2026-01-10T09:23:29.449Z" },
+    { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062, upload-time = "2026-01-10T09:23:31.368Z" },
+    { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" },
 ]
-- 
2.49.1


From ac002131d6728a050aaec8d11203f5b0a54b4d10 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Thu, 26 Feb 2026 22:58:55 +0100
Subject: [PATCH 12/38] fix: resolve remaining ruff lint and mypy type errors

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/api/media.py                              |  3 +-
 app/api/routers/auth.py                       |  3 +-
 app/api/routers/runs.py                       |  8 +-
 app/api/routers/scholars.py                   |  8 +-
 app/security/csrf.py                          |  2 +-
 app/services/domains/arxiv/rate_limit.py      |  3 +-
 app/services/domains/ingestion/application.py | 14 +--
 .../domains/ingestion/fingerprints.py         |  5 +-
 app/services/domains/ingestion/scheduler.py   |  4 +-
 app/services/domains/openalex/matching.py     |  3 +-
 app/services/domains/portability/__init__.py  | 22 ++++-
 .../publication_identifiers/application.py    |  4 +-
 app/services/domains/publications/__init__.py | 85 ++++++++++++++++++-
 .../domains/publications/pdf_queue.py         |  6 +-
 .../publications/pdf_resolution_pipeline.py   |  2 +-
 app/services/domains/publications/queries.py  |  2 +-
 app/services/domains/runs/__init__.py         | 52 +++++++++++-
 app/services/domains/runs/summary.py          |  4 +-
 app/services/domains/scholar/parser.py        |  9 ++
 app/services/domains/scholar/profile_rows.py  |  7 +-
 app/services/domains/scholars/application.py  |  7 +-
 app/services/domains/settings/application.py  |  4 +-
 app/services/domains/unpaywall/application.py |  5 +-
 tests/unit/test_user_settings.py              | 14 +--
 24 files changed, 219 insertions(+), 57 deletions(-)

diff --git a/app/api/media.py b/app/api/media.py
index 00943bd..878c347 100644
--- a/app/api/media.py
+++ b/app/api/media.py
@@ -11,6 +11,7 @@ from app.api.errors import ApiException
 from app.db.models import User
 from app.db.session import get_db_session
 from app.services.domains.scholars import application as scholar_service
+from app.services.domains.scholars import uploads as scholar_uploads
 from app.settings import settings
 
 router = APIRouter(tags=["media"])
@@ -41,7 +42,7 @@ async def get_uploaded_scholar_image(
         )
 
     try:
-        image_path = scholar_service.resolve_upload_file_path(
+        image_path = scholar_uploads.resolve_upload_file_path(
             upload_dir=settings.scholar_image_upload_dir,
             relative_path=profile.profile_image_upload_path,
         )
diff --git a/app/api/routers/auth.py b/app/api/routers/auth.py
index 9b9f053..128fd65 100644
--- a/app/api/routers/auth.py
+++ b/app/api/routers/auth.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+from typing import NoReturn
 
 from fastapi import APIRouter, Depends, Request
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -61,7 +62,7 @@ def _serialize_user_payload(user: User) -> dict[str, object]:
     }
 
 
-def _raise_invalid_credentials(*, normalized_email: str) -> None:
+def _raise_invalid_credentials(*, normalized_email: str) -> NoReturn:
     structured_log(logger, "info", "api.auth.login_failed", email=normalized_email)
     raise ApiException(
         status_code=401,
diff --git a/app/api/routers/runs.py b/app/api/routers/runs.py
index c25a127..b55de66 100644
--- a/app/api/routers/runs.py
+++ b/app/api/routers/runs.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 import re
 from typing import Any
@@ -32,6 +33,7 @@ from app.services.domains.settings import application as user_settings_service
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
+_background_tasks: set[asyncio.Task[Any]] = set()
 
 router = APIRouter(prefix="/runs", tags=["api-runs"])
 ACTIVE_RUN_STATUSES = {RunStatus.RUNNING, RunStatus.RESOLVING}
@@ -656,11 +658,9 @@ async def run_manual(
         await db_session.commit()
 
         # Kick off background execution
-        import asyncio
-
         from app.db.session import get_session_factory
 
-        asyncio.create_task(
+        task = asyncio.create_task(
             ingest_service.execute_run(
                 session_factory=get_session_factory(),
                 run_id=run.id,
@@ -680,6 +680,8 @@ async def run_manual(
                 idempotency_key=idempotency_key,
             )
         )
+        _background_tasks.add(task)
+        task.add_done_callback(_background_tasks.discard)
 
         return success_payload(
             request,
diff --git a/app/api/routers/scholars.py b/app/api/routers/scholars.py
index fcdd1c4..0792aa5 100644
--- a/app/api/routers/scholars.py
+++ b/app/api/routers/scholars.py
@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+from typing import Any
 
 from fastapi import APIRouter, Depends, File, Query, Request, UploadFile
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -29,6 +30,7 @@ from app.services.domains.portability import application as import_export_servic
 from app.services.domains.scholar import rate_limit as scholar_rate_limit
 from app.services.domains.scholar.source import ScholarSource
 from app.services.domains.scholars import application as scholar_service
+from app.services.domains.scholars import search_hints as scholar_search_hints
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
@@ -110,7 +112,7 @@ def _serialize_scholar(profile) -> dict[str, object]:
     if profile.profile_image_upload_path:
         uploaded_image_url = _uploaded_image_media_path(int(profile.id))
 
-    profile_image_url, profile_image_source = scholar_service.resolve_profile_image(
+    profile_image_url, profile_image_source = scholar_search_hints.resolve_profile_image(
         profile,
         uploaded_image_url=uploaded_image_url,
     )
@@ -180,7 +182,7 @@ async def _hydrate_scholar_metadata_if_needed(
     return profile
 
 
-def _search_kwargs() -> dict[str, object]:
+def _search_kwargs() -> dict[str, Any]:
     return {
         "network_error_retries": settings.ingestion_network_error_retries,
         "retry_backoff_seconds": settings.ingestion_retry_backoff_seconds,
@@ -202,7 +204,7 @@ def _search_response_data(query: str, parsed) -> dict[str, object]:
         "query": query.strip(),
         "state": parsed.state.value,
         "state_reason": parsed.state_reason,
-        "action_hint": scholar_service.scrape_state_hint(
+        "action_hint": scholar_search_hints.scrape_state_hint(
             state=parsed.state,
             state_reason=parsed.state_reason,
         ),
diff --git a/app/security/csrf.py b/app/security/csrf.py
index 00119a9..5c181c9 100644
--- a/app/security/csrf.py
+++ b/app/security/csrf.py
@@ -54,7 +54,7 @@ class CSRFMiddleware(BaseHTTPMiddleware):
         if request_token is None and self._is_form_payload(request):
             body = await request.body()
             request_token = self._token_from_form_body(request, body)
-            request._receive = self._build_receive(body)  # type: ignore[attr-defined]
+            request._receive = self._build_receive(body)
 
         if not request_token or not compare_digest(str(session_token), str(request_token)):
             structured_log(
diff --git a/app/services/domains/arxiv/rate_limit.py b/app/services/domains/arxiv/rate_limit.py
index ddc5cab..b5e5eed 100644
--- a/app/services/domains/arxiv/rate_limit.py
+++ b/app/services/domains/arxiv/rate_limit.py
@@ -68,8 +68,7 @@ async def _run_serialized_fetch(
     source_path: str,
 ) -> tuple[httpx.Response, bool]:
     session_factory = get_session_factory()
-    async with session_factory() as db_session:
-        async with db_session.begin():
+    async with session_factory() as db_session, db_session.begin():
             await _acquire_arxiv_lock(db_session)
             runtime_state = await _load_runtime_state_for_update(db_session)
             wait_seconds = await _wait_for_allowed_slot_or_raise(
diff --git a/app/services/domains/ingestion/application.py b/app/services/domains/ingestion/application.py
index 1098c1b..9707c65 100644
--- a/app/services/domains/ingestion/application.py
+++ b/app/services/domains/ingestion/application.py
@@ -109,6 +109,9 @@ def _classify_failure_bucket(*, state: str, state_reason: str) -> str:
     return FAILURE_BUCKET_OTHER
 
 
+_background_tasks: set[asyncio.Task[Any]] = set()
+
+
 class ScholarIngestionService:
     def __init__(self, *, source: ScholarSource) -> None:
         self._source = source
@@ -287,9 +290,8 @@ class ScholarIngestionService:
         paged_parse_result: PagedParseResult,
     ) -> None:
         parsed_page = paged_parse_result.parsed_page
-        if parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS}:
-            if any(code.startswith("layout_") for code in parsed_page.warnings):
-                raise RuntimeError(f"Layout warning marked as terminal for scholar_id={scholar_id}.")
+        if parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS} and any(code.startswith("layout_") for code in parsed_page.warnings):
+            raise RuntimeError(f"Layout warning marked as terminal for scholar_id={scholar_id}.")
         for publication in paged_parse_result.publications:
             if not publication.title.strip():
                 raise RuntimeError(f"Malformed publication title for scholar_id={scholar_id}.")
@@ -1490,7 +1492,7 @@ class ScholarIngestionService:
 
                 # Fire-and-forget enrichment in a separate background task
                 if intended_final_status not in (RunStatus.CANCELED,):
-                    asyncio.create_task(
+                    task = asyncio.create_task(
                         self._background_enrich(
                             session_factory,
                             run_id=run.id,
@@ -1498,6 +1500,8 @@ class ScholarIngestionService:
                             openalex_api_key=getattr(user_settings, "openalex_api_key", None),
                         )
                     )
+                    _background_tasks.add(task)
+                    task.add_done_callback(_background_tasks.discard)
             except Exception as exc:
                 await db_session.rollback()
                 logger.exception("ingestion.background_run_failed", extra={"run_id": run_id, "user_id": user_id})
@@ -2807,7 +2811,7 @@ class ScholarIngestionService:
             publication.venue_text = candidate.venue_text
         if candidate.title_url:
             publication.pub_url = build_publication_url(candidate.title_url)
-        local_doi = first_doi_from_texts(candidate.title_url, candidate.venue_text, candidate.title)
+        first_doi_from_texts(candidate.title_url, candidate.venue_text, candidate.title)
 
     async def _resolve_publication(
         self,
diff --git a/app/services/domains/ingestion/fingerprints.py b/app/services/domains/ingestion/fingerprints.py
index 7c3156d..a39c72d 100644
--- a/app/services/domains/ingestion/fingerprints.py
+++ b/app/services/domains/ingestion/fingerprints.py
@@ -367,10 +367,7 @@ def _publication_identity(pub: PublicationCandidate) -> str:
 
 
 def _is_fuzzy_dup(tokens: set[str], seen: list[set[str]]) -> bool:
-    for existing in seen:
-        if _jaccard(tokens, existing) >= _CANONICAL_DEDUP_THRESHOLD:
-            return True
-    return False
+    return any(_jaccard(tokens, existing) >= _CANONICAL_DEDUP_THRESHOLD for existing in seen)
 
 
 def _build_body_excerpt(body: str, *, max_chars: int = 220) -> str | None:
diff --git a/app/services/domains/ingestion/scheduler.py b/app/services/domains/ingestion/scheduler.py
index 4aa8bc0..df20d2d 100644
--- a/app/services/domains/ingestion/scheduler.py
+++ b/app/services/domains/ingestion/scheduler.py
@@ -330,9 +330,7 @@ class SchedulerService:
             await session.commit()
         if queue_item is None:
             return False
-        if queue_item.status == QueueItemStatus.DROPPED.value:
-            return False
-        return True
+        return queue_item.status != QueueItemStatus.DROPPED.value
 
     async def _queue_job_has_available_scholar(
         self,
diff --git a/app/services/domains/openalex/matching.py b/app/services/domains/openalex/matching.py
index 40c25ba..8b3c6d5 100644
--- a/app/services/domains/openalex/matching.py
+++ b/app/services/domains/openalex/matching.py
@@ -93,8 +93,7 @@ def find_best_match(
 
     for original_score, cand in top_scored_candidates:
         tb_score = 0
-        if target_year is not None and cand.publication_year is not None:
-            if abs(target_year - cand.publication_year) <= 1:
+        if target_year is not None and cand.publication_year is not None and abs(target_year - cand.publication_year) <= 1:
                 tb_score += 1
 
         candidate_author_names = [a.display_name for a in cand.authors if a.display_name]
diff --git a/app/services/domains/portability/__init__.py b/app/services/domains/portability/__init__.py
index 28aae8b..2c081c6 100644
--- a/app/services/domains/portability/__init__.py
+++ b/app/services/domains/portability/__init__.py
@@ -1 +1,21 @@
-from app.services.domains.portability.application import *
+from app.services.domains.portability.application import (
+    EXPORT_SCHEMA_VERSION as EXPORT_SCHEMA_VERSION,
+)
+from app.services.domains.portability.application import (
+    MAX_IMPORT_PUBLICATIONS as MAX_IMPORT_PUBLICATIONS,
+)
+from app.services.domains.portability.application import (
+    MAX_IMPORT_SCHOLARS as MAX_IMPORT_SCHOLARS,
+)
+from app.services.domains.portability.application import (
+    ImportedPublicationInput as ImportedPublicationInput,
+)
+from app.services.domains.portability.application import (
+    ImportExportError as ImportExportError,
+)
+from app.services.domains.portability.application import (
+    export_user_data as export_user_data,
+)
+from app.services.domains.portability.application import (
+    import_user_data as import_user_data,
+)
diff --git a/app/services/domains/publication_identifiers/application.py b/app/services/domains/publication_identifiers/application.py
index 47fe940..b758e84 100644
--- a/app/services/domains/publication_identifiers/application.py
+++ b/app/services/domains/publication_identifiers/application.py
@@ -188,7 +188,7 @@ async def _discover_crossref_doi(
 
     discovered_doi = await crossref_service.discover_doi_for_publication(item=item)
     normalized_doi = normalize_doi(discovered_doi)
-    if normalized_doi is None:
+    if discovered_doi is None or normalized_doi is None:
         return False
     candidate = _candidate(
         IdentifierKind.DOI,
@@ -216,7 +216,7 @@ async def _discover_arxiv_identifier(
 
     discovered_arxiv = await arxiv_service.discover_arxiv_id_for_publication(item=item)
     normalized_arxiv = normalize_arxiv_id(discovered_arxiv)
-    if normalized_arxiv is None:
+    if discovered_arxiv is None or normalized_arxiv is None:
         return
     candidate = _candidate(
         IdentifierKind.ARXIV,
diff --git a/app/services/domains/publications/__init__.py b/app/services/domains/publications/__init__.py
index 371b02c..058e728 100644
--- a/app/services/domains/publications/__init__.py
+++ b/app/services/domains/publications/__init__.py
@@ -1 +1,84 @@
-from app.services.domains.publications.application import *
+from app.services.domains.publications.application import (
+    MODE_ALL as MODE_ALL,
+)
+from app.services.domains.publications.application import (
+    MODE_LATEST as MODE_LATEST,
+)
+from app.services.domains.publications.application import (
+    MODE_NEW as MODE_NEW,
+)
+from app.services.domains.publications.application import (
+    MODE_UNREAD as MODE_UNREAD,
+)
+from app.services.domains.publications.application import (
+    PublicationListItem as PublicationListItem,
+)
+from app.services.domains.publications.application import (
+    UnreadPublicationItem as UnreadPublicationItem,
+)
+from app.services.domains.publications.application import (
+    count_favorite_for_user as count_favorite_for_user,
+)
+from app.services.domains.publications.application import (
+    count_for_user as count_for_user,
+)
+from app.services.domains.publications.application import (
+    count_latest_for_user as count_latest_for_user,
+)
+from app.services.domains.publications.application import (
+    count_pdf_queue_items as count_pdf_queue_items,
+)
+from app.services.domains.publications.application import (
+    count_unread_for_user as count_unread_for_user,
+)
+from app.services.domains.publications.application import (
+    enqueue_all_missing_pdf_jobs as enqueue_all_missing_pdf_jobs,
+)
+from app.services.domains.publications.application import (
+    enqueue_retry_pdf_job_for_publication_id as enqueue_retry_pdf_job_for_publication_id,
+)
+from app.services.domains.publications.application import (
+    get_latest_run_id_for_user as get_latest_run_id_for_user,
+)
+from app.services.domains.publications.application import (
+    get_publication_item_for_user as get_publication_item_for_user,
+)
+from app.services.domains.publications.application import (
+    hydrate_pdf_enrichment_state as hydrate_pdf_enrichment_state,
+)
+from app.services.domains.publications.application import (
+    list_for_user as list_for_user,
+)
+from app.services.domains.publications.application import (
+    list_pdf_queue_items as list_pdf_queue_items,
+)
+from app.services.domains.publications.application import (
+    list_pdf_queue_page as list_pdf_queue_page,
+)
+from app.services.domains.publications.application import (
+    list_unread_for_user as list_unread_for_user,
+)
+from app.services.domains.publications.application import (
+    mark_all_unread_as_read_for_user as mark_all_unread_as_read_for_user,
+)
+from app.services.domains.publications.application import (
+    mark_selected_as_read_for_user as mark_selected_as_read_for_user,
+)
+from app.services.domains.publications.application import (
+    publications_query as publications_query,
+)
+from app.services.domains.publications.application import (
+    resolve_publication_view_mode as resolve_publication_view_mode,
+)
+from app.services.domains.publications.application import (
+    retry_pdf_for_user as retry_pdf_for_user,
+)
+from app.services.domains.publications.application import (
+    schedule_missing_pdf_enrichment_for_user as schedule_missing_pdf_enrichment_for_user,
+)
+from app.services.domains.publications.application import (
+    schedule_retry_pdf_enrichment_for_row as schedule_retry_pdf_enrichment_for_row,
+)
+from app.services.domains.publications.application import (
+    set_publication_favorite_for_user as set_publication_favorite_for_user,
+)
diff --git a/app/services/domains/publications/pdf_queue.py b/app/services/domains/publications/pdf_queue.py
index 880b1a2..1456fc5 100644
--- a/app/services/domains/publications/pdf_queue.py
+++ b/app/services/domains/publications/pdf_queue.py
@@ -190,12 +190,10 @@ def _can_enqueue_job(
         return False
     if int(job.attempt_count) >= _auto_retry_max_attempts():
         return False
-    if _cooldown_active(
+    return not _cooldown_active(
         last_attempt_at=job.last_attempt_at,
         attempt_count=int(job.attempt_count),
-    ):
-        return False
-    return True
+    )
 
 
 def _event_row(
diff --git a/app/services/domains/publications/pdf_resolution_pipeline.py b/app/services/domains/publications/pdf_resolution_pipeline.py
index 88a07ca..c537a4c 100644
--- a/app/services/domains/publications/pdf_resolution_pipeline.py
+++ b/app/services/domains/publications/pdf_resolution_pipeline.py
@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from typing import Any
 
 from app.logging_utils import structured_log
-from app.services.domains.arxiv.application import ArxivRateLimitError
+from app.services.domains.arxiv.errors import ArxivRateLimitError
 from app.services.domains.arxiv.guards import arxiv_skip_reason_for_item
 from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
 from app.services.domains.publications.types import PublicationListItem
diff --git a/app/services/domains/publications/queries.py b/app/services/domains/publications/queries.py
index 89dd1d1..ac6090f 100644
--- a/app/services/domains/publications/queries.py
+++ b/app/services/domains/publications/queries.py
@@ -19,7 +19,7 @@ from app.services.domains.publications.types import PublicationListItem, UnreadP
 
 def _normalized_citation_count(value: object) -> int:
     try:
-        return int(value or 0)
+        return int(value or 0)  # type: ignore[call-overload]  # intentionally accepts any object
     except (TypeError, ValueError):
         return 0
 
diff --git a/app/services/domains/runs/__init__.py b/app/services/domains/runs/__init__.py
index 848f6e0..829f7f0 100644
--- a/app/services/domains/runs/__init__.py
+++ b/app/services/domains/runs/__init__.py
@@ -1 +1,51 @@
-from app.services.domains.runs.application import *
+from app.services.domains.runs.application import (
+    QUEUE_STATUS_DROPPED as QUEUE_STATUS_DROPPED,
+)
+from app.services.domains.runs.application import (
+    QUEUE_STATUS_QUEUED as QUEUE_STATUS_QUEUED,
+)
+from app.services.domains.runs.application import (
+    QUEUE_STATUS_RETRYING as QUEUE_STATUS_RETRYING,
+)
+from app.services.domains.runs.application import (
+    QueueClearResult as QueueClearResult,
+)
+from app.services.domains.runs.application import (
+    QueueListItem as QueueListItem,
+)
+from app.services.domains.runs.application import (
+    QueueTransitionError as QueueTransitionError,
+)
+from app.services.domains.runs.application import (
+    clear_queue_item_for_user as clear_queue_item_for_user,
+)
+from app.services.domains.runs.application import (
+    drop_queue_item_for_user as drop_queue_item_for_user,
+)
+from app.services.domains.runs.application import (
+    extract_run_summary as extract_run_summary,
+)
+from app.services.domains.runs.application import (
+    get_manual_run_by_idempotency_key as get_manual_run_by_idempotency_key,
+)
+from app.services.domains.runs.application import (
+    get_queue_item_for_user as get_queue_item_for_user,
+)
+from app.services.domains.runs.application import (
+    get_run_for_user as get_run_for_user,
+)
+from app.services.domains.runs.application import (
+    list_queue_items_for_user as list_queue_items_for_user,
+)
+from app.services.domains.runs.application import (
+    list_recent_runs_for_user as list_recent_runs_for_user,
+)
+from app.services.domains.runs.application import (
+    list_runs_for_user as list_runs_for_user,
+)
+from app.services.domains.runs.application import (
+    queue_status_counts_for_user as queue_status_counts_for_user,
+)
+from app.services.domains.runs.application import (
+    retry_queue_item_for_user as retry_queue_item_for_user,
+)
diff --git a/app/services/domains/runs/summary.py b/app/services/domains/runs/summary.py
index b18ceb8..58cb7e3 100644
--- a/app/services/domains/runs/summary.py
+++ b/app/services/domains/runs/summary.py
@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, cast
 
 
 def _safe_int(value: object, default: int = 0) -> int:
     try:
-        return int(value)
+        return int(cast(Any, value))
     except (TypeError, ValueError):
         return default
 
diff --git a/app/services/domains/scholar/parser.py b/app/services/domains/scholar/parser.py
index 26b2faf..e8ab1bb 100644
--- a/app/services/domains/scholar/parser.py
+++ b/app/services/domains/scholar/parser.py
@@ -12,6 +12,15 @@ from app.services.domains.scholar.parser_types import (
     ScholarDomInvariantError,
     ScholarMalformedDataError,
 )
+from app.services.domains.scholar.parser_types import (
+    ParseState as ParseState,
+)
+from app.services.domains.scholar.parser_types import (
+    ScholarParserError as ScholarParserError,
+)
+from app.services.domains.scholar.parser_types import (
+    ScholarSearchCandidate as ScholarSearchCandidate,
+)
 from app.services.domains.scholar.parser_utils import (
     strip_tags,
 )
diff --git a/app/services/domains/scholar/profile_rows.py b/app/services/domains/scholar/profile_rows.py
index 38faf0a..0ad8f15 100644
--- a/app/services/domains/scholar/profile_rows.py
+++ b/app/services/domains/scholar/profile_rows.py
@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import re
 from html.parser import HTMLParser
+from typing import Any
 from urllib.parse import parse_qs, urlparse
 
 from app.services.domains.scholar.parser_constants import (
@@ -30,7 +31,7 @@ class ScholarRowParser(HTMLParser):
         self._title_depth = 0
         self._citation_depth = 0
         self._year_depth = 0
-        self._gray_stack: list[dict[str, object]] = []
+        self._gray_stack: list[dict[str, Any]] = []
 
     def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
         if self._title_depth > 0:
@@ -252,9 +253,7 @@ def has_show_more_button(html: str) -> bool:
         return False
     if 'aria-disabled="true"' in button_tag or "aria-disabled='true'" in button_tag:
         return False
-    if "gs_dis" in button_tag:
-        return False
-    return True
+    return "gs_dis" not in button_tag
 
 
 def has_operation_error_banner(html: str) -> bool:
diff --git a/app/services/domains/scholars/application.py b/app/services/domains/scholars/application.py
index 3b66643..51c1490 100644
--- a/app/services/domains/scholars/application.py
+++ b/app/services/domains/scholars/application.py
@@ -6,6 +6,7 @@ import os
 import random
 from dataclasses import replace
 from datetime import UTC, datetime, timedelta
+from typing import Any
 from uuid import uuid4
 
 from sqlalchemy import delete, func, select, text
@@ -182,11 +183,11 @@ def _deserialize_candidate_payload(value: object) -> dict[str, object] | None:
     }
 
 
-def _deserialize_candidates(payload: dict[str, object]) -> list[dict[str, object]]:
+def _deserialize_candidates(payload: dict[str, object]) -> list[dict[str, Any]]:
     candidates_payload = payload.get("candidates")
     if not isinstance(candidates_payload, list):
         return []
-    normalized: list[dict[str, object]] = []
+    normalized: list[dict[str, Any]] = []
     for value in candidates_payload:
         candidate = _deserialize_candidate_payload(value)
         if candidate is not None:
@@ -790,7 +791,7 @@ async def _perform_live_author_search(
     cache_ttl_seconds: int,
     cache_max_entries: int,
 ) -> tuple[ParsedAuthorSearchPage, bool]:
-    runtime_state_updated = await _wait_for_author_search_throttle(
+    await _wait_for_author_search_throttle(
         runtime_state=runtime_state,
         normalized_query=normalized_query,
         now_utc=datetime.now(UTC),
diff --git a/app/services/domains/settings/application.py b/app/services/domains/settings/application.py
index 3636bf6..e35971c 100644
--- a/app/services/domains/settings/application.py
+++ b/app/services/domains/settings/application.py
@@ -4,6 +4,7 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import UserSetting
+from app.settings import settings as app_settings
 
 
 class UserSettingsServiceError(ValueError):
@@ -103,9 +104,6 @@ def parse_nav_visible_pages(value: object) -> list[str]:
     return deduped
 
 
-from app.settings import settings as app_settings
-
-
 async def get_or_create_settings(
     db_session: AsyncSession,
     *,
diff --git a/app/services/domains/unpaywall/application.py b/app/services/domains/unpaywall/application.py
index 0febe51..1258643 100644
--- a/app/services/domains/unpaywall/application.py
+++ b/app/services/domains/unpaywall/application.py
@@ -65,8 +65,9 @@ def _extract_explicit_doi(text: str | None) -> str | None:
 
 def _publication_doi(item: PublicationListItem | UnreadPublicationItem) -> str | None:
     stored = None
-    if getattr(item, "display_identifier", None) and item.display_identifier.kind == "doi":
-        stored = normalize_doi(item.display_identifier.value)
+    di = getattr(item, "display_identifier", None)
+    if di is not None and di.kind == "doi":
+        stored = normalize_doi(di.value)
 
     explicit_doi = _extract_explicit_doi(item.pub_url) or _extract_explicit_doi(item.venue_text)
     if explicit_doi:
diff --git a/tests/unit/test_user_settings.py b/tests/unit/test_user_settings.py
index 83b1bc0..7897de2 100644
--- a/tests/unit/test_user_settings.py
+++ b/tests/unit/test_user_settings.py
@@ -22,7 +22,7 @@ def test_parse_run_interval_minutes_accepts_valid_value() -> None:
 def test_parse_run_interval_minutes_rejects_below_minimum() -> None:
     with pytest.raises(
         UserSettingsServiceError,
-        match="Check interval must be at least 15 minutes.",
+        match=r"Check interval must be at least 15 minutes.",
     ):
         parse_run_interval_minutes("14")
 
@@ -34,7 +34,7 @@ def test_parse_request_delay_seconds_accepts_valid_value() -> None:
 def test_parse_request_delay_seconds_rejects_below_minimum() -> None:
     with pytest.raises(
         UserSettingsServiceError,
-        match="Request delay must be at least 2 seconds.",
+        match=r"Request delay must be at least 2 seconds.",
     ):
         parse_request_delay_seconds("1")
 
@@ -42,7 +42,7 @@ def test_parse_request_delay_seconds_rejects_below_minimum() -> None:
 def test_parse_run_interval_minutes_rejects_below_configured_minimum() -> None:
     with pytest.raises(
         UserSettingsServiceError,
-        match="Check interval must be at least 30 minutes.",
+        match=r"Check interval must be at least 30 minutes.",
     ):
         parse_run_interval_minutes("29", minimum=30)
 
@@ -50,7 +50,7 @@ def test_parse_run_interval_minutes_rejects_below_configured_minimum() -> None:
 def test_parse_request_delay_seconds_rejects_below_configured_minimum() -> None:
     with pytest.raises(
         UserSettingsServiceError,
-        match="Request delay must be at least 8 seconds.",
+        match=r"Request delay must be at least 8 seconds.",
     ):
         parse_request_delay_seconds("7", minimum=8)
 
@@ -82,7 +82,7 @@ def test_parse_nav_visible_pages_accepts_valid_pages() -> None:
 def test_parse_nav_visible_pages_rejects_missing_required_pages() -> None:
     with pytest.raises(
         UserSettingsServiceError,
-        match="Dashboard, Scholars, and Settings must remain visible.",
+        match=r"Dashboard, Scholars, and Settings must remain visible.",
     ):
         parse_nav_visible_pages(["dashboard", "publications"])
 
@@ -90,6 +90,6 @@ def test_parse_nav_visible_pages_rejects_missing_required_pages() -> None:
 def test_parse_nav_visible_pages_rejects_unknown_page() -> None:
     with pytest.raises(
         UserSettingsServiceError,
-        match="Unsupported navigation page id: reports",
+        match=r"Unsupported navigation page id: reports",
     ):
-        parse_nav_visible_pages(DEFAULT_NAV_VISIBLE_PAGES + ["reports"])
+        parse_nav_visible_pages([*DEFAULT_NAV_VISIBLE_PAGES, "reports"])
-- 
2.49.1


From 3866c6d6f03bb2997aeb5f67888cfa312d704209 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 00:05:17 +0100
Subject: [PATCH 13/38] ci: add CodeQL security scanning and Dependabot

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/dependabot.yml                        | 14 ++++++++++
 .github/workflows/codeql.yml                  | 26 +++++++++++++++++++
 .../{domains => }/arxiv/application.py        |  0
 app/services/{domains => }/arxiv/cache.py     |  0
 app/services/{domains => }/arxiv/client.py    |  0
 app/services/{domains => }/arxiv/constants.py |  0
 app/services/{domains => }/arxiv/errors.py    |  0
 app/services/{domains => }/arxiv/gateway.py   |  0
 app/services/{domains => }/arxiv/guards.py    |  0
 app/services/{domains => }/arxiv/parser.py    |  0
 .../{domains => }/arxiv/rate_limit.py         |  0
 app/services/{domains => }/arxiv/types.py     |  0
 .../{domains => }/crossref/__init__.py        |  0
 .../{domains => }/crossref/application.py     |  0
 app/services/{domains => }/dbops/__init__.py  |  0
 .../{domains => }/dbops/application.py        |  0
 app/services/{domains => }/dbops/integrity.py |  0
 .../dbops/near_duplicate_repair.py            |  0
 app/services/{domains => }/dbops/query.py     |  0
 app/services/{domains => }/doi/normalize.py   |  0
 app/services/domains/users/__init__.py        |  1 -
 .../{domains => ingestion}/__init__.py        |  0
 .../{domains => }/ingestion/application.py    |  0
 .../{domains => }/ingestion/constants.py      |  0
 .../{domains => }/ingestion/fingerprints.py   |  0
 app/services/{domains => }/ingestion/queue.py |  0
 .../{domains => }/ingestion/safety.py         |  0
 .../{domains => }/ingestion/scheduler.py      |  0
 app/services/{domains => }/ingestion/types.py |  0
 .../{domains => }/openalex/__init__.py        |  0
 app/services/{domains => }/openalex/client.py |  0
 .../{domains => }/openalex/matching.py        |  0
 app/services/{domains => }/openalex/types.py  |  0
 .../{domains => }/portability/__init__.py     |  0
 .../{domains => }/portability/application.py  |  0
 .../{domains => }/portability/constants.py    |  0
 .../{domains => }/portability/exporting.py    |  0
 .../{domains => }/portability/normalize.py    |  0
 .../portability/publication_import.py         |  0
 .../portability/scholar_import.py             |  0
 .../{domains => }/portability/types.py        |  0
 .../publication_identifiers/__init__.py       |  0
 .../publication_identifiers/application.py    |  0
 .../publication_identifiers/normalize.py      |  0
 .../publication_identifiers/types.py          |  0
 .../{domains => }/publications/__init__.py    |  0
 .../{domains => }/publications/application.py |  0
 .../{domains => }/publications/counts.py      |  0
 .../{domains => }/publications/dedup.py       |  0
 .../{domains => }/publications/enrichment.py  |  0
 .../{domains => }/publications/listing.py     |  0
 .../{domains => }/publications/modes.py       |  0
 .../{domains => }/publications/pdf_queue.py   |  0
 .../publications/pdf_resolution_pipeline.py   |  0
 .../{domains => }/publications/queries.py     |  0
 .../{domains => }/publications/read_state.py  |  0
 .../{domains => }/publications/types.py       |  0
 app/services/{domains => }/runs/__init__.py   |  0
 .../{domains => }/runs/application.py         |  0
 app/services/{domains => }/runs/events.py     |  0
 .../{domains => }/runs/queue_queries.py       |  0
 .../{domains => }/runs/queue_service.py       |  0
 .../{domains => }/runs/runs_service.py        |  0
 app/services/{domains => }/runs/summary.py    |  0
 app/services/{domains => }/runs/types.py      |  0
 .../ingestion => scholar}/__init__.py         |  0
 .../{domains => }/scholar/author_rows.py      |  0
 app/services/{domains => }/scholar/parser.py  |  0
 .../{domains => }/scholar/parser_constants.py |  0
 .../{domains => }/scholar/parser_types.py     |  0
 .../{domains => }/scholar/parser_utils.py     |  0
 .../{domains => }/scholar/profile_rows.py     |  0
 .../{domains => }/scholar/rate_limit.py       |  0
 app/services/{domains => }/scholar/source.py  |  0
 .../{domains => }/scholar/state_detection.py  |  0
 .../{domains/scholar => scholars}/__init__.py |  0
 .../{domains => }/scholars/application.py     |  0
 .../{domains => }/scholars/constants.py       |  0
 .../{domains => }/scholars/exceptions.py      |  0
 .../{domains => }/scholars/search_hints.py    |  0
 .../{domains => }/scholars/uploads.py         |  0
 .../{domains => }/scholars/validators.py      |  0
 .../scholars => settings}/__init__.py         |  0
 .../{domains => }/settings/application.py     |  0
 .../{domains => }/unpaywall/__init__.py       |  0
 .../{domains => }/unpaywall/application.py    |  0
 .../{domains => }/unpaywall/pdf_discovery.py  |  0
 .../{domains => }/unpaywall/rate_limit.py     |  0
 .../{domains/settings => users}/__init__.py   |  0
 .../{domains => }/users/application.py        |  0
 90 files changed, 40 insertions(+), 1 deletion(-)
 create mode 100644 .github/dependabot.yml
 create mode 100644 .github/workflows/codeql.yml
 rename app/services/{domains => }/arxiv/application.py (100%)
 rename app/services/{domains => }/arxiv/cache.py (100%)
 rename app/services/{domains => }/arxiv/client.py (100%)
 rename app/services/{domains => }/arxiv/constants.py (100%)
 rename app/services/{domains => }/arxiv/errors.py (100%)
 rename app/services/{domains => }/arxiv/gateway.py (100%)
 rename app/services/{domains => }/arxiv/guards.py (100%)
 rename app/services/{domains => }/arxiv/parser.py (100%)
 rename app/services/{domains => }/arxiv/rate_limit.py (100%)
 rename app/services/{domains => }/arxiv/types.py (100%)
 rename app/services/{domains => }/crossref/__init__.py (100%)
 rename app/services/{domains => }/crossref/application.py (100%)
 rename app/services/{domains => }/dbops/__init__.py (100%)
 rename app/services/{domains => }/dbops/application.py (100%)
 rename app/services/{domains => }/dbops/integrity.py (100%)
 rename app/services/{domains => }/dbops/near_duplicate_repair.py (100%)
 rename app/services/{domains => }/dbops/query.py (100%)
 rename app/services/{domains => }/doi/normalize.py (100%)
 delete mode 100644 app/services/domains/users/__init__.py
 rename app/services/{domains => ingestion}/__init__.py (100%)
 rename app/services/{domains => }/ingestion/application.py (100%)
 rename app/services/{domains => }/ingestion/constants.py (100%)
 rename app/services/{domains => }/ingestion/fingerprints.py (100%)
 rename app/services/{domains => }/ingestion/queue.py (100%)
 rename app/services/{domains => }/ingestion/safety.py (100%)
 rename app/services/{domains => }/ingestion/scheduler.py (100%)
 rename app/services/{domains => }/ingestion/types.py (100%)
 rename app/services/{domains => }/openalex/__init__.py (100%)
 rename app/services/{domains => }/openalex/client.py (100%)
 rename app/services/{domains => }/openalex/matching.py (100%)
 rename app/services/{domains => }/openalex/types.py (100%)
 rename app/services/{domains => }/portability/__init__.py (100%)
 rename app/services/{domains => }/portability/application.py (100%)
 rename app/services/{domains => }/portability/constants.py (100%)
 rename app/services/{domains => }/portability/exporting.py (100%)
 rename app/services/{domains => }/portability/normalize.py (100%)
 rename app/services/{domains => }/portability/publication_import.py (100%)
 rename app/services/{domains => }/portability/scholar_import.py (100%)
 rename app/services/{domains => }/portability/types.py (100%)
 rename app/services/{domains => }/publication_identifiers/__init__.py (100%)
 rename app/services/{domains => }/publication_identifiers/application.py (100%)
 rename app/services/{domains => }/publication_identifiers/normalize.py (100%)
 rename app/services/{domains => }/publication_identifiers/types.py (100%)
 rename app/services/{domains => }/publications/__init__.py (100%)
 rename app/services/{domains => }/publications/application.py (100%)
 rename app/services/{domains => }/publications/counts.py (100%)
 rename app/services/{domains => }/publications/dedup.py (100%)
 rename app/services/{domains => }/publications/enrichment.py (100%)
 rename app/services/{domains => }/publications/listing.py (100%)
 rename app/services/{domains => }/publications/modes.py (100%)
 rename app/services/{domains => }/publications/pdf_queue.py (100%)
 rename app/services/{domains => }/publications/pdf_resolution_pipeline.py (100%)
 rename app/services/{domains => }/publications/queries.py (100%)
 rename app/services/{domains => }/publications/read_state.py (100%)
 rename app/services/{domains => }/publications/types.py (100%)
 rename app/services/{domains => }/runs/__init__.py (100%)
 rename app/services/{domains => }/runs/application.py (100%)
 rename app/services/{domains => }/runs/events.py (100%)
 rename app/services/{domains => }/runs/queue_queries.py (100%)
 rename app/services/{domains => }/runs/queue_service.py (100%)
 rename app/services/{domains => }/runs/runs_service.py (100%)
 rename app/services/{domains => }/runs/summary.py (100%)
 rename app/services/{domains => }/runs/types.py (100%)
 rename app/services/{domains/ingestion => scholar}/__init__.py (100%)
 rename app/services/{domains => }/scholar/author_rows.py (100%)
 rename app/services/{domains => }/scholar/parser.py (100%)
 rename app/services/{domains => }/scholar/parser_constants.py (100%)
 rename app/services/{domains => }/scholar/parser_types.py (100%)
 rename app/services/{domains => }/scholar/parser_utils.py (100%)
 rename app/services/{domains => }/scholar/profile_rows.py (100%)
 rename app/services/{domains => }/scholar/rate_limit.py (100%)
 rename app/services/{domains => }/scholar/source.py (100%)
 rename app/services/{domains => }/scholar/state_detection.py (100%)
 rename app/services/{domains/scholar => scholars}/__init__.py (100%)
 rename app/services/{domains => }/scholars/application.py (100%)
 rename app/services/{domains => }/scholars/constants.py (100%)
 rename app/services/{domains => }/scholars/exceptions.py (100%)
 rename app/services/{domains => }/scholars/search_hints.py (100%)
 rename app/services/{domains => }/scholars/uploads.py (100%)
 rename app/services/{domains => }/scholars/validators.py (100%)
 rename app/services/{domains/scholars => settings}/__init__.py (100%)
 rename app/services/{domains => }/settings/application.py (100%)
 rename app/services/{domains => }/unpaywall/__init__.py (100%)
 rename app/services/{domains => }/unpaywall/application.py (100%)
 rename app/services/{domains => }/unpaywall/pdf_discovery.py (100%)
 rename app/services/{domains => }/unpaywall/rate_limit.py (100%)
 rename app/services/{domains/settings => users}/__init__.py (100%)
 rename app/services/{domains => }/users/application.py (100%)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..3dbdcd9
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,14 @@
+version: 2
+updates:
+  - package-ecosystem: pip
+    directory: /
+    schedule:
+      interval: weekly
+  - package-ecosystem: npm
+    directory: /frontend
+    schedule:
+      interval: weekly
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 0000000..64a22d1
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,26 @@
+name: CodeQL
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: "30 5 * * 1"
+
+jobs:
+  analyze:
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+      contents: read
+    strategy:
+      matrix:
+        language: [python, javascript]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: github/codeql-action/init@v3
+        with:
+          languages: ${{ matrix.language }}
+      - uses: github/codeql-action/autobuild@v3
+      - uses: github/codeql-action/analyze@v3
diff --git a/app/services/domains/arxiv/application.py b/app/services/arxiv/application.py
similarity index 100%
rename from app/services/domains/arxiv/application.py
rename to app/services/arxiv/application.py
diff --git a/app/services/domains/arxiv/cache.py b/app/services/arxiv/cache.py
similarity index 100%
rename from app/services/domains/arxiv/cache.py
rename to app/services/arxiv/cache.py
diff --git a/app/services/domains/arxiv/client.py b/app/services/arxiv/client.py
similarity index 100%
rename from app/services/domains/arxiv/client.py
rename to app/services/arxiv/client.py
diff --git a/app/services/domains/arxiv/constants.py b/app/services/arxiv/constants.py
similarity index 100%
rename from app/services/domains/arxiv/constants.py
rename to app/services/arxiv/constants.py
diff --git a/app/services/domains/arxiv/errors.py b/app/services/arxiv/errors.py
similarity index 100%
rename from app/services/domains/arxiv/errors.py
rename to app/services/arxiv/errors.py
diff --git a/app/services/domains/arxiv/gateway.py b/app/services/arxiv/gateway.py
similarity index 100%
rename from app/services/domains/arxiv/gateway.py
rename to app/services/arxiv/gateway.py
diff --git a/app/services/domains/arxiv/guards.py b/app/services/arxiv/guards.py
similarity index 100%
rename from app/services/domains/arxiv/guards.py
rename to app/services/arxiv/guards.py
diff --git a/app/services/domains/arxiv/parser.py b/app/services/arxiv/parser.py
similarity index 100%
rename from app/services/domains/arxiv/parser.py
rename to app/services/arxiv/parser.py
diff --git a/app/services/domains/arxiv/rate_limit.py b/app/services/arxiv/rate_limit.py
similarity index 100%
rename from app/services/domains/arxiv/rate_limit.py
rename to app/services/arxiv/rate_limit.py
diff --git a/app/services/domains/arxiv/types.py b/app/services/arxiv/types.py
similarity index 100%
rename from app/services/domains/arxiv/types.py
rename to app/services/arxiv/types.py
diff --git a/app/services/domains/crossref/__init__.py b/app/services/crossref/__init__.py
similarity index 100%
rename from app/services/domains/crossref/__init__.py
rename to app/services/crossref/__init__.py
diff --git a/app/services/domains/crossref/application.py b/app/services/crossref/application.py
similarity index 100%
rename from app/services/domains/crossref/application.py
rename to app/services/crossref/application.py
diff --git a/app/services/domains/dbops/__init__.py b/app/services/dbops/__init__.py
similarity index 100%
rename from app/services/domains/dbops/__init__.py
rename to app/services/dbops/__init__.py
diff --git a/app/services/domains/dbops/application.py b/app/services/dbops/application.py
similarity index 100%
rename from app/services/domains/dbops/application.py
rename to app/services/dbops/application.py
diff --git a/app/services/domains/dbops/integrity.py b/app/services/dbops/integrity.py
similarity index 100%
rename from app/services/domains/dbops/integrity.py
rename to app/services/dbops/integrity.py
diff --git a/app/services/domains/dbops/near_duplicate_repair.py b/app/services/dbops/near_duplicate_repair.py
similarity index 100%
rename from app/services/domains/dbops/near_duplicate_repair.py
rename to app/services/dbops/near_duplicate_repair.py
diff --git a/app/services/domains/dbops/query.py b/app/services/dbops/query.py
similarity index 100%
rename from app/services/domains/dbops/query.py
rename to app/services/dbops/query.py
diff --git a/app/services/domains/doi/normalize.py b/app/services/doi/normalize.py
similarity index 100%
rename from app/services/domains/doi/normalize.py
rename to app/services/doi/normalize.py
diff --git a/app/services/domains/users/__init__.py b/app/services/domains/users/__init__.py
deleted file mode 100644
index 9d48db4..0000000
--- a/app/services/domains/users/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from __future__ import annotations
diff --git a/app/services/domains/__init__.py b/app/services/ingestion/__init__.py
similarity index 100%
rename from app/services/domains/__init__.py
rename to app/services/ingestion/__init__.py
diff --git a/app/services/domains/ingestion/application.py b/app/services/ingestion/application.py
similarity index 100%
rename from app/services/domains/ingestion/application.py
rename to app/services/ingestion/application.py
diff --git a/app/services/domains/ingestion/constants.py b/app/services/ingestion/constants.py
similarity index 100%
rename from app/services/domains/ingestion/constants.py
rename to app/services/ingestion/constants.py
diff --git a/app/services/domains/ingestion/fingerprints.py b/app/services/ingestion/fingerprints.py
similarity index 100%
rename from app/services/domains/ingestion/fingerprints.py
rename to app/services/ingestion/fingerprints.py
diff --git a/app/services/domains/ingestion/queue.py b/app/services/ingestion/queue.py
similarity index 100%
rename from app/services/domains/ingestion/queue.py
rename to app/services/ingestion/queue.py
diff --git a/app/services/domains/ingestion/safety.py b/app/services/ingestion/safety.py
similarity index 100%
rename from app/services/domains/ingestion/safety.py
rename to app/services/ingestion/safety.py
diff --git a/app/services/domains/ingestion/scheduler.py b/app/services/ingestion/scheduler.py
similarity index 100%
rename from app/services/domains/ingestion/scheduler.py
rename to app/services/ingestion/scheduler.py
diff --git a/app/services/domains/ingestion/types.py b/app/services/ingestion/types.py
similarity index 100%
rename from app/services/domains/ingestion/types.py
rename to app/services/ingestion/types.py
diff --git a/app/services/domains/openalex/__init__.py b/app/services/openalex/__init__.py
similarity index 100%
rename from app/services/domains/openalex/__init__.py
rename to app/services/openalex/__init__.py
diff --git a/app/services/domains/openalex/client.py b/app/services/openalex/client.py
similarity index 100%
rename from app/services/domains/openalex/client.py
rename to app/services/openalex/client.py
diff --git a/app/services/domains/openalex/matching.py b/app/services/openalex/matching.py
similarity index 100%
rename from app/services/domains/openalex/matching.py
rename to app/services/openalex/matching.py
diff --git a/app/services/domains/openalex/types.py b/app/services/openalex/types.py
similarity index 100%
rename from app/services/domains/openalex/types.py
rename to app/services/openalex/types.py
diff --git a/app/services/domains/portability/__init__.py b/app/services/portability/__init__.py
similarity index 100%
rename from app/services/domains/portability/__init__.py
rename to app/services/portability/__init__.py
diff --git a/app/services/domains/portability/application.py b/app/services/portability/application.py
similarity index 100%
rename from app/services/domains/portability/application.py
rename to app/services/portability/application.py
diff --git a/app/services/domains/portability/constants.py b/app/services/portability/constants.py
similarity index 100%
rename from app/services/domains/portability/constants.py
rename to app/services/portability/constants.py
diff --git a/app/services/domains/portability/exporting.py b/app/services/portability/exporting.py
similarity index 100%
rename from app/services/domains/portability/exporting.py
rename to app/services/portability/exporting.py
diff --git a/app/services/domains/portability/normalize.py b/app/services/portability/normalize.py
similarity index 100%
rename from app/services/domains/portability/normalize.py
rename to app/services/portability/normalize.py
diff --git a/app/services/domains/portability/publication_import.py b/app/services/portability/publication_import.py
similarity index 100%
rename from app/services/domains/portability/publication_import.py
rename to app/services/portability/publication_import.py
diff --git a/app/services/domains/portability/scholar_import.py b/app/services/portability/scholar_import.py
similarity index 100%
rename from app/services/domains/portability/scholar_import.py
rename to app/services/portability/scholar_import.py
diff --git a/app/services/domains/portability/types.py b/app/services/portability/types.py
similarity index 100%
rename from app/services/domains/portability/types.py
rename to app/services/portability/types.py
diff --git a/app/services/domains/publication_identifiers/__init__.py b/app/services/publication_identifiers/__init__.py
similarity index 100%
rename from app/services/domains/publication_identifiers/__init__.py
rename to app/services/publication_identifiers/__init__.py
diff --git a/app/services/domains/publication_identifiers/application.py b/app/services/publication_identifiers/application.py
similarity index 100%
rename from app/services/domains/publication_identifiers/application.py
rename to app/services/publication_identifiers/application.py
diff --git a/app/services/domains/publication_identifiers/normalize.py b/app/services/publication_identifiers/normalize.py
similarity index 100%
rename from app/services/domains/publication_identifiers/normalize.py
rename to app/services/publication_identifiers/normalize.py
diff --git a/app/services/domains/publication_identifiers/types.py b/app/services/publication_identifiers/types.py
similarity index 100%
rename from app/services/domains/publication_identifiers/types.py
rename to app/services/publication_identifiers/types.py
diff --git a/app/services/domains/publications/__init__.py b/app/services/publications/__init__.py
similarity index 100%
rename from app/services/domains/publications/__init__.py
rename to app/services/publications/__init__.py
diff --git a/app/services/domains/publications/application.py b/app/services/publications/application.py
similarity index 100%
rename from app/services/domains/publications/application.py
rename to app/services/publications/application.py
diff --git a/app/services/domains/publications/counts.py b/app/services/publications/counts.py
similarity index 100%
rename from app/services/domains/publications/counts.py
rename to app/services/publications/counts.py
diff --git a/app/services/domains/publications/dedup.py b/app/services/publications/dedup.py
similarity index 100%
rename from app/services/domains/publications/dedup.py
rename to app/services/publications/dedup.py
diff --git a/app/services/domains/publications/enrichment.py b/app/services/publications/enrichment.py
similarity index 100%
rename from app/services/domains/publications/enrichment.py
rename to app/services/publications/enrichment.py
diff --git a/app/services/domains/publications/listing.py b/app/services/publications/listing.py
similarity index 100%
rename from app/services/domains/publications/listing.py
rename to app/services/publications/listing.py
diff --git a/app/services/domains/publications/modes.py b/app/services/publications/modes.py
similarity index 100%
rename from app/services/domains/publications/modes.py
rename to app/services/publications/modes.py
diff --git a/app/services/domains/publications/pdf_queue.py b/app/services/publications/pdf_queue.py
similarity index 100%
rename from app/services/domains/publications/pdf_queue.py
rename to app/services/publications/pdf_queue.py
diff --git a/app/services/domains/publications/pdf_resolution_pipeline.py b/app/services/publications/pdf_resolution_pipeline.py
similarity index 100%
rename from app/services/domains/publications/pdf_resolution_pipeline.py
rename to app/services/publications/pdf_resolution_pipeline.py
diff --git a/app/services/domains/publications/queries.py b/app/services/publications/queries.py
similarity index 100%
rename from app/services/domains/publications/queries.py
rename to app/services/publications/queries.py
diff --git a/app/services/domains/publications/read_state.py b/app/services/publications/read_state.py
similarity index 100%
rename from app/services/domains/publications/read_state.py
rename to app/services/publications/read_state.py
diff --git a/app/services/domains/publications/types.py b/app/services/publications/types.py
similarity index 100%
rename from app/services/domains/publications/types.py
rename to app/services/publications/types.py
diff --git a/app/services/domains/runs/__init__.py b/app/services/runs/__init__.py
similarity index 100%
rename from app/services/domains/runs/__init__.py
rename to app/services/runs/__init__.py
diff --git a/app/services/domains/runs/application.py b/app/services/runs/application.py
similarity index 100%
rename from app/services/domains/runs/application.py
rename to app/services/runs/application.py
diff --git a/app/services/domains/runs/events.py b/app/services/runs/events.py
similarity index 100%
rename from app/services/domains/runs/events.py
rename to app/services/runs/events.py
diff --git a/app/services/domains/runs/queue_queries.py b/app/services/runs/queue_queries.py
similarity index 100%
rename from app/services/domains/runs/queue_queries.py
rename to app/services/runs/queue_queries.py
diff --git a/app/services/domains/runs/queue_service.py b/app/services/runs/queue_service.py
similarity index 100%
rename from app/services/domains/runs/queue_service.py
rename to app/services/runs/queue_service.py
diff --git a/app/services/domains/runs/runs_service.py b/app/services/runs/runs_service.py
similarity index 100%
rename from app/services/domains/runs/runs_service.py
rename to app/services/runs/runs_service.py
diff --git a/app/services/domains/runs/summary.py b/app/services/runs/summary.py
similarity index 100%
rename from app/services/domains/runs/summary.py
rename to app/services/runs/summary.py
diff --git a/app/services/domains/runs/types.py b/app/services/runs/types.py
similarity index 100%
rename from app/services/domains/runs/types.py
rename to app/services/runs/types.py
diff --git a/app/services/domains/ingestion/__init__.py b/app/services/scholar/__init__.py
similarity index 100%
rename from app/services/domains/ingestion/__init__.py
rename to app/services/scholar/__init__.py
diff --git a/app/services/domains/scholar/author_rows.py b/app/services/scholar/author_rows.py
similarity index 100%
rename from app/services/domains/scholar/author_rows.py
rename to app/services/scholar/author_rows.py
diff --git a/app/services/domains/scholar/parser.py b/app/services/scholar/parser.py
similarity index 100%
rename from app/services/domains/scholar/parser.py
rename to app/services/scholar/parser.py
diff --git a/app/services/domains/scholar/parser_constants.py b/app/services/scholar/parser_constants.py
similarity index 100%
rename from app/services/domains/scholar/parser_constants.py
rename to app/services/scholar/parser_constants.py
diff --git a/app/services/domains/scholar/parser_types.py b/app/services/scholar/parser_types.py
similarity index 100%
rename from app/services/domains/scholar/parser_types.py
rename to app/services/scholar/parser_types.py
diff --git a/app/services/domains/scholar/parser_utils.py b/app/services/scholar/parser_utils.py
similarity index 100%
rename from app/services/domains/scholar/parser_utils.py
rename to app/services/scholar/parser_utils.py
diff --git a/app/services/domains/scholar/profile_rows.py b/app/services/scholar/profile_rows.py
similarity index 100%
rename from app/services/domains/scholar/profile_rows.py
rename to app/services/scholar/profile_rows.py
diff --git a/app/services/domains/scholar/rate_limit.py b/app/services/scholar/rate_limit.py
similarity index 100%
rename from app/services/domains/scholar/rate_limit.py
rename to app/services/scholar/rate_limit.py
diff --git a/app/services/domains/scholar/source.py b/app/services/scholar/source.py
similarity index 100%
rename from app/services/domains/scholar/source.py
rename to app/services/scholar/source.py
diff --git a/app/services/domains/scholar/state_detection.py b/app/services/scholar/state_detection.py
similarity index 100%
rename from app/services/domains/scholar/state_detection.py
rename to app/services/scholar/state_detection.py
diff --git a/app/services/domains/scholar/__init__.py b/app/services/scholars/__init__.py
similarity index 100%
rename from app/services/domains/scholar/__init__.py
rename to app/services/scholars/__init__.py
diff --git a/app/services/domains/scholars/application.py b/app/services/scholars/application.py
similarity index 100%
rename from app/services/domains/scholars/application.py
rename to app/services/scholars/application.py
diff --git a/app/services/domains/scholars/constants.py b/app/services/scholars/constants.py
similarity index 100%
rename from app/services/domains/scholars/constants.py
rename to app/services/scholars/constants.py
diff --git a/app/services/domains/scholars/exceptions.py b/app/services/scholars/exceptions.py
similarity index 100%
rename from app/services/domains/scholars/exceptions.py
rename to app/services/scholars/exceptions.py
diff --git a/app/services/domains/scholars/search_hints.py b/app/services/scholars/search_hints.py
similarity index 100%
rename from app/services/domains/scholars/search_hints.py
rename to app/services/scholars/search_hints.py
diff --git a/app/services/domains/scholars/uploads.py b/app/services/scholars/uploads.py
similarity index 100%
rename from app/services/domains/scholars/uploads.py
rename to app/services/scholars/uploads.py
diff --git a/app/services/domains/scholars/validators.py b/app/services/scholars/validators.py
similarity index 100%
rename from app/services/domains/scholars/validators.py
rename to app/services/scholars/validators.py
diff --git a/app/services/domains/scholars/__init__.py b/app/services/settings/__init__.py
similarity index 100%
rename from app/services/domains/scholars/__init__.py
rename to app/services/settings/__init__.py
diff --git a/app/services/domains/settings/application.py b/app/services/settings/application.py
similarity index 100%
rename from app/services/domains/settings/application.py
rename to app/services/settings/application.py
diff --git a/app/services/domains/unpaywall/__init__.py b/app/services/unpaywall/__init__.py
similarity index 100%
rename from app/services/domains/unpaywall/__init__.py
rename to app/services/unpaywall/__init__.py
diff --git a/app/services/domains/unpaywall/application.py b/app/services/unpaywall/application.py
similarity index 100%
rename from app/services/domains/unpaywall/application.py
rename to app/services/unpaywall/application.py
diff --git a/app/services/domains/unpaywall/pdf_discovery.py b/app/services/unpaywall/pdf_discovery.py
similarity index 100%
rename from app/services/domains/unpaywall/pdf_discovery.py
rename to app/services/unpaywall/pdf_discovery.py
diff --git a/app/services/domains/unpaywall/rate_limit.py b/app/services/unpaywall/rate_limit.py
similarity index 100%
rename from app/services/domains/unpaywall/rate_limit.py
rename to app/services/unpaywall/rate_limit.py
diff --git a/app/services/domains/settings/__init__.py b/app/services/users/__init__.py
similarity index 100%
rename from app/services/domains/settings/__init__.py
rename to app/services/users/__init__.py
diff --git a/app/services/domains/users/application.py b/app/services/users/application.py
similarity index 100%
rename from app/services/domains/users/application.py
rename to app/services/users/application.py
-- 
2.49.1


From 6c31b331f783fe381bb4b79c3c90bb41f68c596f Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 00:07:25 +0100
Subject: [PATCH 14/38] ci: adopt python-semantic-release, fix hardcoded
 version strings

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/workflows/release.yml        | 27 +++++++++++++++++++++++++++
 app/services/crossref/application.py |  9 ++++++---
 pyproject.toml                       |  8 ++++++++
 3 files changed, 41 insertions(+), 3 deletions(-)
 create mode 100644 .github/workflows/release.yml

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..0e0166c
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,27 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    if: github.repository == 'JustinZeus/scholarr'
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install python-semantic-release
+      - name: Semantic Release
+        id: release
+        run: semantic-release publish
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/app/services/crossref/application.py b/app/services/crossref/application.py
index 9b7076c..a9e46d5 100644
--- a/app/services/crossref/application.py
+++ b/app/services/crossref/application.py
@@ -5,16 +5,19 @@ import logging
 import re
 import threading
 import time
+from importlib.metadata import version as pkg_version
 from typing import TYPE_CHECKING
 
 from crossref.restful import Etiquette, Works
 
 from app.logging_utils import structured_log
-from app.services.domains.doi.normalize import normalize_doi
+from app.services.doi.normalize import normalize_doi
 from app.settings import settings
 
+_APP_VERSION = pkg_version("scholarr")
+
 if TYPE_CHECKING:
-    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+    from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 TOKEN_RE = re.compile(r"[a-z0-9]+")
 NON_ALNUM_RE = re.compile(r"[^a-z0-9\\s]+")
@@ -292,7 +295,7 @@ def _best_candidate_doi(
 
 def _works_client(email: str | None) -> Works:
     if email:
-        etiquette = Etiquette(settings.app_name, "0.1.0", "https://scholarr.local", email)
+        etiquette = Etiquette(settings.app_name, _APP_VERSION, "https://scholarr.local", email)
         return Works(etiquette=etiquette)
     return Works()
 
diff --git a/pyproject.toml b/pyproject.toml
index 79c61b1..2a0c15f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -27,6 +27,7 @@ dependencies = [
 dev = [
   "pytest>=8.3,<9.0",
   "pytest-asyncio>=0.25,<0.26",
+  "python-semantic-release>=9.0,<10.0",
   "ruff>=0.9",
   "mypy>=1.14",
 ]
@@ -61,6 +62,13 @@ ignore_missing_imports = true
 check_untyped_defs = false
 warn_unused_ignores = true
 
+[tool.semantic_release]
+version_toml = ["pyproject.toml:project.version"]
+version_variables = ["frontend/package.json:version"]
+branch = "main"
+build_command = ""
+commit_message = "chore(release): v{version}"
+
 [tool.setuptools]
 include-package-data = true
 
-- 
2.49.1


From 0c5b199b766a91e86f54f44a7b690edaa4ee8708 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 09:39:27 +0100
Subject: [PATCH 15/38] docs: rebuild documentation from scratch with clean IA

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 docs/README.md                             |  23 ---
 docs/developer/api-contract.md             |  12 --
 docs/developer/architecture.md             | 181 +++++++++++++----
 docs/developer/contributing.md             |  90 +++++++--
 docs/developer/documentation-standards.md  |  26 ---
 docs/developer/frontend-theme-inventory.md | 166 +++++++++-------
 docs/developer/ingestion.md                | 109 ++++++++---
 docs/developer/local-development.md        | 100 +++++++---
 docs/developer/overview.md                 |  72 ++++++-
 docs/developer/testing.md                  | 102 ++++++++++
 docs/index.md                              |  44 ++---
 docs/operations/arxiv-runbook.md           |  58 ++++--
 docs/operations/database-runbook.md        | 215 +++++++++++++++------
 docs/operations/deployment.md              | 117 +++++++++++
 docs/operations/migration-checklist.md     |  48 -----
 docs/operations/overview.md                |  34 +++-
 docs/operations/scrape-safety-runbook.md   |  88 ++++-----
 docs/reference/api-contract.md             |  31 ---
 docs/reference/api.md                      | 177 +++++++++++++++++
 docs/reference/changelog.md                |  12 ++
 docs/reference/environment.md              |  86 +++------
 docs/reference/overview.md                 |  16 +-
 docs/user/configuration.md                 | 178 +++++++++++++++++
 docs/user/getting-started.md               | 109 ++++++++---
 docs/user/overview.md                      |  30 ++-
 docs/website/docusaurus.config.js          |  79 ++++----
 docs/website/package.json                  |  19 +-
 docs/website/sidebars.js                   |  47 +++--
 docs/website/src/css/custom.css            |  27 ++-
 docs/website/static/img/favicon.ico        | Bin 15086 -> 0 bytes
 30 files changed, 1647 insertions(+), 649 deletions(-)
 delete mode 100644 docs/README.md
 delete mode 100644 docs/developer/api-contract.md
 delete mode 100644 docs/developer/documentation-standards.md
 create mode 100644 docs/developer/testing.md
 create mode 100644 docs/operations/deployment.md
 delete mode 100644 docs/operations/migration-checklist.md
 delete mode 100644 docs/reference/api-contract.md
 create mode 100644 docs/reference/api.md
 create mode 100644 docs/reference/changelog.md
 create mode 100644 docs/user/configuration.md
 delete mode 100644 docs/website/static/img/favicon.ico

diff --git a/docs/README.md b/docs/README.md
deleted file mode 100644
index f6b8216..0000000
--- a/docs/README.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# Documentation Index
-
-This directory contains both docs content and docs tooling.
-
-## Audience-Based Structure
-
-- `docs/user/`: onboarding and usage-oriented docs for self-hosters.
-- `docs/operations/`: runbooks and rollout checklists for ongoing operations.
-- `docs/developer/`: architecture, contribution standards, and local development workflows.
-- `docs/reference/`: canonical API and environment contracts.
-
-## Docs Tooling
-
-- `docs/website/`: Docusaurus app used to publish docs to GitHub Pages.
-
-## Recommended Reading Paths
-
-- Users: `docs/user/getting-started.md`
-- Operators: `docs/operations/overview.md`
-- Developers: `docs/developer/overview.md`
-- Contract consumers: `docs/reference/overview.md`
-
-Published site: https://justinzeus.github.io/scholarr/
diff --git a/docs/developer/api-contract.md b/docs/developer/api-contract.md
deleted file mode 100644
index 6884bc6..0000000
--- a/docs/developer/api-contract.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# API Contracts
-
-`Scholarr` is designed with strictly typed Pydantic V2 models, serialized across the network through standard OpenAPI `v3` specs via FastAPI.
-
-## DTO Models Structure
-FastAPI routes dynamically ingest request/response Data Transfer Objects.
-- **Example**: `PublicationListItem` no longer contains a hard-coded `.doi`. It contains a `.display_identifier` property resolving the highest confidence identifier regardless of backend origin.
-- **Testing**: Run `./scripts/check_frontend_api_contract.py` or equivalent integration steps mapped in CI to ensure that backend python routes strictly map to the TypeScript types compiled by the Frontend.
-
-## Frontend Contract Requirements
-The UI exclusively calls routes exposed by FastAPI's `APIRouter`. 
-All frontend integration tests enforce that Vue 3 Components do not assume hard properties directly outside the bounded TS schemas. This avoids type mismatch runtime explosions if the database is scaled horizontally.
diff --git a/docs/developer/architecture.md b/docs/developer/architecture.md
index 4330830..392670e 100644
--- a/docs/developer/architecture.md
+++ b/docs/developer/architecture.md
@@ -1,58 +1,173 @@
-# Domain Boundaries
+---
+title: Architecture
+sidebar_position: 2
+---
+
+# Architecture
 
 ## Data Model Rules
 
-- Scholar tracking is user-scoped.
-- Publications are global/deduplicated records.
-- Read/favorite/visibility state stays on scholar-publication link rows.
+- **Scholar tracking is user-scoped.** Each user manages their own list of tracked scholars. Validate mapping/join tables; never assume global links between users and Scholar IDs.
+- **Publications are global, deduplicated records.** Deduplicate via Scholar cluster ID and normalized fingerprinting prior to database insertion.
+- **State lives on the link.** Read/unread, favorites, and visibility state exist exclusively on the scholar-publication link table, not the global publication table.
 
-## Service Boundaries
+## Domain Service Boundaries
 
-Canonical business logic belongs in `app/services/domains/*`.
+All business logic resides in `app/services/<domain>/`. Flat files in the `app/services/` root are strictly prohibited.
 
-- `app/services/domains/ingestion/*`: run orchestration, continuation queue, scheduler, and scrape safety.
-- `app/services/domains/scholar/*`: fail-fast scholar parsing and source fetch adapters.
-- `app/services/domains/scholars/*`: scholar CRUD, profile image, and name-search controls.
-- `app/services/domains/publications/*`: listing/read-state, favorite toggles, enrichment scheduling, and retry paths.
-- `app/services/domains/arxiv/*`: typed API client, global DB-backed throttle, query cache, and in-flight request coalescing.
-- `app/services/domains/crossref/*` + `app/services/domains/unpaywall/*`: DOI/OA enrichment with bounded pacing.
-- `app/services/domains/runs/*`: run history and continuation queue operations.
-- `app/services/domains/portability/*`: import/export workflows.
+### Ingestion (`app/services/ingestion/`)
 
-## Frontend Behavior Notes
+Run orchestration, continuation queue, scheduler integration, and scrape safety policy enforcement. The `ScholarIngestionService` drives the primary data acquisition loop.
 
-- Navigation: Mobile primary nav is in a left drawer and closes on route change or logout.
-- Lists: Long list views use internal scroll containers to prevent viewport overflow.
-- Rate Limiting: Name search remains intentionally constrained due to upstream anti-bot behavior; production onboarding should prefer scholar ID/profile URLs directly if possible.
+Key modules:
+- `application.py` - Main ingestion orchestrator
+- `scheduler.py` - Background tick loop, queue batch processing
+- `constants.py` - Safety policy constants and floor values
+- `fingerprints.py` - Publication fingerprinting for deduplication
+- `types.py` - Ingestion result types and state enums
 
-## Data Integration & Acquisition Flow
+### Scholar Parsing (`app/services/scholar/`)
+
+Fail-fast Google Scholar HTML parsing and source fetch adapters. Handles paginated HTML feeds, extracts publication blocks via regex and DOM invariants (e.g., `gsc_vcd_cib`).
+
+Key modules:
+- `parser.py` - HTML parser for publication extraction
+- `parser_utils.py` - Parsing helpers and DOM selectors
+- `source.py` - HTTP fetch adapters with browser headers
+- `profile_rows.py` - Profile metadata extraction
+- `author_rows.py` - Author citation row parsing
+- `state_detection.py` - Blocked/CAPTCHA/rate-limit detection
+
+### Scholar Management (`app/services/scholars/`)
+
+Scholar CRUD, profile image management, and name-search controls with rate limiting.
+
+Key modules:
+- `application.py` - Scholar lifecycle operations
+- `uploads.py` - Image upload handling
+- `search_hints.py` - Name search with caching and cooldowns
+- `validators.py` - Input validation for scholar creation
+
+### Publications (`app/services/publications/`)
+
+Listing, read-state management, favorite toggles, enrichment scheduling, deduplication, and PDF queue management.
+
+Key modules:
+- `application.py` - Publication service facade
+- `listing.py` - Filtered listing with pagination (modes: all/unread/latest)
+- `queries.py` - Database query builders
+- `counts.py` - Aggregation counts for dashboard
+- `dedup.py` - Duplicate detection and merging
+- `enrichment.py` - Identifier and metadata enrichment orchestration
+- `pdf_queue.py` - PDF resolution queue policy
+- `pdf_resolution_pipeline.py` - Multi-source PDF resolution (Unpaywall, arXiv)
+- `types.py` - Publication DTOs and response types
+
+### Publication Identifiers (`app/services/publication_identifiers/`)
+
+Multi-identifier resolution engine. A single publication can have multiple identifiers (DOI, arXiv ID, PMID, PMCID). This decoupled approach replaced the earlier hardcoded DOI-only model.
+
+Key modules:
+- `application.py` - Identifier gathering orchestration
+- `normalize.py` - Identifier normalization and validation
+
+### arXiv (`app/services/arxiv/`)
+
+Typed API client with global DB-backed throttle, query cache, and in-flight request coalescing.
+
+Key modules:
+- `client.py` - HTTP client for arXiv export API
+- `gateway.py` - Gateway with advisory lock, caching, and coalescing
+- `cache.py` - Query cache with TTL and max-entry pruning
+- `rate_limit.py` - Global rate limiter via `arxiv_runtime_state` table
+- `guards.py` - Load-shedding guards (skip when DOI/arXiv evidence exists)
+- `parser.py` - Atom XML response parser
+
+Safety features:
+- Requests are globally serialized via a PostgreSQL advisory lock and shared runtime row (`arxiv_runtime_state`)
+- Identical request payloads are fingerprinted and cached in `arxiv_query_cache_entries` with TTL + max-entry pruning
+- Concurrent identical misses are coalesced in-process (one outbound call serves all waiters)
+
+### Crossref (`app/services/crossref/`)
+
+DOI lookup via Crossref REST API with bounded pacing and configurable batch limits.
+
+### Unpaywall (`app/services/unpaywall/`)
+
+Open-access PDF resolution via Unpaywall API, with HTML-based PDF link discovery as a fallback.
+
+Key modules:
+- `application.py` - Unpaywall service facade
+- `pdf_discovery.py` - HTML page scraping for PDF link candidates
+
+### OpenAlex (`app/services/openalex/`)
+
+Metadata matching via OpenAlex API for supplementary identifier resolution.
+
+Key modules:
+- `client.py` - OpenAlex API client
+- `matching.py` - Fuzzy title/author matching
+
+### Runs (`app/services/runs/`)
+
+Run history tracking and continuation queue operations.
+
+Key modules:
+- `application.py` - Run lifecycle management
+- `queue_service.py` - Continuation queue operations (retry, drop, clear)
+- `queue_queries.py` - Queue item queries
+
+### Portability (`app/services/portability/`)
+
+Import/export workflows for scholar data with full publication state preservation.
+
+Key modules:
+- `application.py` - Import/export orchestration
+- `exporting.py` - Scholar export serialization
+- `publication_import.py` - Publication import with deduplication
+- `scholar_import.py` - Scholar import with link reconstruction
+- `normalize.py` - Payload normalization and validation
+
+### Database Operations (`app/services/dbops/`)
+
+Integrity checking, link repair, and near-duplicate repair operations exposed via admin API and CLI scripts.
+
+Key modules:
+- `__init__.py` - `collect_integrity_report`, `run_publication_link_repair`
+- `near_duplicate_repair.py` - Near-duplicate publication detection and merging
+
+## Data Integration Flow
 
 ```mermaid
 graph TD
     UI[Frontend Vue App] --> API[FastAPI Backend]
-    API --> Scheduler[Background Celery/Async Scheduler]
-    
+    API --> Scheduler[Background Async Scheduler]
+
     Scheduler -->|1. Fetch HTML| Scholar[Google Scholar HTML Parser]
     Scholar -->|2. Extract Metadata| IdentifierModule[Identifier Gathering]
-    
+
     IdentifierModule -->|Search arXiv API| API1(arXiv)
     IdentifierModule -->|Search Crossref API| API2(Crossref)
-    
+
     IdentifierModule -->|3. Save Identifiers| DB[(PostgreSQL)]
-    
+
     Scheduler -->|4. Resolve PDF| PDFPipeline[PDF Resolution Pipeline]
     DB --> |Identified DOIs| PDFPipeline
     PDFPipeline -->|Search Open Access APIs| Unpaywall(Unpaywall API)
-    
+
     Unpaywall --> |Acquire PDF URL| PDFWorker[PDF Download Worker]
-    PDFWorker --> |Store PDF Metadata| DB 
+    PDFWorker --> |Store PDF Metadata| DB
 ```
 
-### Identifier Engine Philosophy
-The platform previously treated the `DOI` as a hardcoded 1:1 property of a publication. It now utilizes a decoupled *Identifier Gathering* module (`PublicationIdentifier` table). A single publication can have multiple identifiers (ex. `doi`, `arxiv`, `pmid`, `pmcid`). This creates high resilience when integrating with external APIs, allowing systems like Unpaywall to be fed explicitly with high-confidence DOIs, rather than relying on unstructured search heuristics.
+## API Layer
 
-### arXiv Safety and Efficiency
-- arXiv requests are globally serialized via a PostgreSQL advisory lock and shared runtime row (`arxiv_runtime_state`).
-- identical request payloads are fingerprinted and cached in `arxiv_query_cache_entries` with TTL + optional max-entry pruning.
-- concurrent identical misses are coalesced in-process, so one outbound call serves all waiters.
-- structured logs provide auditability for scheduling/completion/cooldown/cache behavior.
+Routes live in `app/api/routers/`. All responses under `/api/v1` use a strict envelope format. See [API Reference](../reference/api.md) for the full contract.
+
+## Middleware Stack
+
+Applied in `app/main.py`:
+
+1. **CSRF Protection** - Token-based CSRF validation
+2. **Session Middleware** - Cookie-based session management (itsdangerous signing)
+3. **Request Logging** - Structured request/response logging with configurable skip paths
+4. **Security Headers** - Configurable HTTP security headers and CSP
diff --git a/docs/developer/contributing.md b/docs/developer/contributing.md
index ab44797..ec5ad5e 100644
--- a/docs/developer/contributing.md
+++ b/docs/developer/contributing.md
@@ -1,24 +1,78 @@
+---
+title: Contributing
+sidebar_position: 4
+---
+
 # Contributing
 
-## Scope
-This project favors small, reviewable pull requests that keep runtime behavior clear and operationally safe.
+## PR Process
 
-## Essential-File Policy
-Commit only source-of-truth files required to build, run, test, or document the app.
+1. Create a feature branch from `main`.
+2. Make your changes following the code standards below.
+3. Run tests inside the container (see [Testing](testing.md)).
+4. Run `ruff check .` and `mypy app/` to catch lint and type errors.
+5. Open a pull request with a clear title and description.
 
-Do not commit generated or local-only artifacts, including:
-- `__pycache__/`, `*.pyc`, `.pytest_cache/`, `.mypy_cache/`, `.ruff_cache/`
-- frontend build/install outputs like `frontend/dist/`, `frontend/node_modules/`, `frontend/.vite/`
-- coverage outputs (`.coverage`, `htmlcov/`)
-- packaging/build leftovers (`*.egg-info/`, `build/`, `dist/`)
-- local probe/scratch material (`planning/`)
+## Commit Conventions
 
-CI enforces this with `scripts/check_no_generated_artifacts.sh`.
+This project uses [Conventional Commits](https://www.conventionalcommits.org/) with [python-semantic-release](https://python-semantic-release.readthedocs.io/) for automated versioning.
 
-## Merge Checklist
-- [ ] Changes are minimal, purposeful, and remove obsolete/dead code in touched areas.
-- [ ] Backend tests pass (`uv run pytest tests/unit` and integration scope as needed).
-- [ ] Frontend checks pass (`npm run typecheck`, `npm run test:run`, `npm run build`).
-- [ ] API/behavior docs are updated when env vars, endpoints, or payloads change.
-- [ ] `README.md`, `.env.example`, and deployment notes stay aligned.
-- [ ] `scripts/check_no_generated_artifacts.sh` passes locally.
+Commit message format:
+
+```
+<type>(<scope>): <description>
+
+[optional body]
+```
+
+Types: `feat`, `fix`, `docs`, `ci`, `refactor`, `test`, `chore`, `perf`.
+
+Examples:
+- `feat(scholars): add bulk import from CSV`
+- `fix(ingestion): handle empty citation blocks`
+- `docs: update configuration reference`
+
+## Code Standards
+
+### Function Length
+
+Maximum 50 lines per function. Break complex logic into small, testable, single-responsibility functions.
+
+### DRY
+
+Abstract repetitive logic immediately. No duplicate boilerplate for database queries, API responses, or error handling.
+
+### Negative Space Programming
+
+Use explicit assertions and constraints to define invalid states. Fail fast and early. Do not allow silent failures or cascading malformed data, especially in DOM parsing.
+
+### Cyclomatic Complexity
+
+Flatten logic. Use early returns and guard clauses instead of deep nesting. No magic numbers.
+
+### Domain Service Boundaries
+
+All business logic resides in `app/services/<domain>/`. Flat files in the `app/services/` root are strictly prohibited. Each domain owns its own application service, types, and helpers.
+
+### API Envelope
+
+All `/api/v1` responses use the strict envelope format:
+
+- Success: `{"data": ..., "meta": {"request_id": "..."}}`
+- Error: `{"error": {"code": "...", "message": "...", "details": ...}, "meta": {"request_id": "..."}}`
+
+### Data Isolation
+
+- Scholar tracking is user-scoped.
+- Publications are global, deduplicated records.
+- Read/favorite/visibility state lives on scholar-publication link rows.
+
+### Scrape Safety
+
+Rate limits and cooldowns are immutable constraints. They prevent IP bans and must not be optimized away or set to zero.
+
+## UI Standards
+
+- Integrate Tailwind with the preset theming system (`frontend/src/theme/presets/`).
+- Every UI element must have a clear purpose.
+- Clarity through both styling and language.
diff --git a/docs/developer/documentation-standards.md b/docs/developer/documentation-standards.md
deleted file mode 100644
index f3c25b9..0000000
--- a/docs/developer/documentation-standards.md
+++ /dev/null
@@ -1,26 +0,0 @@
-# Documentation Standards
-
-This project keeps docs organized by audience and document type.
-
-## Audience Split
-
-- `user/`: onboarding and usage tasks for self-hosted users.
-- `operations/`: runbooks and checklists for production operation.
-- `developer/`: architecture, contribution workflow, and implementation guides.
-- `reference/`: stable contracts (API, env variables, configuration behavior).
-
-## Document Quality Rules
-
-- One primary audience per page.
-- Task pages must include prerequisites, exact commands, and verification steps.
-- Reference pages should be contract-first and avoid procedural noise.
-- Runbooks should include recovery steps and rollback/safety notes.
-- Prefer concise pages with strong cross-links over long mixed-purpose pages.
-
-## Required Top-Level Entrypoints
-
-- `index.md`: user/developer/operator navigation hub.
-- `user/getting-started.md`: first-run path.
-- `developer/local-development.md`: contributor setup and validation path.
-- `operations/overview.md`: operational playbook index.
-- `reference/overview.md`: contract index.
diff --git a/docs/developer/frontend-theme-inventory.md b/docs/developer/frontend-theme-inventory.md
index b8d6571..0233071 100644
--- a/docs/developer/frontend-theme-inventory.md
+++ b/docs/developer/frontend-theme-inventory.md
@@ -1,89 +1,105 @@
-# Theme Inventory (Phase 0)
+---
+title: Frontend Theme Inventory
+sidebar_position: 6
+---
 
-This file captures the semantic color system baseline for the theme refactor.
+# Frontend Theme Inventory
 
 ## Token Domains
 
-- `scale`:
-  - `brand` (`50..950`)
-  - `info` (`50..950`)
-  - `success` (`50..950`)
-  - `warning` (`50..950`)
-  - `danger` (`50..950`)
-- `surface`:
-  - `app`
-  - `nav`
-  - `nav_active`
-  - `card`
-  - `card_muted`
-  - `table`
-  - `table_header`
-  - `input`
-  - `overlay`
-- `text`:
-  - `primary`
-  - `secondary`
-  - `muted`
-  - `inverse`
-  - `link`
-- `border`:
-  - `default`
-  - `strong`
-  - `subtle`
-  - `interactive`
-- `focus`:
-  - `ring`
-  - `ring_offset`
-- `action` variants (`primary`, `secondary`, `ghost`, `danger`):
-  - `bg`
-  - `border`
-  - `text`
-  - `hover_bg`
-  - `hover_border`
-  - `hover_text`
-- `state` variants (`info`, `success`, `warning`, `danger`):
-  - `bg`
-  - `border`
-  - `text`
+The theme system uses semantic tokens organized into domains:
 
-## Theme Sources
+### Scale Colors
 
-Theme presets are dynamically loaded from `frontend/src/theme/presets/*.{json,js}`.
+Color ramps from `50` to `950` for each intent:
 
-Current preset files:
+- `brand` - Primary brand color
+- `info` - Informational elements
+- `success` - Success states
+- `warning` - Warning states
+- `danger` - Error/destructive states
 
-- `frontend/src/theme/presets/parchment.js`
-- `frontend/src/theme/presets/lilac.js`
-- `frontend/src/theme/presets/dune.js`
-- `frontend/src/theme/presets/oatmeal.js`
-- `frontend/src/theme/presets/scholarly.json`
-- `frontend/src/theme/presets/graphite.json`
-- `frontend/src/theme/presets/tide.json`
+### Surface
 
-Each preset contains both `light` and `dark` mode token definitions.
+Background colors for major UI areas:
 
-## Adoption Status (Phase 0-3 complete baseline)
+| Token | Usage |
+|-------|-------|
+| `app` | Application background |
+| `nav` | Navigation bar |
+| `nav_active` | Active navigation item |
+| `card` | Card backgrounds |
+| `card_muted` | Muted card variant |
+| `table` | Table body |
+| `table_header` | Table header |
+| `input` | Form inputs |
+| `overlay` | Modal/dialog overlays |
 
-Tokenized foundation components:
+### Text
 
-- `AppButton`
-- `AppCard`
-- `AppCheckbox`
-- `AppEmptyState`
-- `AppHelpHint`
-- `AppInput`
-- `AppSelect`
-- `AppTable`
-- `AppModal`
-- `AppHeader`
-- `AppNav`
-- `AppAlert`
-- `AppBadge`
-- `RunStatusBadge`
-- `QueueHealthBadge`
+| Token | Usage |
+|-------|-------|
+| `primary` | Default text |
+| `secondary` | Supporting text |
+| `muted` | Disabled/placeholder text |
+| `inverse` | Text on dark backgrounds |
+| `link` | Hyperlinks |
 
-Hardening in place:
+### Border
 
-- Frontend token policy check script: `frontend/scripts/check_theme_tokens.mjs`
-- CI enforcement step in `frontend-quality` workflow
-- Theme preset integrity tests in `frontend/src/theme/presets.test.ts`
+| Token | Usage |
+|-------|-------|
+| `default` | Standard borders |
+| `strong` | Emphasized borders |
+| `subtle` | Light separators |
+| `interactive` | Hover/focus borders |
+
+### Focus
+
+| Token | Usage |
+|-------|-------|
+| `ring` | Focus ring color |
+| `ring_offset` | Focus ring offset color |
+
+### Action Variants
+
+Each action type (`primary`, `secondary`, `ghost`, `danger`) provides:
+
+`bg`, `border`, `text`, `hover_bg`, `hover_border`, `hover_text`
+
+### State Variants
+
+Each state (`info`, `success`, `warning`, `danger`) provides:
+
+`bg`, `border`, `text`
+
+## Theme Presets
+
+Presets are loaded from `frontend/src/theme/presets/*.{json,js}`. Each contains both `light` and `dark` mode token definitions.
+
+Current presets:
+
+| Preset | Format |
+|--------|--------|
+| `parchment` | JS |
+| `lilac` | JS |
+| `dune` | JS |
+| `oatmeal` | JS |
+| `scholarly` | JSON |
+| `graphite` | JSON |
+| `tide` | JSON |
+
+## Tokenized Components
+
+Foundation components using the token system:
+
+- `AppButton`, `AppCard`, `AppCheckbox`, `AppEmptyState`
+- `AppHelpHint`, `AppInput`, `AppSelect`, `AppTable`
+- `AppModal`, `AppHeader`, `AppNav`, `AppAlert`
+- `AppBadge`, `RunStatusBadge`, `QueueHealthBadge`
+
+## Enforcement
+
+- Token policy check: `frontend/scripts/check_theme_tokens.mjs`
+- CI step in `frontend-quality` workflow
+- Preset integrity tests: `frontend/src/theme/presets.test.ts`
diff --git a/docs/developer/ingestion.md b/docs/developer/ingestion.md
index 26ee8e7..12eb014 100644
--- a/docs/developer/ingestion.md
+++ b/docs/developer/ingestion.md
@@ -1,38 +1,89 @@
-# Ingestion System & Backoff Strategies
+---
+title: Ingestion Pipeline
+sidebar_position: 5
+---
 
-The `ScholarIngestionService` drives the primary data acquisition loop. Since Google Scholar utilizes heavy bot protection and rate limits, this package contains nuanced backoffs to protect user networks from automated IP bans.
+# Ingestion Pipeline
 
-## Ingestion Overview
-The underlying ingestion process:
-1. Receives an explicit request or background cron trigger to resolve a `scholar_profile_id`.
-2. Connects asynchronously using configured HTTPX adapters with strict browser headers.
-3. Downloads the paginated HTML feed for a user across multiple page iterations.
-4. Uses `regex` and DOM-invariants (e.g. `gsc_vcd_cib`) to pull individual publication blocks.
+The `ScholarIngestionService` drives the primary data acquisition loop. Google Scholar uses heavy bot protection, so the pipeline includes nuanced backoff strategies to protect user networks from IP bans.
 
-## Handling 429 Too Many Requests
-Google Scholar aggressively throws HTTP 429 responses if multiple concurrent tabs or rapidly sequential commands query the same IP address for specific API endpoints (like `citations?view_op=view_citation...`). 
+## Pipeline Overview
 
-Scholarr treats these distinct from random network timeouts.
-- **Network Error Retries**: Handled via `ingestion_network_error_retries` with a base backoff of `ingestion_retry_backoff_seconds` (Default 1.0s).
-- **Rate Limit 429 Retries**: When `ParseState.BLOCKED_OR_CAPTCHA` captures `blocked_http_429_rate_limited`, the system applies a dedicated cooldown. It respects `ingestion_rate_limit_retries` multiplied by `ingestion_rate_limit_backoff_seconds` (Default 30.0s). This prevents the pipeline from fatalizing a user's job completely, pausing operations seamlessly instead.
+1. The scheduler (or a manual trigger) starts a **run** for one or more scholars.
+2. The service connects via HTTPX with strict browser headers.
+3. Paginated HTML feeds are downloaded for each scholar profile.
+4. A regex + DOM-invariant parser (`gsc_vcd_cib` selectors) extracts publication blocks.
+5. Publications are fingerprinted and deduplicated against the global store.
+6. External APIs resolve additional identifiers.
+7. The PDF resolution pipeline runs asynchronously for publications with known DOIs.
 
-## Publication Identifiers Loop
-Once a publication is built, the `gather_identifiers_for_publication` module isolates keys explicitly.
-- **Local Parsing**: Searches for direct identifiers within the HTML parameters (DOI patterns, arXiv regexes).
-- **API Fetching**: Queries secondary bibliographic platforms sequentially:
-  - `export.arxiv.org/api/query` (Queries by Title and Author strings).
-  - `crossref.restful` APIs (Queries by Title and Author strings).
+## Rate Limiting & Backoff
 
-These identifiers are accumulated in `publication_identifiers` instead of being bound as hard-coded properties, maximizing matching resilience in the automated Unpaywall PDF acquisition stage.
+### Network Errors
+
+Handled via `INGESTION_NETWORK_ERROR_RETRIES` (default: 1) with base backoff of `INGESTION_RETRY_BACKOFF_SECONDS` (default: 1.0s).
+
+### HTTP 429 (Rate Limited)
+
+When the parser detects `BLOCKED_OR_CAPTCHA` with `blocked_http_429_rate_limited`, a dedicated cooldown applies:
+
+- Retries: `INGESTION_RATE_LIMIT_RETRIES` (default: 3)
+- Backoff per retry: `INGESTION_RATE_LIMIT_BACKOFF_SECONDS` (default: 30s)
+
+This pauses the pipeline gracefully instead of failing the entire run.
+
+### Safety Cooldowns
+
+Threshold-based cooldowns halt all ingestion after repeated failures:
+
+| Threshold | Variable | Default | Cooldown |
+|-----------|----------|---------|----------|
+| Blocked failures | `INGESTION_ALERT_BLOCKED_FAILURE_THRESHOLD` | 1 | 1800s (30 min) |
+| Network failures | `INGESTION_ALERT_NETWORK_FAILURE_THRESHOLD` | 2 | 900s (15 min) |
+
+## Continuation Queue
+
+Multi-page ingestion uses a continuation queue to spread load over time:
+
+- `INGESTION_CONTINUATION_QUEUE_ENABLED` (default: `1`)
+- Base delay: `INGESTION_CONTINUATION_BASE_DELAY_SECONDS` (default: 120s)
+- Max delay: `INGESTION_CONTINUATION_MAX_DELAY_SECONDS` (default: 3600s)
+- Max attempts: `INGESTION_CONTINUATION_MAX_ATTEMPTS` (default: 6)
+
+Each continuation item is re-enqueued with exponential backoff.
+
+## Identifier Resolution
+
+After publication extraction, the `gather_identifiers_for_publication` module resolves identifiers:
+
+1. **Local parsing** - Searches HTML parameters for DOI patterns and arXiv regex matches.
+2. **arXiv API** - Queries `export.arxiv.org/api/query` by title and author strings.
+3. **Crossref API** - Queries Crossref REST API by title and author strings.
+
+Identifiers are stored in the `publication_identifiers` table rather than as hardcoded properties, maximizing matching resilience for the PDF resolution stage.
+
+## PDF Resolution
+
+Publications with resolved DOIs enter the PDF resolution pipeline:
+
+1. **Unpaywall** - Queries the Unpaywall API for open-access PDF URLs.
+2. **PDF Discovery** - If Unpaywall returns an OA page URL without a direct PDF link, the service fetches the HTML and searches for PDF link candidates.
+3. **arXiv Direct** - If an arXiv ID is known, the PDF URL is derived directly.
+
+Auto-retry is configured via `PDF_AUTO_RETRY_*` variables.
 
 ## arXiv Request Controls
-- **Global throttle state**: arXiv calls share `arxiv_runtime_state` so all workers respect one cooldown/interval clock.
-- **Query cache**: identical request parameters map to a stable fingerprint and are stored in `arxiv_query_cache_entries`.
-- **In-flight coalescing**: duplicate concurrent misses join one outbound request instead of fan-out.
-- **Caller load-shedding**: arXiv lookups are skipped when high-confidence DOI/arXiv evidence already exists, or when title quality is below threshold.
 
-## arXiv Observability Events
-- `arxiv.request_scheduled`: emitted before a gated request; includes `wait_seconds`, `cooldown_remaining_seconds`, `source_path`.
-- `arxiv.request_completed`: emitted after response; includes `status_code`, `wait_seconds`, `cooldown_remaining_seconds`, `source_path`.
-- `arxiv.cooldown_activated`: emitted when status `429` triggers cooldown.
-- `arxiv.cache_hit` / `arxiv.cache_miss`: emitted on query cache lookup with `source_path`.
+- **Global throttle**: arXiv calls share `arxiv_runtime_state` so all workers respect one cooldown/interval clock.
+- **Query cache**: Identical request parameters are fingerprinted and cached in `arxiv_query_cache_entries`.
+- **In-flight coalescing**: Duplicate concurrent misses join one outbound request.
+- **Load shedding**: arXiv lookups are skipped when high-confidence DOI/arXiv evidence already exists, or when title quality is below threshold.
+
+### Observability Events
+
+| Event | Description |
+|-------|-------------|
+| `arxiv.request_scheduled` | Emitted before a gated request. Includes `wait_seconds`, `cooldown_remaining_seconds`, `source_path`. |
+| `arxiv.request_completed` | Emitted after response. Includes `status_code`, `wait_seconds`, `source_path`. |
+| `arxiv.cooldown_activated` | Emitted when status `429` triggers cooldown. |
+| `arxiv.cache_hit` / `arxiv.cache_miss` | Emitted on query cache lookup with `source_path`. |
diff --git a/docs/developer/local-development.md b/docs/developer/local-development.md
index af89f3f..2adfab0 100644
--- a/docs/developer/local-development.md
+++ b/docs/developer/local-development.md
@@ -1,52 +1,100 @@
-# Developer Local Development
+---
+title: Local Development
+sidebar_position: 3
+---
 
-## Start the Dev Stack
+# Local Development
+
+## Prerequisites
+
+- Docker and Docker Compose v2+
+- Python 3.12+ (for IDE support and local linting)
+- Node.js 20+ (for frontend development)
+
+## Starting the Dev Stack
+
+The development compose file overlays the production config with hot-reload and a separate Vite dev server:
 
 ```bash
-docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d --build
+docker compose -f docker-compose.yml -f docker-compose.dev.yml up --build
 ```
 
-Open:
-- API: `http://localhost:8000`
-- Frontend dev server: `http://localhost:5173`
+This starts three services:
 
-Stop:
+| Service | Port | Description |
+|---------|------|-------------|
+| `db` | 5432 (internal) | PostgreSQL 15 |
+| `app` | 8000 | FastAPI backend with `APP_RELOAD=1` |
+| `frontend` | 5173 | Vite dev server proxying API calls to `app:8000` |
+
+### Dev-Specific Overrides
+
+The `docker-compose.dev.yml` file applies these changes:
+
+- **`app`**: Uses `scholarr-dev:local` image built from the `dev` stage. Mounts the project root as `/app` for hot reload. Disables `SESSION_COOKIE_SECURE` and the built frontend.
+- **`frontend`**: Node 20 container running `npm install && npm run dev`. Mounts `./frontend` with a named volume for `node_modules`. Uses polling for file watching (`CHOKIDAR_USEPOLLING=1`).
+
+## Environment Setup
 
 ```bash
-docker compose -f docker-compose.yml -f docker-compose.dev.yml down
+cp .env.example .env
 ```
 
-## Backend Validation
+Set at minimum:
 
 ```bash
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app uv run pytest tests/unit
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app uv run pytest -m integration
+POSTGRES_PASSWORD=localdev
+SESSION_SECRET_KEY=local-dev-secret-at-least-32-characters
+SESSION_COOKIE_SECURE=0
 ```
 
-## Frontend Validation
+## Running Tests
+
+All tests run inside containers:
 
 ```bash
-cd frontend
-npm install
-npm run typecheck
-npm run test:run
-npm run build
+# Run unit tests (default: excludes integration markers)
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python -m pytest
+
+# Run integration tests
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python -m pytest -m integration
+
+# Run a specific test file
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python -m pytest tests/unit/test_fingerprints.py -v
 ```
 
-## Repository Gates
+See [Testing](testing.md) for markers, fixtures, and conventions.
+
+## Linting and Type Checking
 
 ```bash
-python3 scripts/check_frontend_api_contract.py
-python3 scripts/check_env_contract.py
-./scripts/check_no_generated_artifacts.sh
+# Ruff linting
+ruff check .
+
+# Ruff formatting check
+ruff format --check .
+
+# Mypy type checking
+mypy app/
 ```
 
-## Docs Site (Contributor Workflow)
+Ruff config is in `pyproject.toml`: target Python 3.12, line length 120, rules `E F W I UP B SIM RUF`.
 
-Docs tooling is colocated in `docs/website/`:
+## Database Migrations
+
+Alembic migrations run automatically on startup when `MIGRATE_ON_START=1`. To run manually:
 
 ```bash
-cd docs/website
-npm install
-npm run build
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  alembic upgrade head
+```
+
+To create a new migration:
+
+```bash
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  alembic revision --autogenerate -m "description of change"
 ```
diff --git a/docs/developer/overview.md b/docs/developer/overview.md
index 7ab91cc..9974236 100644
--- a/docs/developer/overview.md
+++ b/docs/developer/overview.md
@@ -1,11 +1,65 @@
-# Developer Documentation
+---
+title: Developer Overview
+sidebar_position: 1
+---
 
-Use this section if you are contributing code or running full quality gates.
+# Developer Overview
 
-- [Documentation Standards](./documentation-standards.md)
-- [Local Development](./local-development.md)
-- [Architecture Boundaries](./architecture.md)
-- [Ingestion API & Backoff Strategies](./ingestion.md)
-- [API Contracts](./api-contract.md)
-- [Contributing](./contributing.md)
-- [Frontend Theme Inventory](./frontend-theme-inventory.md)
+Scholarr is a Python 3.12+ FastAPI backend with an async SQLAlchemy ORM layer, PostgreSQL database, and a Vue 3 + TypeScript + Vite frontend.
+
+## Stack
+
+| Layer | Technology |
+|-------|------------|
+| Backend | Python 3.12+, FastAPI, SQLAlchemy 2.0 (async/asyncpg), Alembic |
+| Frontend | TypeScript, Vue 3, Vite, Tailwind CSS |
+| Database | PostgreSQL 15 |
+| Infrastructure | Multi-stage Docker, Docker Compose |
+| Linting | ruff (E, F, W, I, UP, B, SIM, RUF), mypy |
+| Testing | pytest, pytest-asyncio |
+| Versioning | python-semantic-release, conventional commits |
+
+## Quick Start
+
+```bash
+# Build the dev image and start services
+docker compose -f docker-compose.yml -f docker-compose.dev.yml up --build
+
+# Backend: http://localhost:8000 (hot reload enabled)
+# Frontend: http://localhost:5173 (Vite dev server with API proxy)
+```
+
+See [Local Development](local-development.md) for the full setup guide.
+
+## Project Layout
+
+```
+app/
+├── api/routers/          # FastAPI route handlers
+├── auth/                 # Session + CSRF middleware
+├── db/                   # SQLAlchemy models, session factory, migrations
+├── services/             # Domain service modules (see Architecture)
+│   ├── arxiv/            # arXiv API client, cache, rate limiting
+│   ├── crossref/         # Crossref DOI lookups
+│   ├── dbops/            # Database integrity + repair operations
+│   ├── ingestion/        # Run orchestration, scheduler, safety gates
+│   ├── openalex/         # OpenAlex metadata matching
+│   ├── portability/      # Import/export workflows
+│   ├── publication_identifiers/  # Multi-identifier resolution
+│   ├── publications/     # Listing, enrichment, dedup, PDF queue
+│   ├── runs/             # Run history, continuation queue
+│   ├── scholar/          # HTML parser, source fetch adapters
+│   ├── scholars/         # Scholar CRUD, image upload, name search
+│   └── unpaywall/        # Unpaywall PDF discovery
+├── main.py               # App factory, lifespan, middleware stack
+frontend/
+├── src/
+│   ├── components/       # Reusable Vue components
+│   ├── theme/presets/    # Color theme presets (light + dark)
+│   └── ...
+scripts/db/               # Operational database scripts
+tests/
+├── unit/                 # Fast, no-database tests
+├── integration/          # Tests requiring database + services
+└── fixtures/             # Shared test fixtures
+```
diff --git a/docs/developer/testing.md b/docs/developer/testing.md
new file mode 100644
index 0000000..6440a3d
--- /dev/null
+++ b/docs/developer/testing.md
@@ -0,0 +1,102 @@
+---
+title: Testing
+sidebar_position: 7
+---
+
+# Testing
+
+## Running Tests
+
+All tests must run inside containers:
+
+```bash
+# Unit tests (default: excludes integration markers)
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python -m pytest
+
+# Integration tests
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python -m pytest -m integration
+
+# Specific marker
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python -m pytest -m db
+
+# Verbose output for a specific file
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python -m pytest tests/unit/test_fingerprints.py -v
+```
+
+## Test Configuration
+
+From `pyproject.toml`:
+
+```toml
+[tool.pytest.ini_options]
+addopts = "-q -m \"not integration\" --import-mode=importlib"
+asyncio_mode = "auto"
+testpaths = ["tests"]
+```
+
+- Default run excludes `integration` marked tests
+- Uses `importlib` import mode to resolve module name collisions
+- Async tests run automatically (no `@pytest.mark.asyncio` needed)
+
+## Markers
+
+| Marker | Description |
+|--------|-------------|
+| `integration` | Tests requiring external services (database, network) |
+| `db` | Tests that validate database behavior and constraints |
+| `migrations` | Tests focused on Alembic schema migration correctness |
+| `schema` | Tests focused on multi-tenant schema invariants |
+| `smoke` | Smoke tests for containerized runtime |
+
+## Test Tiers
+
+### Unit Tests (`tests/unit/`)
+
+Fast, no-database tests. Mock external dependencies. These run by default.
+
+Examples:
+- `test_fingerprints.py` - Publication fingerprinting logic
+- `test_scholar_parser.py` - HTML parsing without network calls
+- `test_doi_normalize.py` - DOI normalization rules
+- `test_ingestion_arxiv_rate_limit.py` - Rate limiter behavior
+- `test_publication_pdf_resolution_pipeline.py` - PDF pipeline logic
+
+Domain-specific unit tests are organized under `tests/unit/services/domains/`:
+- `arxiv/` - Cache, client, gateway, guards, parser, rate limit tests
+- `openalex/` - Client and matching tests
+- `publications/` - Dedup tests
+
+### Integration Tests (`tests/integration/`)
+
+Require a running database. Test full request/response flows and data consistency.
+
+Examples:
+- `test_api_v1.py` - API endpoint integration tests
+- `test_db_integrity.py` - Database integrity checks
+- `test_run_lifecycle_consistency.py` - Run state machine transitions
+- `test_deferred_enrichment.py` - Enrichment pipeline with real data
+- `test_fixture_probe_runs.py` - Fixture-based run probes
+
+### Smoke Tests
+
+Marked with `@pytest.mark.smoke`. Validate the containerized runtime starts and serves basic requests.
+
+## Fixtures
+
+Test fixtures live in `tests/fixtures/`:
+
+```
+tests/fixtures/
+└── scholar/
+    ├── profile_ok_amIMrIEAAAAJ.html          # Successful profile HTML
+    └── regression/
+        ├── profile_P1RwlvoAAAAJ.html         # Regression case
+        ├── profile_LZ5D_p4AAAAJ.html         # Regression case
+        └── profile_AAAAAAAAAAAA.html         # Regression case
+```
+
+Scholar HTML fixtures are real Google Scholar profile pages used to test parser robustness against DOM structure changes.
diff --git a/docs/index.md b/docs/index.md
index 4a6574c..94b563b 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,33 +1,27 @@
 ---
-slug: /
+title: Scholarr Documentation
+sidebar_position: 1
 ---
 
-# scholarr Documentation
+# Scholarr
 
-This documentation is organized for both users and developers.
+Scholarr is a self-hosted academic publication tracker. It monitors Google Scholar profiles, discovers new publications, resolves open-access PDFs, and presents everything through a clean Vue 3 dashboard.
 
-## For Users
+## Quick Links
 
-- [User Overview](./user/overview.md)
-- [Getting Started](./user/getting-started.md)
+| Section | Description |
+|---------|-------------|
+| [User Guide](user/overview.md) | What scholarr does, installation, configuration |
+| [Developer Guide](developer/overview.md) | Architecture, local development, contributing |
+| [Operations](operations/overview.md) | Deployment, database runbook, scrape safety |
+| [Reference](reference/overview.md) | API contract, environment variables, changelog |
 
-## For Operators
+## Key Features
 
-- [Operations Overview](./operations/overview.md)
-- [Scrape Safety Runbook](./operations/scrape-safety-runbook.md)
-- [Database Runbook](./operations/database-runbook.md)
-- [Migration Rollout Checklist](./operations/migration-checklist.md)
-
-## For Developers
-
-- [Developer Overview](./developer/overview.md)
-- [Local Development](./developer/local-development.md)
-- [Architecture Boundaries](./developer/architecture.md)
-- [Contributing](./developer/contributing.md)
-- [Frontend Theme Inventory](./developer/frontend-theme-inventory.md)
-
-## Reference
-
-- [Reference Overview](./reference/overview.md)
-- [API Contract](./reference/api-contract.md)
-- [Environment Reference](./reference/environment.md)
+- **Scholar Tracking** - Add Google Scholar profiles by ID, URL, or name search
+- **Automated Ingestion** - Background scheduler fetches new publications on a configurable interval
+- **Identifier Resolution** - Cross-references arXiv, Crossref, and OpenAlex for DOIs and metadata
+- **PDF Discovery** - Resolves open-access PDFs via Unpaywall and arXiv
+- **Import/Export** - Portable scholar data with full publication state
+- **Multi-User** - Session-based auth with admin user management
+- **Theming** - Multiple color presets with light/dark mode support
diff --git a/docs/operations/arxiv-runbook.md b/docs/operations/arxiv-runbook.md
index b3183be..b49da90 100644
--- a/docs/operations/arxiv-runbook.md
+++ b/docs/operations/arxiv-runbook.md
@@ -1,46 +1,80 @@
+---
+title: arXiv Runbook
+sidebar_position: 5
+---
+
 # arXiv Operations Runbook
 
 Use this runbook when arXiv lookups are slow, rate-limited, or behaving unexpectedly.
 
-## Signals To Check
-- logs for `arxiv.request_scheduled`, `arxiv.request_completed`, `arxiv.cooldown_activated`, `arxiv.cache_hit`, `arxiv.cache_miss`
+## Signals to Check
+
+- Logs for `arxiv.request_scheduled`, `arxiv.request_completed`, `arxiv.cooldown_activated`, `arxiv.cache_hit`, `arxiv.cache_miss`
 - `arxiv_runtime_state` row for cooldown and next-allowed timestamps
 - `arxiv_query_cache_entries` size and expiry churn
 
 ## Event Field Guide
-- `wait_seconds`: enforced pre-request delay from the global limiter.
-- `status_code`: upstream response code from arXiv.
-- `cooldown_remaining_seconds`: remaining cooldown when blocked or after 429.
-- `source_path`: caller path (`search` or `lookup_ids`).
+
+| Field | Description |
+|-------|-------------|
+| `wait_seconds` | Enforced pre-request delay from the global limiter |
+| `status_code` | Upstream response code from arXiv |
+| `cooldown_remaining_seconds` | Remaining cooldown when blocked or after 429 |
+| `source_path` | Caller path (`search` or `lookup_ids`) |
 
 ## Quick SQL Checks
+
+### Runtime State
+
 ```sql
 SELECT state_key, next_allowed_at, cooldown_until, updated_at
 FROM arxiv_runtime_state;
 ```
 
+### Cache Status
+
 ```sql
-SELECT count(*) AS cache_rows, min(expires_at) AS earliest_expiry, max(expires_at) AS latest_expiry
+SELECT count(*) AS cache_rows,
+       min(expires_at) AS earliest_expiry,
+       max(expires_at) AS latest_expiry
 FROM arxiv_query_cache_entries;
 ```
 
 ## Common Scenarios
-1. Repeated `arxiv.cooldown_activated` events:
-- Confirm recent `429` statuses in `arxiv.request_completed`.
-- Reduce caller pressure (check new title-quality/identifier guards are active).
+
+### 1. Repeated `arxiv.cooldown_activated` Events
+
+- Confirm recent `429` statuses in `arxiv.request_completed` logs.
+- Reduce caller pressure (check title-quality/identifier guards are active).
 - Temporarily raise `ARXIV_RATE_LIMIT_COOLDOWN_SECONDS` if upstream remains strict.
 
-2. High request latency with few completions:
+### 2. High Request Latency with Few Completions
+
 - Inspect `wait_seconds` in `arxiv.request_scheduled`.
 - Verify only one process path is repeatedly hitting arXiv (`source_path`).
 - Confirm cache is enabled (`ARXIV_CACHE_TTL_SECONDS > 0`) and effective (`cache_hit` appears).
 
-3. Low cache effectiveness:
+### 3. Low Cache Effectiveness
+
 - Validate normalized query behavior and caller churn.
 - Increase `ARXIV_CACHE_TTL_SECONDS` for stable workloads.
 - Increase `ARXIV_CACHE_MAX_ENTRIES` if heavy eviction is observed.
 
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `ARXIV_ENABLED` | `1` | Enable arXiv lookups |
+| `ARXIV_TIMEOUT_SECONDS` | `3.0` | Request timeout |
+| `ARXIV_MIN_INTERVAL_SECONDS` | `4.0` | Min interval between requests |
+| `ARXIV_RATE_LIMIT_COOLDOWN_SECONDS` | `60.0` | Cooldown after 429 |
+| `ARXIV_DEFAULT_MAX_RESULTS` | `3` | Max results per query |
+| `ARXIV_CACHE_TTL_SECONDS` | `900` | Cache TTL (15 min) |
+| `ARXIV_CACHE_MAX_ENTRIES` | `512` | Max cached queries |
+| `ARXIV_MAILTO` | *(empty)* | Contact email for API headers |
+
 ## Safe Recovery
+
 1. Pause automated ingestion if rate-limit storms persist.
 2. Let cooldown expire naturally; avoid manual burst retries.
 3. Resume and monitor event rates before restoring full load.
diff --git a/docs/operations/database-runbook.md b/docs/operations/database-runbook.md
index abe320d..434bc51 100644
--- a/docs/operations/database-runbook.md
+++ b/docs/operations/database-runbook.md
@@ -1,100 +1,195 @@
-# Database Operations Runbook
+---
+title: Database Runbook
+sidebar_position: 3
+---
 
-This runbook defines backup, restore, and verification procedures for the
-PostgreSQL database used by `scholarr`.
+# Database Runbook
 
-## Objectives
+## Backup
 
-- Keep data loss bounded via scheduled backups.
-- Provide repeatable restore procedures.
-- Verify backups by running regular restore drills.
+Use `scripts/db/backup_full.sh` to create logical backups from the running `db` compose service.
 
-Recommended starting targets:
-
-- `RPO`: 24 hours (maximum acceptable data loss).
-- `RTO`: 60 minutes (maximum acceptable restore time).
-
-## Backup Strategy
-
-Use logical backups from the running `db` compose service.
-
-- Custom-format backup (recommended for restore flexibility):
+### Custom-Format Backup (Default)
 
 ```bash
 scripts/db/backup_full.sh
 ```
 
-- Plain SQL backup:
+Creates a `.dump` file in `./backups/` (e.g., `scholarr_20260227T120000Z.dump`).
+
+### Plain SQL Backup
 
 ```bash
 scripts/db/backup_full.sh --plain
 ```
 
-Optional environment variables:
+Creates a `.sql` file.
 
-- `BACKUP_DIR`: destination directory (default: `<repo>/backups`)
-- `BACKUP_PREFIX`: backup filename prefix (default: `scholarr`)
-- `USE_DEV_COMPOSE=1`: include `docker-compose.dev.yml`
+### Options
 
-## Restore Strategy
+| Option | Description |
+|--------|-------------|
+| `--plain` | Write plain SQL instead of custom-format dump |
 
-Restore from a `.dump` (custom format) or `.sql` file into the running `db`
-compose service.
+### Environment Variables
 
-- Restore without schema wipe:
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `BACKUP_DIR` | `<repo>/backups` | Destination directory |
+| `BACKUP_PREFIX` | `scholarr` | File prefix |
+| `USE_DEV_COMPOSE` | `0` | Set to `1` to include `docker-compose.dev.yml` |
+
+## Restore
+
+Use `scripts/db/restore_dump.sh` to restore a backup into the running `db` service.
+
+### Restore a Custom-Format Dump
 
 ```bash
-scripts/db/restore_dump.sh --file backups/scholarr_20260220T120000Z.dump
+scripts/db/restore_dump.sh --file backups/scholarr_20260227T120000Z.dump
 ```
 
-- Restore with full `public` schema reset:
+### Restore with Schema Wipe
 
 ```bash
-scripts/db/restore_dump.sh --file backups/scholarr_20260220T120000Z.dump --wipe-public
+scripts/db/restore_dump.sh --file backups/scholarr_20260227T120000Z.dump --wipe-public
 ```
 
-## Safety Checklist Before Restore
+This drops and recreates the `public` schema before restoring. Use with caution.
 
-1. Pause writes (stop app/scheduler or set maintenance mode).
-2. Create a fresh pre-restore backup.
-3. Validate target dump checksum/size.
-4. Confirm operator, scope, and rollback plan.
+### Options
 
-## Post-Restore Verification
+| Option | Description |
+|--------|-------------|
+| `--file <path>` | Required. Path to `.dump` or `.sql` backup file |
+| `--wipe-public` | Drop and recreate `public` schema before restore |
 
-1. Run migrations head check.
-2. Run health endpoint checks.
-3. Verify table row counts for core tables:
-   - `users`
-   - `scholar_profiles`
-   - `publications`
-   - `scholar_publications`
-   - `crawl_runs`
-4. Run integrity report and require zero failures:
+## Integrity Checks
+
+Use `scripts/db/check_integrity.py` to run database integrity checks.
+
+### Run Inside Container
 
 ```bash
-python3 scripts/db/check_integrity.py
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python scripts/db/check_integrity.py
 ```
 
-5. Run API smoke checks for scholars/publications/runs pages.
-
-## Data Cleanup and Repair
-
-Use the audited repair job for scholar-publication relinking cleanup:
+### With Strict Warnings
 
 ```bash
-python3 scripts/db/repair_publication_links.py --user-id <id> --requested-by "<operator>" --apply
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python scripts/db/check_integrity.py --strict-warnings
 ```
 
-Dry-run first, then re-run with `--apply` once scope and summary counts match expectation.
+Returns non-zero exit code if any warning is present.
 
-If cleanup changes schema assumptions, follow `docs/operations/migration-checklist.md` before any migration rollout.
+### Output Format
 
-## Restore Drill Cadence
+JSON report:
 
-- Run at least one full restore drill per month.
-- Record:
-  - backup artifact used,
-  - restore start/end timestamps,
-  - issues encountered,
-  - achieved `RTO`.
+```json
+{
+  "status": "passed",
+  "failures": [],
+  "warnings": []
+}
+```
+
+Exit codes:
+- `0` - All checks passed
+- `1` - Check failure
+- `2` - Warnings present (with `--strict-warnings`)
+
+### Via Admin API
+
+```
+GET /api/v1/admin/db/integrity
+```
+
+Returns the same integrity report through the API (admin auth required).
+
+## Publication Link Repair
+
+Use `scripts/db/repair_publication_links.py` to repair scholar-publication links with audit logging.
+
+### Dry Run (Default)
+
+```bash
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python scripts/db/repair_publication_links.py --user-id 1
+```
+
+### Apply Changes
+
+```bash
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python scripts/db/repair_publication_links.py --user-id 1 --apply \
+  --requested-by "admin@example.com"
+```
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `--user-id <int>` | Required. Target user ID |
+| `--scholar-profile-id <int>` | Optional. Filter by scholar profile ID (repeatable) |
+| `--apply` | Apply changes (default is dry-run) |
+| `--gc-orphan-publications` | Delete publications with zero links after cleanup |
+| `--requested-by <string>` | Operator identifier for audit logs |
+
+### Via Admin API
+
+```
+POST /api/v1/admin/db/repairs/publication-links
+```
+
+## Near-Duplicate Repair
+
+Detect and merge near-duplicate publications via the admin API:
+
+```
+POST /api/v1/admin/db/repairs/publication-near-duplicates
+```
+
+## PDF Queue Management
+
+### List Queue
+
+```
+GET /api/v1/admin/db/pdf-queue
+```
+
+### Requeue Single Item
+
+```
+POST /api/v1/admin/db/pdf-queue/{id}/requeue
+```
+
+### Bulk Requeue
+
+```
+POST /api/v1/admin/db/pdf-queue/requeue-all
+```
+
+## Migration Procedures
+
+Alembic migrations run automatically on startup when `MIGRATE_ON_START=1`.
+
+To run manually:
+
+```bash
+docker compose exec app alembic upgrade head
+```
+
+To check current migration status:
+
+```bash
+docker compose exec app alembic current
+```
+
+Recommended procedure for production:
+1. Backup the database before upgrading.
+2. Pull the new image.
+3. Start the container; migrations run on startup.
+4. Verify via `GET /healthz` and check logs for migration output.
diff --git a/docs/operations/deployment.md b/docs/operations/deployment.md
new file mode 100644
index 0000000..48e06d4
--- /dev/null
+++ b/docs/operations/deployment.md
@@ -0,0 +1,117 @@
+---
+title: Deployment
+sidebar_position: 2
+---
+
+# Deployment
+
+## Production Docker Compose
+
+The default `docker-compose.yml` runs two services:
+
+| Service | Image | Description |
+|---------|-------|-------------|
+| `db` | `postgres:15-alpine` | PostgreSQL database with persistent volume |
+| `app` | `justinzeus/scholarr:latest` | FastAPI application with embedded frontend |
+
+### Start
+
+```bash
+docker compose up -d
+```
+
+### Stop
+
+```bash
+docker compose down
+```
+
+### Update
+
+```bash
+docker compose pull
+docker compose up -d
+```
+
+### View Logs
+
+```bash
+docker compose logs -f app
+docker compose logs -f db
+```
+
+## Required Environment Variables
+
+These must be set in `.env` or the shell environment:
+
+```bash
+POSTGRES_PASSWORD=<secure-password>
+SESSION_SECRET_KEY=<random-string-32-chars-minimum>
+```
+
+## Volumes
+
+| Volume | Mount | Description |
+|--------|-------|-------------|
+| `postgres_data` | `/var/lib/postgresql/data` | Database files |
+| `scholar_uploads` | `/var/lib/scholarr/uploads` | Scholar profile images |
+
+## Health Checks
+
+### Database
+
+```yaml
+healthcheck:
+  test: ["CMD-SHELL", "pg_isready -U $POSTGRES_USER -d $POSTGRES_DB"]
+  interval: 5s
+  timeout: 5s
+  retries: 20
+```
+
+### Application
+
+```yaml
+healthcheck:
+  test: ["CMD-SHELL", "curl -fsS http://localhost:8000/healthz >/dev/null || exit 1"]
+  interval: 10s
+  timeout: 5s
+  retries: 12
+```
+
+The app service depends on `db` with `condition: service_healthy`, so it waits for the database to be ready.
+
+## Database Readiness Wait
+
+The app has built-in database readiness polling:
+
+- `DB_WAIT_TIMEOUT_SECONDS` (default: 60) - Max wait time
+- `DB_WAIT_INTERVAL_SECONDS` (default: 2) - Poll interval
+
+## Auto-Migration
+
+Set `MIGRATE_ON_START=1` (default) to run Alembic migrations automatically on startup.
+
+## Scaling Considerations
+
+- Run a single `app` instance to avoid scheduler conflicts (the scheduler is process-local).
+- arXiv requests are globally serialized via a PostgreSQL advisory lock, so multiple instances safely share the rate limiter.
+- Database pool defaults: 5 base connections + 10 overflow. Adjust `DATABASE_POOL_SIZE` and `DATABASE_POOL_MAX_OVERFLOW` for higher loads.
+
+## Admin Bootstrap
+
+For first-time setup without manual database access:
+
+```bash
+BOOTSTRAP_ADMIN_ON_START=1
+BOOTSTRAP_ADMIN_EMAIL=admin@example.com
+BOOTSTRAP_ADMIN_PASSWORD=<secure-password>
+```
+
+Set `BOOTSTRAP_ADMIN_FORCE_PASSWORD=1` to reset an existing admin password.
+
+## Security Hardening
+
+- Set `SESSION_COOKIE_SECURE=1` when serving over HTTPS.
+- Enable HSTS: `SECURITY_STRICT_TRANSPORT_SECURITY_ENABLED=1`.
+- Review CSP policy in `SECURITY_CSP_POLICY` for your domain.
+- Set `UNPAYWALL_EMAIL` and `ARXIV_MAILTO` for polite API pool access.
diff --git a/docs/operations/migration-checklist.md b/docs/operations/migration-checklist.md
deleted file mode 100644
index 106b9fc..0000000
--- a/docs/operations/migration-checklist.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Migration Checklist
-
-Use this checklist for every schema/data migration.
-
-## 1. Design Review
-
-- Define change type: `expand`, `backfill`, `contract`.
-- Document expected lock behavior and index impact.
-- Confirm backward compatibility with currently deployed app version.
-- Define rollback strategy before implementation.
-
-## 2. Pre-Migration Controls
-
-- Capture a fresh backup before applying migration.
-- Confirm migration head revision and working tree cleanliness.
-- Prepare validation queries for new/changed tables and indexes.
-- Identify high-risk tables (large row count, hot write paths).
-
-## 3. Implementation Standards
-
-- Keep migrations idempotent when feasible.
-- Prefer additive steps first (`nullable`, new index, new table).
-- For destructive changes, separate into later contract migration.
-- Avoid large blocking rewrites in a single deployment step.
-
-## 4. Verification
-
-- Apply migration in staging against production-like snapshot.
-- Verify:
-  - expected tables/columns/indexes,
-  - app startup and health endpoint,
-  - affected API flows,
-  - data consistency queries.
-
-## 5. Rollout and Recovery
-
-- Apply migration during planned window.
-- Monitor logs/errors and DB metrics during rollout.
-- If rollback needed:
-  - follow downgrade/recovery runbook,
-  - restore from backup if downgrade is unsafe,
-  - document incident timeline.
-
-## 6. Post-Migration Tasks
-
-- Update `README.md` / `.env.example` / ops docs.
-- Add/update integration tests for new schema assumptions.
-- Record migration notes in changelog.
diff --git a/docs/operations/overview.md b/docs/operations/overview.md
index f208a7d..7d2f997 100644
--- a/docs/operations/overview.md
+++ b/docs/operations/overview.md
@@ -1,8 +1,30 @@
-# Operations Documentation
+---
+title: Operations Overview
+sidebar_position: 1
+---
 
-Use this section for production operations and incident/runbook workflows.
+# Operations Overview
 
-- [Scrape Safety Runbook](./scrape-safety-runbook.md)
-- [arXiv Runbook](./arxiv-runbook.md)
-- [Database Runbook](./database-runbook.md)
-- [Migration Rollout Checklist](./migration-checklist.md)
+This section covers production deployment, database administration, and scrape safety operations.
+
+## Quick Links
+
+| Guide | Description |
+|-------|-------------|
+| [Deployment](deployment.md) | Production Docker setup, scaling, health checks |
+| [Database Runbook](database-runbook.md) | Backup, restore, integrity checks, repair procedures |
+| [Scrape Safety Runbook](scrape-safety-runbook.md) | Rate limiting, cooldowns, CAPTCHA handling |
+| [arXiv Runbook](arxiv-runbook.md) | arXiv rate limits, cache tuning, query patterns |
+
+## Health Check
+
+The app exposes `GET /healthz` for container orchestration:
+
+```bash
+curl -fsS http://localhost:8000/healthz
+```
+
+Docker Compose healthcheck config:
+- Interval: 10s
+- Timeout: 5s
+- Retries: 12
diff --git a/docs/operations/scrape-safety-runbook.md b/docs/operations/scrape-safety-runbook.md
index db01064..71f6769 100644
--- a/docs/operations/scrape-safety-runbook.md
+++ b/docs/operations/scrape-safety-runbook.md
@@ -1,74 +1,76 @@
+---
+title: Scrape Safety Runbook
+sidebar_position: 4
+---
+
 # Scrape Safety Runbook
 
-This runbook covers operational handling for scrape safety cooldowns, threshold alerts, and blocked-IP events.
+Operational handling for scrape safety cooldowns, threshold alerts, and blocked-IP events.
 
 ## Key Signals
 
 Use structured log `event` fields (recommended with `LOG_FORMAT=json`):
 
-- `ingestion.safety_policy_blocked_run_start`
-- `ingestion.safety_cooldown_entered`
-- `ingestion.safety_cooldown_cleared`
-- `ingestion.alert_blocked_failure_threshold_exceeded`
-- `ingestion.alert_network_failure_threshold_exceeded`
-- `ingestion.alert_retry_scheduled_threshold_exceeded`
-- `api.runs.manual_blocked_policy`
-- `api.runs.manual_blocked_safety`
-- `scheduler.run_skipped_safety_cooldown`
-- `scheduler.run_skipped_safety_cooldown_precheck`
-- `scheduler.queue_item_deferred_safety_cooldown`
+| Event | Description |
+|-------|-------------|
+| `ingestion.safety_policy_blocked_run_start` | Run blocked by safety policy |
+| `ingestion.safety_cooldown_entered` | Cooldown activated |
+| `ingestion.safety_cooldown_cleared` | Cooldown expired |
+| `ingestion.alert_blocked_failure_threshold_exceeded` | Blocked failure threshold tripped |
+| `ingestion.alert_network_failure_threshold_exceeded` | Network failure threshold tripped |
+| `ingestion.alert_retry_scheduled_threshold_exceeded` | Retry threshold tripped |
+| `api.runs.manual_blocked_policy` | Manual run blocked by policy |
+| `api.runs.manual_blocked_safety` | Manual run blocked by safety cooldown |
+| `scheduler.run_skipped_safety_cooldown` | Scheduled run skipped due to cooldown |
+| `scheduler.run_skipped_safety_cooldown_precheck` | Scheduler precheck blocked |
+| `scheduler.queue_item_deferred_safety_cooldown` | Queue item deferred due to cooldown |
 
-Each event includes metric-style fields (`metric_name`, `metric_value`) for straightforward log-based alert rules.
+Each event includes metric-style fields (`metric_name`, `metric_value`) for log-based alert rules.
 
 ## Recommended Alert Rules
 
-- Cooldown enters:
-  - Trigger on `event=ingestion.safety_cooldown_entered`.
-- Repeated start blocks:
-  - Trigger on high rate of `event=api.runs.manual_blocked_safety`.
-- Threshold trips:
-  - Trigger on any of:
-    - `ingestion.alert_blocked_failure_threshold_exceeded`
-    - `ingestion.alert_network_failure_threshold_exceeded`
-    - `ingestion.alert_retry_scheduled_threshold_exceeded`
-- Scheduler pressure:
-  - Trigger on sustained `scheduler.queue_item_deferred_safety_cooldown`.
+- **Cooldown enters**: Trigger on `event=ingestion.safety_cooldown_entered`
+- **Repeated start blocks**: High rate of `event=api.runs.manual_blocked_safety`
+- **Threshold trips**: Any of the `*_threshold_exceeded` events
+- **Scheduler pressure**: Sustained `scheduler.queue_item_deferred_safety_cooldown`
 
 ## If Your IP Appears Blocked
 
-Symptoms:
+### Symptoms
 
-- cooldown reason `blocked_failure_threshold_exceeded`
-- parse state `blocked_or_captcha`
-- redirects toward Google account sign-in flows
+- Cooldown reason: `blocked_failure_threshold_exceeded`
+- Parse state: `blocked_or_captcha`
+- Redirects toward Google account sign-in flows
 
-Actions:
+### Actions
 
 1. Stop manual retries immediately.
 2. Let cooldown expire; do not spam retriggers.
 3. Increase `INGESTION_MIN_REQUEST_DELAY_SECONDS` and user request delay values.
 4. Reduce concurrency pressure (keep one scheduler instance).
-5. Keep name-search disabled/WIP for now if login-gated responses persist.
+5. Keep name-search disabled if login-gated responses persist.
 6. Resume with a small monitored run and verify blocked rate drops.
 
-Avoid:
+### Avoid
 
-- aggressive rapid retries
-- rotating through risky scraping patterns that increase challenge rates
-- bypass/captcha-solving workflows that may violate source platform rules
+- Aggressive rapid retries
+- Rotating through risky scraping patterns that increase challenge rates
+- Bypass/CAPTCHA-solving workflows that may violate source platform rules
 
 ## Environment Controls
 
 Policy floors and safety controls:
 
-- `INGESTION_MIN_REQUEST_DELAY_SECONDS`
-- `INGESTION_MIN_RUN_INTERVAL_MINUTES`
-- `INGESTION_ALERT_BLOCKED_FAILURE_THRESHOLD`
-- `INGESTION_ALERT_NETWORK_FAILURE_THRESHOLD`
-- `INGESTION_ALERT_RETRY_SCHEDULED_THRESHOLD`
-- `INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS`
-- `INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS`
-- `INGESTION_MANUAL_RUN_ALLOWED`
-- `INGESTION_AUTOMATION_ALLOWED`
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `INGESTION_MIN_REQUEST_DELAY_SECONDS` | `2` | Floor delay between requests |
+| `INGESTION_MIN_RUN_INTERVAL_MINUTES` | `15` | Minimum time between runs |
+| `INGESTION_ALERT_BLOCKED_FAILURE_THRESHOLD` | `1` | Blocked failures before alert |
+| `INGESTION_ALERT_NETWORK_FAILURE_THRESHOLD` | `2` | Network failures before alert |
+| `INGESTION_ALERT_RETRY_SCHEDULED_THRESHOLD` | `3` | Retries before alert |
+| `INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS` | `1800` | Cooldown after blocked threshold (30 min) |
+| `INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS` | `900` | Cooldown after network threshold (15 min) |
+| `INGESTION_MANUAL_RUN_ALLOWED` | `1` | Enable manual runs |
+| `INGESTION_AUTOMATION_ALLOWED` | `1` | Enable automated runs |
 
 Apply stricter values first, then relax slowly only after sustained healthy runs.
diff --git a/docs/reference/api-contract.md b/docs/reference/api-contract.md
deleted file mode 100644
index 8b72186..0000000
--- a/docs/reference/api-contract.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# API Contract
-
-## Envelope Invariant
-
-All API responses under `/api/v1` use one of these envelopes:
-
-- Success: `{"data": ..., "meta": {"request_id": "..."}}`
-- Error: `{"error": {"code": "...", "message": "...", "details": ...}, "meta": {"request_id": "..."}}`
-
-`meta.request_id` must be present for success and error responses.
-
-Binary media assets are served outside `/api/v1` (for example, `GET /scholar-images/{scholar_profile_id}/upload`).
-
-## Publications Semantics
-
-- `GET /api/v1/publications` supports `mode=all|unread|latest`.
-- `mode=new` is currently accepted as a compatibility alias for `latest`.
-- Pagination controls: `page`, `page_size` (with backward-compatible `limit`/`offset` support).
-- Pagination fields in response: `page`, `page_size`, `has_prev`, `has_next`, `total_count`.
-- `unread` represents read-state (`is_read=false`).
-- `latest` represents discovery-state (`first seen in the latest completed run`).
-
-Publication payloads expose:
-- `pub_url` (canonical scholar detail URL)
-- `doi` (normalized DOI)
-- `pdf_url` (resolved OA PDF when available)
-
-## Scholar Portability
-
-- `GET /api/v1/scholars/export` exports tracked scholars and scholar-publication link state.
-- `POST /api/v1/scholars/import` imports that payload while preserving global publication deduplication.
diff --git a/docs/reference/api.md b/docs/reference/api.md
new file mode 100644
index 0000000..668ab51
--- /dev/null
+++ b/docs/reference/api.md
@@ -0,0 +1,177 @@
+---
+title: API Contract
+sidebar_position: 2
+---
+
+# API Contract
+
+## Envelope Invariant
+
+All API responses under `/api/v1` use one of these envelopes:
+
+### Success
+
+```json
+{
+  "data": "...",
+  "meta": {
+    "request_id": "..."
+  }
+}
+```
+
+### Error
+
+```json
+{
+  "error": {
+    "code": "...",
+    "message": "...",
+    "details": "..."
+  },
+  "meta": {
+    "request_id": "..."
+  }
+}
+```
+
+`meta.request_id` is present on both success and error responses.
+
+### Binary Assets
+
+Binary media assets are served outside `/api/v1`:
+
+```
+GET /scholar-images/{scholar_profile_id}/upload
+```
+
+## DTO Structure
+
+Scholarr uses strictly typed Pydantic V2 models serialized through OpenAPI v3 via FastAPI.
+
+- `PublicationListItem` exposes a `.display_identifier` property that resolves the highest-confidence identifier regardless of backend origin, rather than a hardcoded `.doi`.
+- Frontend TypeScript types are compiled from the OpenAPI spec to ensure type safety across the stack.
+
+## Endpoints
+
+### Auth
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `POST` | `/api/v1/auth/login` | Login (rate-limited sliding window) |
+| `GET` | `/api/v1/auth/me` | Current session user |
+| `GET` | `/api/v1/auth/csrf` | Bootstrap CSRF token |
+| `POST` | `/api/v1/auth/change-password` | Change password |
+| `POST` | `/api/v1/auth/logout` | Logout |
+
+### Scholars
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/api/v1/scholars` | List tracked scholars |
+| `POST` | `/api/v1/scholars` | Create scholar (auto-enqueue, metadata hydration) |
+| `GET` | `/api/v1/scholars/search` | Search author candidates by name |
+| `PATCH` | `/api/v1/scholars/{id}/toggle` | Toggle enabled status |
+| `DELETE` | `/api/v1/scholars/{id}` | Delete scholar |
+| `PUT` | `/api/v1/scholars/{id}/image/url` | Update image URL |
+| `POST` | `/api/v1/scholars/{id}/image/upload` | Upload image |
+| `DELETE` | `/api/v1/scholars/{id}/image` | Clear image customization |
+
+### Scholar Portability
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/api/v1/scholars/export` | Export tracked scholars and publication link state |
+| `POST` | `/api/v1/scholars/import` | Import scholars with global publication deduplication |
+
+The export payload includes scholar metadata, tracked publication data, and link state (read/unread, favorites). Import preserves global deduplication.
+
+### Publications
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/api/v1/publications` | List publications (filtered, paginated) |
+| `POST` | `/api/v1/publications/mark-all-read` | Mark all as read |
+| `POST` | `/api/v1/publications/mark-read` | Mark selected as read |
+| `POST` | `/api/v1/publications/{id}/retry-pdf` | Retry PDF resolution |
+| `POST` | `/api/v1/publications/{id}/favorite` | Toggle favorite |
+
+#### Publication Modes
+
+`GET /api/v1/publications` supports a `mode` parameter:
+
+| Mode | Description |
+|------|-------------|
+| `all` | All publications |
+| `unread` | Publications with `is_read=false` |
+| `latest` | Publications first seen in the latest completed run |
+
+`mode=new` is accepted as a compatibility alias for `latest`.
+
+#### Pagination
+
+Query parameters: `page`, `page_size` (with backward-compatible `limit`/`offset` support).
+
+Response pagination fields:
+
+```json
+{
+  "page": 1,
+  "page_size": 20,
+  "has_prev": false,
+  "has_next": true,
+  "total_count": 142
+}
+```
+
+#### Publication Payload Fields
+
+| Field | Description |
+|-------|-------------|
+| `pub_url` | Canonical scholar detail URL |
+| `doi` | Normalized DOI |
+| `pdf_url` | Resolved open-access PDF URL (when available) |
+| `display_identifier` | Highest-confidence identifier regardless of source |
+
+### Runs
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/api/v1/runs` | List runs with safety state |
+| `GET` | `/api/v1/runs/{run_id}` | Run detail with scholar results |
+| `POST` | `/api/v1/runs/{run_id}/cancel` | Cancel active run |
+| `POST` | `/api/v1/runs/manual` | Trigger manual run (idempotent, safety-checked) |
+| `GET` | `/api/v1/runs/queue/items` | List queue items |
+| `POST` | `/api/v1/runs/queue/{id}/retry` | Retry queue item |
+| `POST` | `/api/v1/runs/queue/{id}/drop` | Drop queue item |
+| `DELETE` | `/api/v1/runs/queue/{id}` | Clear queue item |
+| `GET` | `/api/v1/runs/{run_id}/stream` | Stream run events (SSE) |
+
+### Settings
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/api/v1/settings` | Get user settings (with cooldown expiry check) |
+| `PUT` | `/api/v1/settings` | Update settings (interval, delay, nav, API keys) |
+
+### Admin - User Management
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/api/v1/admin/users` | List all users |
+| `POST` | `/api/v1/admin/users` | Create user |
+| `PATCH` | `/api/v1/admin/users/{id}/active` | Set user active status |
+| `POST` | `/api/v1/admin/users/{id}/reset-password` | Reset password |
+
+### Admin - Database Operations
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/api/v1/admin/db/integrity` | Get integrity report |
+| `GET` | `/api/v1/admin/db/repair-jobs` | List repair jobs |
+| `GET` | `/api/v1/admin/db/pdf-queue` | List PDF queue |
+| `POST` | `/api/v1/admin/db/pdf-queue/{id}/requeue` | Requeue single PDF |
+| `POST` | `/api/v1/admin/db/pdf-queue/requeue-all` | Bulk requeue missing PDFs |
+| `POST` | `/api/v1/admin/db/repairs/publication-links` | Trigger link repair |
+| `POST` | `/api/v1/admin/db/repairs/publication-near-duplicates` | Trigger dedup repair |
+| `POST` | `/api/v1/admin/db/drop-all-publications` | Drop all publications (destructive) |
diff --git a/docs/reference/changelog.md b/docs/reference/changelog.md
new file mode 100644
index 0000000..23a7a11
--- /dev/null
+++ b/docs/reference/changelog.md
@@ -0,0 +1,12 @@
+---
+title: Changelog
+sidebar_position: 4
+---
+
+# Changelog
+
+This changelog is auto-generated by [python-semantic-release](https://python-semantic-release.readthedocs.io/).
+
+Release versions follow [Semantic Versioning](https://semver.org/). Commit messages follow [Conventional Commits](https://www.conventionalcommits.org/).
+
+<!-- semantic-release will insert entries here -->
diff --git a/docs/reference/environment.md b/docs/reference/environment.md
index 75cc192..fc7e29a 100644
--- a/docs/reference/environment.md
+++ b/docs/reference/environment.md
@@ -1,68 +1,32 @@
-# Environment Reference and Audit
+---
+title: Environment Variables
+sidebar_position: 3
+---
 
-This document is the source-of-truth audit for what remains configurable versus internal defaults.
+# Environment Variables Quick Reference
 
-## Decision Summary
+All environment variables are documented in detail in [Configuration](../user/configuration.md).
 
-- Keep in `.env.example`: all runtime and compose controls currently exposed by `app/settings.py` plus compose/bootstrap extras.
-- Move to internal defaults only: none at this time.
-- Internal fallback behavior still exists in code to keep local/test startup resilient when values are omitted.
+## Required Variables
 
-## Configurable Variables (By Section)
+| Variable | Description |
+|----------|-------------|
+| `POSTGRES_PASSWORD` | PostgreSQL password |
+| `SESSION_SECRET_KEY` | Session cookie signing key (32+ characters) |
 
-### Compose + Database
+## Categories
 
-`POSTGRES_DB`, `POSTGRES_USER`, `POSTGRES_PASSWORD`, `DATABASE_URL`, `TEST_DATABASE_URL`, `SCHOLARR_IMAGE`
+| Category | Key Variables |
+|----------|--------------|
+| Database | `POSTGRES_DB`, `POSTGRES_USER`, `DATABASE_URL`, `DATABASE_POOL_*` |
+| Runtime | `APP_HOST`, `APP_PORT`, `MIGRATE_ON_START`, `FRONTEND_ENABLED` |
+| Auth | `SESSION_SECRET_KEY`, `SESSION_COOKIE_SECURE`, `LOGIN_RATE_LIMIT_*` |
+| Security | `SECURITY_HEADERS_ENABLED`, `SECURITY_CSP_*`, `SECURITY_STRICT_TRANSPORT_*` |
+| Logging | `LOG_LEVEL`, `LOG_FORMAT`, `LOG_REQUESTS` |
+| Scheduler | `SCHEDULER_ENABLED`, `SCHEDULER_TICK_SECONDS`, `SCHEDULER_*_BATCH_SIZE` |
+| Ingestion | `INGESTION_*` (safety floors, cooldowns, retry policies) |
+| Scholar | `SCHOLAR_IMAGE_*`, `SCHOLAR_NAME_SEARCH_*` |
+| Enrichment | `UNPAYWALL_*`, `ARXIV_*`, `CROSSREF_*`, `OPENALEX_*`, `PDF_AUTO_RETRY_*` |
+| Bootstrap | `BOOTSTRAP_ADMIN_*`, `DB_WAIT_*` |
 
-### App Runtime + Networking
-
-`APP_NAME`, `APP_HOST`, `APP_PORT`, `APP_HOST_PORT`, `APP_RELOAD`, `MIGRATE_ON_START`, `FRONTEND_ENABLED`, `FRONTEND_DIST_DIR`
-
-### Database Pool
-
-`DATABASE_POOL_MODE`, `DATABASE_POOL_SIZE`, `DATABASE_POOL_MAX_OVERFLOW`, `DATABASE_POOL_TIMEOUT_SECONDS`
-
-### Frontend Dev Overrides
-
-`FRONTEND_HOST_PORT`, `CHOKIDAR_USEPOLLING`, `VITE_DEV_API_PROXY_TARGET`
-
-### Auth + Session
-
-`SESSION_SECRET_KEY`, `SESSION_COOKIE_SECURE`, `LOGIN_RATE_LIMIT_ATTEMPTS`, `LOGIN_RATE_LIMIT_WINDOW_SECONDS`
-
-### HTTP Security Headers + CSP
-
-`SECURITY_HEADERS_ENABLED`, `SECURITY_X_CONTENT_TYPE_OPTIONS`, `SECURITY_X_FRAME_OPTIONS`, `SECURITY_REFERRER_POLICY`, `SECURITY_PERMISSIONS_POLICY`, `SECURITY_CROSS_ORIGIN_OPENER_POLICY`, `SECURITY_CROSS_ORIGIN_RESOURCE_POLICY`, `SECURITY_CSP_ENABLED`, `SECURITY_CSP_POLICY`, `SECURITY_CSP_DOCS_POLICY`, `SECURITY_CSP_REPORT_ONLY`, `SECURITY_STRICT_TRANSPORT_SECURITY_ENABLED`, `SECURITY_STRICT_TRANSPORT_SECURITY_MAX_AGE`, `SECURITY_STRICT_TRANSPORT_SECURITY_INCLUDE_SUBDOMAINS`, `SECURITY_STRICT_TRANSPORT_SECURITY_PRELOAD`
-
-### Logging
-
-`LOG_LEVEL`, `LOG_FORMAT`, `LOG_REQUESTS`, `LOG_UVICORN_ACCESS`, `LOG_REQUEST_SKIP_PATHS`, `LOG_REDACT_FIELDS`
-
-### Scheduler + Ingestion Safety
-
-`SCHEDULER_ENABLED`, `SCHEDULER_TICK_SECONDS`, `SCHEDULER_QUEUE_BATCH_SIZE`, `SCHEDULER_PDF_QUEUE_BATCH_SIZE`, `INGESTION_AUTOMATION_ALLOWED`, `INGESTION_MANUAL_RUN_ALLOWED`, `INGESTION_MIN_RUN_INTERVAL_MINUTES`, `INGESTION_MIN_REQUEST_DELAY_SECONDS`, `INGESTION_NETWORK_ERROR_RETRIES`, `INGESTION_RETRY_BACKOFF_SECONDS`, `INGESTION_RATE_LIMIT_RETRIES`, `INGESTION_RATE_LIMIT_BACKOFF_SECONDS`, `INGESTION_MAX_PAGES_PER_SCHOLAR`, `INGESTION_PAGE_SIZE`, `INGESTION_ALERT_BLOCKED_FAILURE_THRESHOLD`, `INGESTION_ALERT_NETWORK_FAILURE_THRESHOLD`, `INGESTION_ALERT_RETRY_SCHEDULED_THRESHOLD`, `INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS`, `INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS`, `INGESTION_CONTINUATION_QUEUE_ENABLED`, `INGESTION_CONTINUATION_BASE_DELAY_SECONDS`, `INGESTION_CONTINUATION_MAX_DELAY_SECONDS`, `INGESTION_CONTINUATION_MAX_ATTEMPTS`
-
-### Scholar Images + Name Search Safety
-
-`SCHOLAR_IMAGE_UPLOAD_DIR`, `SCHOLAR_IMAGE_UPLOAD_MAX_BYTES`, `SCHOLAR_NAME_SEARCH_ENABLED`, `SCHOLAR_NAME_SEARCH_CACHE_TTL_SECONDS`, `SCHOLAR_NAME_SEARCH_BLOCKED_CACHE_TTL_SECONDS`, `SCHOLAR_NAME_SEARCH_CACHE_MAX_ENTRIES`, `SCHOLAR_NAME_SEARCH_MIN_INTERVAL_SECONDS`, `SCHOLAR_NAME_SEARCH_INTERVAL_JITTER_SECONDS`, `SCHOLAR_NAME_SEARCH_COOLDOWN_BLOCK_THRESHOLD`, `SCHOLAR_NAME_SEARCH_COOLDOWN_SECONDS`, `SCHOLAR_NAME_SEARCH_ALERT_RETRY_COUNT_THRESHOLD`, `SCHOLAR_NAME_SEARCH_ALERT_COOLDOWN_REJECTIONS_THRESHOLD`
-
-### OA Enrichment + PDF Resolution
-
-`UNPAYWALL_ENABLED`, `UNPAYWALL_EMAIL`, `UNPAYWALL_TIMEOUT_SECONDS`, `UNPAYWALL_MIN_INTERVAL_SECONDS`, `UNPAYWALL_MAX_ITEMS_PER_REQUEST`, `UNPAYWALL_RETRY_COOLDOWN_SECONDS`, `UNPAYWALL_PDF_DISCOVERY_ENABLED`, `UNPAYWALL_PDF_DISCOVERY_MAX_CANDIDATES`, `UNPAYWALL_PDF_DISCOVERY_MAX_HTML_BYTES`, `ARXIV_ENABLED`, `ARXIV_TIMEOUT_SECONDS`, `ARXIV_MIN_INTERVAL_SECONDS`, `ARXIV_RATE_LIMIT_COOLDOWN_SECONDS`, `ARXIV_DEFAULT_MAX_RESULTS`, `ARXIV_CACHE_TTL_SECONDS`, `ARXIV_CACHE_MAX_ENTRIES`, `ARXIV_MAILTO`, `PDF_AUTO_RETRY_INTERVAL_SECONDS`, `PDF_AUTO_RETRY_FIRST_INTERVAL_SECONDS`, `PDF_AUTO_RETRY_MAX_ATTEMPTS`, `CROSSREF_ENABLED`, `CROSSREF_MAX_ROWS`, `CROSSREF_TIMEOUT_SECONDS`, `CROSSREF_MIN_INTERVAL_SECONDS`, `CROSSREF_MAX_LOOKUPS_PER_REQUEST`, `OPENALEX_API_KEY`, `CROSSREF_API_TOKEN`, `CROSSREF_API_MAILTO`
-
-### Startup Bootstrap + DB Wait
-
-`BOOTSTRAP_ADMIN_ON_START`, `BOOTSTRAP_ADMIN_EMAIL`, `BOOTSTRAP_ADMIN_PASSWORD`, `BOOTSTRAP_ADMIN_FORCE_PASSWORD`, `DB_WAIT_TIMEOUT_SECONDS`, `DB_WAIT_INTERVAL_SECONDS`
-
-## Drift Guard
-
-CI enforces env parity with:
-
-```bash
-python3 scripts/check_env_contract.py
-```
-
-The check fails when:
-- `app/settings.py` references a variable missing from `.env.example`.
-- `.env.example` contains an unknown key (outside the approved compose/bootstrap extras).
-- `.env.example` contains duplicate keys.
+See [Configuration](../user/configuration.md) for the complete table with types, defaults, and descriptions.
diff --git a/docs/reference/overview.md b/docs/reference/overview.md
index 240683d..c8249d9 100644
--- a/docs/reference/overview.md
+++ b/docs/reference/overview.md
@@ -1,6 +1,14 @@
-# Reference Documentation
+---
+title: Reference
+sidebar_position: 1
+---
 
-Use this section for canonical contracts and configuration references.
+# Reference
 
-- [API Contract](./api-contract.md)
-- [Environment Reference](./environment.md)
+Quick-reference documentation for the scholarr API, environment variables, and release changelog.
+
+| Document | Description |
+|----------|-------------|
+| [API Contract](api.md) | Envelope spec, endpoints, DTO structure, publication semantics |
+| [Environment Variables](environment.md) | Quick-reference table linking to full configuration docs |
+| [Changelog](changelog.md) | Auto-generated release history |
diff --git a/docs/user/configuration.md b/docs/user/configuration.md
new file mode 100644
index 0000000..d79a1b7
--- /dev/null
+++ b/docs/user/configuration.md
@@ -0,0 +1,178 @@
+---
+title: Configuration
+sidebar_position: 3
+---
+
+# Configuration
+
+All configuration is done through environment variables. Copy `.env.example` to `.env` and adjust values as needed.
+
+## Compose & Database
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `POSTGRES_DB` | string | `scholar` | PostgreSQL database name |
+| `POSTGRES_USER` | string | `scholar` | PostgreSQL user |
+| `POSTGRES_PASSWORD` | string | **required** | PostgreSQL password |
+| `DATABASE_URL` | string | derived | SQLAlchemy async connection string |
+| `TEST_DATABASE_URL` | string | derived | Override for test database. If empty, tests derive `<db_name>_test` |
+| `SCHOLARR_IMAGE` | string | `justinzeus/scholarr:latest` | Docker image for the app service |
+
+## App Runtime & Networking
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `APP_NAME` | string | `scholarr` | Application name used in logs and headers |
+| `APP_HOST` | string | `0.0.0.0` | Bind address |
+| `APP_PORT` | int | `8000` | Internal port |
+| `APP_HOST_PORT` | int | `8000` | Host-mapped port |
+| `APP_RELOAD` | bool | `0` | Enable uvicorn auto-reload (dev only) |
+| `MIGRATE_ON_START` | bool | `1` | Run Alembic migrations on startup |
+| `FRONTEND_ENABLED` | bool | `1` | Serve the built Vue frontend |
+| `FRONTEND_DIST_DIR` | string | `/app/frontend/dist` | Path to compiled frontend assets |
+
+## Database Pool
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `DATABASE_POOL_MODE` | string | `auto` | Pool mode (`auto`, `fixed`, `null`) |
+| `DATABASE_POOL_SIZE` | int | `5` | Base pool size |
+| `DATABASE_POOL_MAX_OVERFLOW` | int | `10` | Maximum overflow connections |
+| `DATABASE_POOL_TIMEOUT_SECONDS` | int | `30` | Connection acquisition timeout |
+
+## Frontend Dev Overrides
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `FRONTEND_HOST_PORT` | int | `5173` | Host port for Vite dev server |
+| `CHOKIDAR_USEPOLLING` | bool | `1` | Enable polling for file watchers in containers |
+| `VITE_DEV_API_PROXY_TARGET` | string | `http://app:8000` | Backend URL for Vite proxy |
+
+## Auth & Session
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `SESSION_SECRET_KEY` | string | **required** | Signing key for session cookies (32+ chars) |
+| `SESSION_COOKIE_SECURE` | bool | `1` | Set `Secure` flag on session cookie (disable for local HTTP dev) |
+| `LOGIN_RATE_LIMIT_ATTEMPTS` | int | `5` | Max login attempts per window |
+| `LOGIN_RATE_LIMIT_WINDOW_SECONDS` | int | `60` | Sliding window for login rate limiting |
+
+## HTTP Security Headers & CSP
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `SECURITY_HEADERS_ENABLED` | bool | `1` | Enable security response headers |
+| `SECURITY_X_CONTENT_TYPE_OPTIONS` | string | `nosniff` | X-Content-Type-Options header value |
+| `SECURITY_X_FRAME_OPTIONS` | string | `DENY` | X-Frame-Options header value |
+| `SECURITY_REFERRER_POLICY` | string | `strict-origin-when-cross-origin` | Referrer-Policy header value |
+| `SECURITY_PERMISSIONS_POLICY` | string | *(restrictive)* | Permissions-Policy header value |
+| `SECURITY_CROSS_ORIGIN_OPENER_POLICY` | string | `same-origin` | Cross-Origin-Opener-Policy header |
+| `SECURITY_CROSS_ORIGIN_RESOURCE_POLICY` | string | `same-origin` | Cross-Origin-Resource-Policy header |
+| `SECURITY_CSP_ENABLED` | bool | `1` | Enable Content-Security-Policy header |
+| `SECURITY_CSP_POLICY` | string | *(restrictive)* | CSP for app routes |
+| `SECURITY_CSP_DOCS_POLICY` | string | *(docs-specific)* | CSP for documentation routes |
+| `SECURITY_CSP_REPORT_ONLY` | bool | `0` | Use report-only mode for CSP |
+| `SECURITY_STRICT_TRANSPORT_SECURITY_ENABLED` | bool | `0` | Enable HSTS header |
+| `SECURITY_STRICT_TRANSPORT_SECURITY_MAX_AGE` | int | `31536000` | HSTS max-age in seconds |
+| `SECURITY_STRICT_TRANSPORT_SECURITY_INCLUDE_SUBDOMAINS` | bool | `1` | HSTS includeSubDomains directive |
+| `SECURITY_STRICT_TRANSPORT_SECURITY_PRELOAD` | bool | `0` | HSTS preload directive |
+
+## Logging
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `LOG_LEVEL` | string | `INFO` | Root log level (`DEBUG`, `INFO`, `WARNING`, `ERROR`) |
+| `LOG_FORMAT` | string | `console` | Log format (`console` or `json`) |
+| `LOG_REQUESTS` | bool | `1` | Log HTTP requests |
+| `LOG_UVICORN_ACCESS` | bool | `0` | Enable uvicorn access log |
+| `LOG_REQUEST_SKIP_PATHS` | string | `/healthz` | Comma-separated paths to exclude from request logging |
+| `LOG_REDACT_FIELDS` | string | *(empty)* | Comma-separated field names to redact in logs |
+
+## Scheduler & Ingestion Safety
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `SCHEDULER_ENABLED` | bool | `1` | Enable the background scheduler |
+| `SCHEDULER_TICK_SECONDS` | int | `60` | Scheduler poll interval |
+| `SCHEDULER_QUEUE_BATCH_SIZE` | int | `10` | Max scholars processed per tick |
+| `SCHEDULER_PDF_QUEUE_BATCH_SIZE` | int | `15` | Max PDF resolutions per tick |
+| `INGESTION_AUTOMATION_ALLOWED` | bool | `1` | Allow automated (scheduled) runs |
+| `INGESTION_MANUAL_RUN_ALLOWED` | bool | `1` | Allow manually triggered runs |
+| `INGESTION_MIN_RUN_INTERVAL_MINUTES` | int | `15` | Minimum time between runs |
+| `INGESTION_MIN_REQUEST_DELAY_SECONDS` | int | `2` | Floor delay between external requests |
+| `INGESTION_NETWORK_ERROR_RETRIES` | int | `1` | Retries on network errors |
+| `INGESTION_RETRY_BACKOFF_SECONDS` | float | `1.0` | Base backoff for network retries |
+| `INGESTION_RATE_LIMIT_RETRIES` | int | `3` | Retries on 429 responses |
+| `INGESTION_RATE_LIMIT_BACKOFF_SECONDS` | float | `30.0` | Backoff per 429 retry |
+| `INGESTION_MAX_PAGES_PER_SCHOLAR` | int | `30` | Max paginated pages per scholar |
+| `INGESTION_PAGE_SIZE` | int | `100` | Publications per page |
+| `INGESTION_ALERT_BLOCKED_FAILURE_THRESHOLD` | int | `1` | Blocked failures before alert |
+| `INGESTION_ALERT_NETWORK_FAILURE_THRESHOLD` | int | `2` | Network failures before alert |
+| `INGESTION_ALERT_RETRY_SCHEDULED_THRESHOLD` | int | `3` | Scheduled retries before alert |
+| `INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS` | int | `1800` | Cooldown after blocked-failure threshold (30 min) |
+| `INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS` | int | `900` | Cooldown after network-failure threshold (15 min) |
+| `INGESTION_CONTINUATION_QUEUE_ENABLED` | bool | `1` | Enable continuation queue for multi-page ingestion |
+| `INGESTION_CONTINUATION_BASE_DELAY_SECONDS` | int | `120` | Base delay for continuation queue items |
+| `INGESTION_CONTINUATION_MAX_DELAY_SECONDS` | int | `3600` | Max delay for continuation queue items |
+| `INGESTION_CONTINUATION_MAX_ATTEMPTS` | int | `6` | Max continuation attempts per scholar |
+
+## Scholar Images & Name Search Safety
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `SCHOLAR_IMAGE_UPLOAD_DIR` | string | `/var/lib/scholarr/uploads` | Directory for uploaded scholar images |
+| `SCHOLAR_IMAGE_UPLOAD_MAX_BYTES` | int | `2000000` | Max image upload size (2 MB) |
+| `SCHOLAR_NAME_SEARCH_ENABLED` | bool | `1` | Enable name-based scholar search |
+| `SCHOLAR_NAME_SEARCH_CACHE_TTL_SECONDS` | int | `21600` | Cache TTL for successful searches (6 hours) |
+| `SCHOLAR_NAME_SEARCH_BLOCKED_CACHE_TTL_SECONDS` | int | `300` | Cache TTL for blocked search results (5 min) |
+| `SCHOLAR_NAME_SEARCH_CACHE_MAX_ENTRIES` | int | `512` | Max cache entries for name search |
+| `SCHOLAR_NAME_SEARCH_MIN_INTERVAL_SECONDS` | float | `8.0` | Min interval between name searches |
+| `SCHOLAR_NAME_SEARCH_INTERVAL_JITTER_SECONDS` | float | `2.0` | Random jitter added to search interval |
+| `SCHOLAR_NAME_SEARCH_COOLDOWN_BLOCK_THRESHOLD` | int | `1` | Blocked results before cooldown |
+| `SCHOLAR_NAME_SEARCH_COOLDOWN_SECONDS` | int | `1800` | Cooldown after blocked name search (30 min) |
+| `SCHOLAR_NAME_SEARCH_ALERT_RETRY_COUNT_THRESHOLD` | int | `2` | Retries before alert |
+| `SCHOLAR_NAME_SEARCH_ALERT_COOLDOWN_REJECTIONS_THRESHOLD` | int | `3` | Cooldown rejections before alert |
+
+## OA Enrichment & PDF Resolution
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `UNPAYWALL_ENABLED` | bool | `1` | Enable Unpaywall DOI lookups |
+| `UNPAYWALL_EMAIL` | string | *(empty)* | Polite pool email for Unpaywall API |
+| `UNPAYWALL_TIMEOUT_SECONDS` | float | `4.0` | Request timeout |
+| `UNPAYWALL_MIN_INTERVAL_SECONDS` | float | `0.6` | Min interval between Unpaywall requests |
+| `UNPAYWALL_MAX_ITEMS_PER_REQUEST` | int | `20` | Max items per batch |
+| `UNPAYWALL_RETRY_COOLDOWN_SECONDS` | int | `1800` | Cooldown after repeated failures |
+| `UNPAYWALL_PDF_DISCOVERY_ENABLED` | bool | `1` | Enable HTML-based PDF link discovery |
+| `UNPAYWALL_PDF_DISCOVERY_MAX_CANDIDATES` | int | `5` | Max candidate URLs to probe |
+| `UNPAYWALL_PDF_DISCOVERY_MAX_HTML_BYTES` | int | `500000` | Max HTML response size to parse |
+| `ARXIV_ENABLED` | bool | `1` | Enable arXiv API lookups |
+| `ARXIV_TIMEOUT_SECONDS` | float | `3.0` | Request timeout |
+| `ARXIV_MIN_INTERVAL_SECONDS` | float | `4.0` | Min interval between arXiv requests |
+| `ARXIV_RATE_LIMIT_COOLDOWN_SECONDS` | float | `60.0` | Cooldown after arXiv 429 |
+| `ARXIV_DEFAULT_MAX_RESULTS` | int | `3` | Default max results per query |
+| `ARXIV_CACHE_TTL_SECONDS` | int | `900` | Query cache TTL (15 min) |
+| `ARXIV_CACHE_MAX_ENTRIES` | int | `512` | Max cached queries |
+| `ARXIV_MAILTO` | string | *(empty)* | Contact email for arXiv API headers |
+| `PDF_AUTO_RETRY_INTERVAL_SECONDS` | int | `86400` | Auto-retry interval for failed PDFs (24 hours) |
+| `PDF_AUTO_RETRY_FIRST_INTERVAL_SECONDS` | int | `3600` | First retry interval (1 hour) |
+| `PDF_AUTO_RETRY_MAX_ATTEMPTS` | int | `3` | Max auto-retry attempts |
+| `CROSSREF_ENABLED` | bool | `1` | Enable Crossref lookups |
+| `CROSSREF_MAX_ROWS` | int | `10` | Max rows per Crossref query |
+| `CROSSREF_TIMEOUT_SECONDS` | float | `8.0` | Request timeout |
+| `CROSSREF_MIN_INTERVAL_SECONDS` | float | `0.6` | Min interval between Crossref requests |
+| `CROSSREF_MAX_LOOKUPS_PER_REQUEST` | int | `8` | Max lookups per ingestion request |
+| `OPENALEX_API_KEY` | string | *(empty)* | OpenAlex API key (optional) |
+| `CROSSREF_API_TOKEN` | string | *(empty)* | Crossref Plus API token (optional) |
+| `CROSSREF_API_MAILTO` | string | *(empty)* | Crossref polite pool email |
+
+## Startup Bootstrap & DB Wait
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `BOOTSTRAP_ADMIN_ON_START` | bool | `0` | Create admin user on startup |
+| `BOOTSTRAP_ADMIN_EMAIL` | string | *(empty)* | Admin email address |
+| `BOOTSTRAP_ADMIN_PASSWORD` | string | *(empty)* | Admin password |
+| `BOOTSTRAP_ADMIN_FORCE_PASSWORD` | bool | `0` | Overwrite existing admin password |
+| `DB_WAIT_TIMEOUT_SECONDS` | int | `60` | Max seconds to wait for database readiness |
+| `DB_WAIT_INTERVAL_SECONDS` | int | `2` | Poll interval while waiting for database |
diff --git a/docs/user/getting-started.md b/docs/user/getting-started.md
index bc15032..1090f86 100644
--- a/docs/user/getting-started.md
+++ b/docs/user/getting-started.md
@@ -1,41 +1,86 @@
-# User Getting Started
+---
+title: Getting Started
+sidebar_position: 2
+---
 
-## Required Setup
+# Getting Started
 
-1. Copy `.env.example` to `.env`.
-2. Set `POSTGRES_PASSWORD`.
-3. Set `SESSION_SECRET_KEY`.
+## Prerequisites
 
-## Deploy Method A: Prebuilt Image
+- Docker and Docker Compose v2+
+- A machine with at least 512 MB RAM
+
+## Installation
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/JustinZeus/scholarr.git
+cd scholarr
+```
+
+2. Copy the example environment file:
+
+```bash
+cp .env.example .env
+```
+
+3. Edit `.env` and set the required secrets:
+
+```bash
+# Required: database password
+POSTGRES_PASSWORD=your-secure-password
+
+# Required: session signing key (32+ random characters)
+SESSION_SECRET_KEY=your-random-secret-key
+```
+
+4. Start the stack:
+
+```bash
+docker compose up -d
+```
+
+5. Verify the service is healthy:
+
+```bash
+docker compose ps
+curl http://localhost:8000/healthz
+```
+
+The app is now available at `http://localhost:8000`.
+
+## First Run
+
+### Bootstrap an Admin User
+
+Set these environment variables before first start (or add them to `.env`):
+
+```bash
+BOOTSTRAP_ADMIN_ON_START=1
+BOOTSTRAP_ADMIN_EMAIL=admin@example.com
+BOOTSTRAP_ADMIN_PASSWORD=your-admin-password
+```
+
+Restart the app container. The admin account is created on startup.
+
+### Add Your First Scholar
+
+1. Log in at `http://localhost:8000`.
+2. Navigate to the Scholars page.
+3. Click **Add Scholar**.
+4. Enter a Google Scholar profile URL (e.g., `https://scholar.google.com/citations?user=XXXXXXXXXX`) or a Scholar ID.
+5. The scheduler will begin fetching publications on the next tick (default: 60 seconds).
+
+### Manual Run
+
+To trigger an immediate ingestion run, use the **Manual Run** button on the Runs page. This respects the minimum run interval (`INGESTION_MIN_RUN_INTERVAL_MINUTES`, default 15 minutes).
+
+## Updating
 
 ```bash
 docker compose pull
 docker compose up -d
 ```
 
-Open:
-- App/API: `http://localhost:8000`
-- Health endpoint: `http://localhost:8000/healthz`
-
-Upgrade:
-
-```bash
-docker compose pull
-docker compose up -d
-```
-
-## Deploy Method B: Local Source + Dev Frontend
-
-```bash
-docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d --build
-```
-
-Open:
-- API: `http://localhost:8000`
-- Frontend dev server: `http://localhost:5173`
-
-Stop:
-
-```bash
-docker compose -f docker-compose.yml -f docker-compose.dev.yml down
-```
+Database migrations run automatically on startup when `MIGRATE_ON_START=1` (the default).
diff --git a/docs/user/overview.md b/docs/user/overview.md
index 29ee003..50af970 100644
--- a/docs/user/overview.md
+++ b/docs/user/overview.md
@@ -1,5 +1,29 @@
-# User Documentation
+---
+title: Overview
+sidebar_position: 1
+---
 
-Use this section if you are deploying and using scholarr.
+# What is Scholarr?
 
-- [Getting Started](./getting-started.md)
+Scholarr is a self-hosted service that tracks academic publications from Google Scholar. It runs as a Docker container with a PostgreSQL database and serves a Vue 3 frontend.
+
+## Key Concepts
+
+- **Scholar** - A tracked Google Scholar profile. Scholars are user-scoped: each user manages their own list.
+- **Publication** - A globally deduplicated academic work. Publications are shared across all users to avoid duplicate storage.
+- **Scholar-Publication Link** - Connects a scholar to a publication for a specific user. Read/unread state, favorites, and visibility live on this link, not on the publication itself.
+- **Run** - A single ingestion cycle that fetches new publications for one or more scholars.
+- **Identifier** - A DOI, arXiv ID, PMID, or other external key attached to a publication. Multiple identifiers can exist per publication.
+
+## How It Works
+
+1. You add a Google Scholar profile (by ID, URL, or name search).
+2. The scheduler periodically scrapes the profile for new publications.
+3. Each publication is fingerprinted and deduplicated against the global store.
+4. External APIs (arXiv, Crossref, OpenAlex) are queried for identifiers.
+5. Unpaywall and arXiv resolve open-access PDF URLs when a DOI is available.
+6. The dashboard shows new, unread, and all publications with filtering and search.
+
+## Safety Model
+
+Scholarr enforces rate limits and cooldowns to prevent IP bans from upstream sources. These are not configurable to zero; they are safety floors. See [Scrape Safety Runbook](../operations/scrape-safety-runbook.md) for details.
diff --git a/docs/website/docusaurus.config.js b/docs/website/docusaurus.config.js
index f32aeaa..6156ad9 100644
--- a/docs/website/docusaurus.config.js
+++ b/docs/website/docusaurus.config.js
@@ -2,8 +2,8 @@
 
 /** @type {import('@docusaurus/types').Config} */
 const config = {
-  title: "scholarr",
-  tagline: "Self-hosted scholar tracking docs",
+  title: "Scholarr",
+  tagline: "Self-hosted academic publication tracker",
   favicon: "img/favicon.ico",
 
   url: "https://justinzeus.github.io",
@@ -23,59 +23,52 @@ const config = {
   presets: [
     [
       "classic",
-      {
+      /** @type {import('@docusaurus/preset-classic').Options} */
+      ({
         docs: {
           path: "..",
-          exclude: ["website/**", "README.md"],
           routeBasePath: "/",
           sidebarPath: require.resolve("./sidebars.js"),
-          editUrl: "https://github.com/JustinZeus/scholarr/tree/main/",
+          exclude: ["website/**", "README.md"],
         },
         blog: false,
         theme: {
           customCss: require.resolve("./src/css/custom.css"),
         },
-      },
+      }),
     ],
   ],
 
-  themeConfig: {
-    navbar: {
-      title: "scholarr",
-      items: [
-        {
-          type: "docSidebar",
-          sidebarId: "docsSidebar",
-          position: "left",
-          label: "Docs",
-        },
-        {
-          href: "https://github.com/JustinZeus/scholarr",
-          label: "GitHub",
-          position: "right",
-        },
-      ],
-    },
-    footer: {
-      style: "dark",
-      links: [
-        {
-          title: "Docs",
-          items: [{ label: "Index", to: "/" }],
-        },
-        {
-          title: "Community",
-          items: [
-            {
-              label: "GitHub",
-              href: "https://github.com/JustinZeus/scholarr",
-            },
-          ],
-        },
-      ],
-      copyright: `Copyright © ${new Date().getFullYear()} scholarr.`,
-    },
-  },
+  themeConfig:
+    /** @type {import('@docusaurus/preset-classic').ThemeConfig} */
+    ({
+      navbar: {
+        title: "Scholarr",
+        items: [
+          { to: "/user/overview", label: "User Guide", position: "left" },
+          {
+            to: "/developer/overview",
+            label: "Developer",
+            position: "left",
+          },
+          {
+            to: "/operations/overview",
+            label: "Operations",
+            position: "left",
+          },
+          { to: "/reference/overview", label: "Reference", position: "left" },
+          {
+            href: "https://github.com/JustinZeus/scholarr",
+            label: "GitHub",
+            position: "right",
+          },
+        ],
+      },
+      footer: {
+        style: "dark",
+        copyright: `Copyright \u00a9 ${new Date().getFullYear()} Scholarr. Built with Docusaurus.`,
+      },
+    }),
 };
 
 module.exports = config;
diff --git a/docs/website/package.json b/docs/website/package.json
index 383161f..85208b0 100644
--- a/docs/website/package.json
+++ b/docs/website/package.json
@@ -1,18 +1,27 @@
 {
   "name": "scholarr-docs",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "private": true,
   "scripts": {
+    "docusaurus": "docusaurus",
     "start": "docusaurus start",
     "build": "docusaurus build",
+    "swizzle": "docusaurus swizzle",
+    "deploy": "docusaurus deploy",
+    "clear": "docusaurus clear",
     "serve": "docusaurus serve"
   },
   "dependencies": {
-    "@docusaurus/core": "3.9.2",
-    "@docusaurus/preset-classic": "3.9.2",
-    "clsx": "^2.1.1",
-    "prism-react-renderer": "^2.3.1",
+    "@docusaurus/core": "^3.0.0",
+    "@docusaurus/preset-classic": "^3.0.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@docusaurus/module-type-aliases": "^3.0.0"
+  },
+  "browserslist": {
+    "production": [">0.5%", "not dead", "not op_mini all"],
+    "development": ["last 1 chrome version", "last 1 firefox version", "last 1 safari version"]
   }
 }
diff --git a/docs/website/sidebars.js b/docs/website/sidebars.js
index 3189871..2b97349 100644
--- a/docs/website/sidebars.js
+++ b/docs/website/sidebars.js
@@ -1,38 +1,49 @@
 /** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
 const sidebars = {
-  docsSidebar: [
+  docs: [
     "index",
     {
       type: "category",
-      label: "Users",
-      items: ["user/overview", "user/getting-started"],
+      label: "User Guide",
+      items: [
+        "user/overview",
+        "user/getting-started",
+        "user/configuration",
+      ],
+    },
+    {
+      type: "category",
+      label: "Developer",
+      items: [
+        "developer/overview",
+        "developer/architecture",
+        "developer/local-development",
+        "developer/contributing",
+        "developer/ingestion",
+        "developer/frontend-theme-inventory",
+        "developer/testing",
+      ],
     },
     {
       type: "category",
       label: "Operations",
       items: [
         "operations/overview",
-        "operations/scrape-safety-runbook",
+        "operations/deployment",
         "operations/database-runbook",
-        "operations/migration-checklist",
-      ],
-    },
-    {
-      type: "category",
-      label: "Developers",
-      items: [
-        "developer/overview",
-        "developer/documentation-standards",
-        "developer/local-development",
-        "developer/architecture",
-        "developer/contributing",
-        "developer/frontend-theme-inventory",
+        "operations/scrape-safety-runbook",
+        "operations/arxiv-runbook",
       ],
     },
     {
       type: "category",
       label: "Reference",
-      items: ["reference/overview", "reference/api-contract", "reference/environment"],
+      items: [
+        "reference/overview",
+        "reference/api",
+        "reference/environment",
+        "reference/changelog",
+      ],
     },
   ],
 };
diff --git a/docs/website/src/css/custom.css b/docs/website/src/css/custom.css
index 6f9b7ae..c875358 100644
--- a/docs/website/src/css/custom.css
+++ b/docs/website/src/css/custom.css
@@ -1,9 +1,22 @@
 :root {
-  --ifm-color-primary: #2a6b4e;
-  --ifm-color-primary-dark: #255f46;
-  --ifm-color-primary-darker: #225942;
-  --ifm-color-primary-darkest: #1c4936;
-  --ifm-color-primary-light: #2f7756;
-  --ifm-color-primary-lighter: #327d5a;
-  --ifm-color-primary-lightest: #3b946b;
+  --ifm-color-primary: #2e8555;
+  --ifm-color-primary-dark: #29784c;
+  --ifm-color-primary-darker: #277148;
+  --ifm-color-primary-darkest: #205d3b;
+  --ifm-color-primary-light: #33925d;
+  --ifm-color-primary-lighter: #359962;
+  --ifm-color-primary-lightest: #3cad6e;
+  --ifm-code-font-size: 95%;
+  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.1);
+}
+
+[data-theme="dark"] {
+  --ifm-color-primary: #25c2a0;
+  --ifm-color-primary-dark: #21af90;
+  --ifm-color-primary-darker: #1fa588;
+  --ifm-color-primary-darkest: #1a8870;
+  --ifm-color-primary-light: #29d5b0;
+  --ifm-color-primary-lighter: #32d8b4;
+  --ifm-color-primary-lightest: #4fddbf;
+  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.3);
 }
diff --git a/docs/website/static/img/favicon.ico b/docs/website/static/img/favicon.ico
deleted file mode 100644
index 783fa026032499189b063ed6629144ebb9c15192..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15086
zcmeI2*;m!q6~}K^^9SUm?>;nZ^)XL<?pkdjF==d@(K=zAP-GGTnZXH>2v(wTLP?E8
zNiB-TIBOJVtr+7hisFRPIHAn!?$5sb=;gvCmwVB!tp0v$?e#mqGw!p`KIiP;{%()w
z7oJ~wUVYW0?;)P(S3I8IdOV&XL%iSXG=G)mz5aUF_iG+c#IHP_-)J2z(iYx)eR(`u
z&;N-Z{ie9oQw9lRhKfHWM!gl3oM@Li>0Ox-{hp*u{Hqb^8PV@spFbsQ+UF#Ul9@?k
zB|Cnkz30xDD6^)2+{M#d{q~bI?j2c>6E8)12}+6bNp`F(oRuVhpFLfYK7L0Q7o=PN
zaiiYoHJ_;?{%GUW)n1UB*K6g*waaqt%6YkU<C<K*deL|(%1w~Wsl&y;J#%K9%JSuM
zyZ)LqK7A}r&l`<MlUKQRx%}g^0-Kj_d(v}KCdlru|0(r4=DoYO<o>-oa_`PfX;Av1
z;kKpg>n_W_ZIyyNeA^>azL6cgEzvn{-&ih}&ea%^CXX`e__y_46Ut&oMo8SqNSQwV
z&qkzUmHKPv+sDr-?SCE&^qX^Lh|=$rIG^m{;PHEYPBL+M?Rg%$@^Izx|Dprj4}mD&
zrwn@_AxN8GAhJuF{Jx}3`M~T3?$qQ7f9bx5rjH+H`Pda%v44~FDIfN_!v``}Uv*O_
zzAG6q9~lqamyR6+U!*fM5B{hFe|_~4P9Af@?#YfDVefQ!(Xp9trc!R=XtiHPOWw3G
zFJ%6+Q^w1@^vN<mGe+j7PL#Z)C>ygNV~XWrTb0aBQ9CM4?T|_Toqw0z5U=lW=08*I
zy!^CDQjj^t#%J6@wc+3i-sWe;$eh#(Qap2-+DzlkCc!RYJ=U%$3TWE}!xQ!)_9AnK
z;G-~Ws!@Jgw9HN(XX$zA(Prx{$c;CfGHz6)%4m$#Ui@APGA1iekpq?i_Elk4tkl<C
zkt-L@$oHp?%BiFK<+~Gy<mBOfa`eDXIkfj1Idk%`TsU)5>eMc!F0#R1V^8egS!FsB
zik(Iu$h4)US%Q72OPkmc5hjN(OBWg+!N}TM2U`={GQ!RrZ1m=)=fMsy&CN}+NOjRU
zuSyrqlIi1y1tojhu-A(9AE9#XGL!ScJzvX_{X0zl4Y%v%(Zl=ltnrCFf7WP3`q7W~
z<?gK;a{2ssa`@Zra&XU9YrFBw6|!~18q>doG5!B5Ir_SD^Ln%Ooe6h#cB<WfS88?r
zS!dS$c=c{MqT?_YI&k99UO9c@pj^@M`7fZ2^Za<f!TupKV|)Lf_^%1`=lo)StzTUt
z|331q_1DqS;dEzj`tRsyH}V~eLh9acxMO-+QTD0r8TzDe|M3ESd;cvWg!_cEZRNt5
z_K$PD_M-kfJ?p^>ALLQCciX?LE^QK{-ZmXVmjaCwOg`&k|33Pjp=WOKOw|qjpJNX~
zq|q1tWqs=g(|0I!yn7>3rj7lR5xj*v$58li+qm|xs{`TbfS)_yrGMh5P#38uN~zmV
z@oW9?d)##nZ=GHFx$<*$z|{d)2V5O+b->jDR|j664mf@w{M25#dwtmf*Py%Jn_WJn
z{;}nN{R~PB!5il1#h-z{7e5OA=5+Nnlg1C8(nXF>96tngQYXD<{$em>+QyF#&j%ao
zJn_$`P4@ckle@6v<OyKN!vtI&|Ef_}8hn|0)M1Y4F&|ppP{$9q9lT_z-yJ_Y{^Xqa
zQRZvM-;X~CIXh*{6Q3`B`i!X`8Mcn!p0)X($X|U{$Pior9fGgiE}X!4RvzJ*w9Qd*
z4EVRY$~SY(n-*m{7OoFJly$(L#`@1vA3L}Ud=UeJkJd}xH30j-56>JZCl&(VJU)4R
z_SB`XP<RNZ4Pz3cvSfaS`Q-5(mds5xJOJME6)T~9K~9{-Vh~5NXil;$TaYa)7UmhP
zE}3I>{Q2kG>-T$+^YZEsdf?TQ;f6n<_h4S=ii1J1PMkC7JGxJO+A%+L&|m-2E7rz)
zHochp06#Jq(dSF%nOv6_<w)7$e8Xv$7G_GhVng_rmlx&AXN4J-zxva;CV$qUOw${_
zSZaFI)5khg4(!@&H~@Y2EE~MJfLox?hU@9s!})`bBkSxq-Jcp0#X2Bw%8(`Hwg&pm
zoA#^$=c=R2_>3#cO61{#dxoF+>y}e5oHsH7hXEJ4dg-j<7JKFJzHKHqFplcoTP(eO
zQ@MOo`Gr)iUuC}Z{W~@(p0USpjk7h!6w|t3eU#*<njapX;Gfu~+KXrGt_z3HKyAUV
zmVT0D7)LL_K{LQTIy*bMaS$&a(i10f+EGSd^y%e4(qhlRbNbpFfp{87J~Cp=_O>>M
zjga5;;mbez!v3vVUpgRMCs_XJKW6yvg+1EdJ_!74AMhVD{14sOF#K;?w{md!?>dXo
zd2ku_9QwJUI9HxNc@(nToraB19!u$>*?LB0THoMe+<D-O!OApHJ?vv_M(!SB5y253
z{BYMWU+}cAK3^>C*P7$ia^vbHd7xM%{In>}+Sb}4ZEdYat(qo}GU618mppasfb6JR
zCl!h%?%BFQ%bT_D2B|q#ExWc<2zwn{_NTDXK)fS|@|DGUzMSh5BW90+%^EJNXAit=
z`KnCiwo=!=RH~FVmap)V$`W~k=W!No)A&fR^-E`K?40cM!$4V^Hr*Fs?qH>fW8V&8
zEr#0JzDm~?StGN)@J&Y#cz3k7+gynsef;o&fbT-g6I}x<Z`V5gJxxuDmul=PaiiE5
z#B&S;pY>f2uN|VXp}GgqBd~vD%h?T2{`hczd<81woCSA3clx+&u2^mNG<Tiv*uFf4
zn)deRjceuKgqV^w%L)x^zjL!rT3cEIvDhoWRpTIT*Vh?Fzh-Hn^~HV8838d?sC)+7
zj+hhf0oE29f607}0oMEW^7+&9^s$~xK5+u96M2-O`@}>$vBC5aO8iQ&d<Ij`SsVD^
ze+s*f*pg$_yNoyo$fL}OA9xuu4u*H%I?g_Gc;p*G#^{A_T{k^=wzMltSC+00xH{nK
VfU5(p4h&2O{KA3U&zCHL{{Sz;@yGxG

-- 
2.49.1


From c9b9d892f4b1fcdcd102af0451ca8b9fd43ad9e7 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 10:45:19 +0100
Subject: [PATCH 16/38] docs: rewrite README with project hook, feature table,
 and screenshot placeholders

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 README.md            | 171 +++++++++++++++++++++++++++----------------
 docs/assets/.gitkeep |   0
 2 files changed, 108 insertions(+), 63 deletions(-)
 create mode 100644 docs/assets/.gitkeep

diff --git a/README.md b/README.md
index c05beaa..f0f3fac 100644
--- a/README.md
+++ b/README.md
@@ -1,94 +1,139 @@
-# scholarr
-
 <div align="center">
 
-Self-hosted scholar tracking with a single app image (API + frontend). It automates publication discovery, parses Google Scholar, gathers external metadata via Crossref & arXiv APIs, and autonomously downloads Open Access PDFs.
+<img src="frontend/public/scholar_logo.png" alt="Scholarr" width="120" />
+
+# Scholarr
+
+**Self-hosted academic publication tracker.**
+
+Track Google Scholar profiles, discover new papers automatically,
+resolve open-access PDFs, and stay on top of the literature you care about.
 
 [![CI](https://img.shields.io/github/actions/workflow/status/justinzeus/scholarr/ci.yml?style=for-the-badge)](https://github.com/JustinZeus/scholarr/actions/workflows/ci.yml)
 [![Docker Pulls](https://img.shields.io/docker/pulls/justinzeus/scholarr?style=for-the-badge&logo=docker)](https://hub.docker.com/r/justinzeus/scholarr)
-[![Docker Image](https://img.shields.io/badge/docker-justinzeus%2Fscholarr-2496ED?style=for-the-badge&logo=docker&logoColor=white)](https://hub.docker.com/r/justinzeus/scholarr)
+[![Docs](https://img.shields.io/badge/docs-scholarr-2e8555?style=for-the-badge)](https://justinzeus.github.io/scholarr/)
 
 </div>
 
-## Key Features
-- **Automated Ingestion**: Background tasks regularly scrape author profiles to pull the latest publications.
-- **Resilient Parsing**: Custom DOM parsing logic falls back heavily across changes, backed by a dynamic `429 Too Many Requests` backoff cycle.
-- **Identifier Subsystem**: Isolates DOIs, PMIDs, and arXiv IDs independently of PDFs mapping fallback external APIs sequentially.
-- **Unpaywall PDF Search**: Leverages a fully automated resolution queue to grab public PDFs via the Unpaywall API on identified entries.
-- **Beautiful UI**: Polished Vue 3 frontend that ships natively inside the same Docker container as the FastAPI backend.
+---
 
-## Architecture Data Flow
-```mermaid
-graph LR
-    HTML(Google Scholar) --> |Scraper| Ingestion
-    Ingestion --> |Extract DOI| DB[(Database)]
-    Ingestion -.-> |Fallback API Search| Crossref/arXiv
-    Crossref/arXiv --> DB
-    
-    DB --> |Identified DOIs| PDFQueue(Unpaywall/PDF Workers)
-    PDFQueue --> |Download & Store File| Storage
-```
+<!-- TODO: Replace these placeholders with actual screenshots.
+     Drop PNG/JPEG files into docs/assets/ and update the paths below.
+
+     Recommended screenshots:
+       1. Dashboard / publications list (light or dark mode)
+       2. Scholar profile view
+       3. Run detail with progress
+
+     Ideal dimensions: 1200-1400px wide, PNG or WebP.
+-->
+
+<p align="center">
+  <img src="docs/assets/screenshot-dashboard.png" alt="Publications dashboard" width="720" />
+</p>
+
+<!--
+<p align="center">
+  <img src="docs/assets/screenshot-scholars.png" alt="Scholar profiles" width="360" />
+  <img src="docs/assets/screenshot-run.png" alt="Ingestion run" width="360" />
+</p>
+-->
+
+## Why Scholarr?
+
+Most researchers track new papers by manually checking Google Scholar, setting up email alerts, or juggling RSS feeds. Scholarr replaces all of that with a single self-hosted service:
+
+- **Add scholars once** -- by profile URL, Scholar ID, or name search
+- **Publications appear automatically** -- a background scheduler scrapes profiles on a configurable interval
+- **Open-access PDFs are resolved for you** -- Unpaywall and arXiv are queried automatically when a DOI is found
+- **Everything is deduplicated** -- publications are global records; no duplicates across scholars
+- **Your data stays yours** -- fully self-hosted, export/import your entire library at any time
+
+## Features
+
+| | |
+|---|---|
+| **Automated Ingestion** | Background scheduler with configurable intervals, continuation queue, and multi-page pagination |
+| **Identifier Resolution** | Cross-references arXiv, Crossref, and OpenAlex to gather DOIs, arXiv IDs, PMIDs |
+| **PDF Discovery** | Resolves open-access PDFs via Unpaywall API and arXiv, with automatic retry queue |
+| **Scrape Safety** | Rate limiting, cooldowns, and backoff strategies that prevent IP bans -- these are safety floors, not optional |
+| **Multi-User** | Session-based auth, admin user management, user-scoped scholar tracking |
+| **Theming** | 7 color presets with light/dark mode, tokenized component system |
+| **Import / Export** | Portable scholar data with full publication and read-state preservation |
+| **Single Container** | FastAPI backend + Vue 3 frontend ship as one Docker image |
 
 ## Quick Start
 
-1. Copy env template:
-
 ```bash
+# 1. Clone and configure
+git clone https://github.com/JustinZeus/scholarr.git
+cd scholarr
 cp .env.example .env
+
+# 2. Set required secrets in .env
+#    POSTGRES_PASSWORD=<secure-password>
+#    SESSION_SECRET_KEY=<random-32-char-string>
+
+# 3. Start
+docker compose up -d
+
+# 4. Open http://localhost:8000
 ```
 
-2. Set required values in `.env`:
-- `POSTGRES_PASSWORD`
-- `SESSION_SECRET_KEY`
-
-3. Start stack:
+To bootstrap an admin account on first run, add to `.env`:
 
 ```bash
-docker compose pull
-docker compose up -d
+BOOTSTRAP_ADMIN_ON_START=1
+BOOTSTRAP_ADMIN_EMAIL=admin@example.com
+BOOTSTRAP_ADMIN_PASSWORD=<secure-password>
 ```
 
-Open:
-- App/API: `http://localhost:8000`
-- Health: `http://localhost:8000/healthz`
+## How It Works
+
+```mermaid
+graph LR
+    Scholar[Google Scholar] -->|Scrape HTML| Parser[Parser & Fingerprinting]
+    Parser -->|Deduplicate| DB[(PostgreSQL)]
+    Parser -.->|Identify| APIs[arXiv / Crossref / OpenAlex]
+    APIs --> DB
+    DB -->|DOIs| PDF[PDF Resolution]
+    PDF -->|Unpaywall / arXiv| DB
+    DB --> UI[Vue 3 Dashboard]
+```
+
+## Tech Stack
+
+| Layer | Technology |
+|-------|------------|
+| Backend | Python 3.12, FastAPI, SQLAlchemy 2.0 (async), Alembic |
+| Frontend | TypeScript, Vue 3, Vite, Tailwind CSS |
+| Database | PostgreSQL 15 |
+| Infrastructure | Multi-stage Docker, Docker Compose |
 
 ## Documentation
 
-Complete documentation is published at:
-- https://justinzeus.github.io/scholarr/
+Full documentation: **[justinzeus.github.io/scholarr](https://justinzeus.github.io/scholarr/)**
 
-You can also read the developer/architecture breakdowns directly within the repository under:
-- `docs/developer/architecture.md`
-- `docs/developer/ingestion.md`
-- `docs/developer/api-contract.md`
+| Section | Covers |
+|---------|--------|
+| [User Guide](docs/user/overview.md) | Installation, configuration, all environment variables |
+| [Developer Guide](docs/developer/overview.md) | Architecture, local dev, contributing, testing |
+| [Operations](docs/operations/overview.md) | Deployment, database runbook, scrape safety |
+| [API Reference](docs/reference/api.md) | Envelope spec, all endpoints, DTO contracts |
 
-## Quality Gates
+## Contributing
 
-Backend:
+Scholarr uses [conventional commits](https://www.conventionalcommits.org/) and [semantic versioning](https://semver.org/). See the [contributing guide](docs/developer/contributing.md) for PR process and code standards.
 
 ```bash
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app uv run pytest tests/unit
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app uv run pytest -m integration
+# Dev environment
+docker compose -f docker-compose.yml -f docker-compose.dev.yml up --build
+
+# Run tests (always in containers)
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app \
+  python -m pytest
 ```
 
-Frontend:
+## License
 
-```bash
-# ALL tests/builds MUST be run within the docker container. Do not run raw npm commands on the host.
-# For automated agents checking outputs, redirect stdout/stderr to files (e.g. > /tmp/npm_typecheck.log 2>&1) 
-# The temp files /tmp/npm_test.log, /tmp/npm_lint.log, /tmp/npm_typecheck.log, and /tmp/pytest_eval.log are pre-authorized for overwrite.
-
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm install
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm run typecheck
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm run test:run
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm run build
-```
-
-Contract and env checks:
-
-```bash
-python3 scripts/check_frontend_api_contract.py
-python3 scripts/check_env_contract.py
-./scripts/check_no_generated_artifacts.sh
-```
-thanks arxiv
\ No newline at end of file
+See [LICENSE](LICENSE) for details.
diff --git a/docs/assets/.gitkeep b/docs/assets/.gitkeep
new file mode 100644
index 0000000..e69de29
-- 
2.49.1


From 92395b2b4bfcc4a908adb247e6c7ec2ba4f0a475 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 10:46:05 +0100
Subject: [PATCH 17/38] Initial release prep

---
 MODERNIZATION_PLAN.md                         | 78 +++++++++----------
 agents.md                                     |  2 +-
 app/api/media.py                              |  4 +-
 app/api/routers/admin.py                      |  2 +-
 app/api/routers/admin_dbops.py                |  4 +-
 app/api/routers/auth.py                       |  2 +-
 app/api/routers/publications.py               |  6 +-
 app/api/routers/runs.py                       | 10 +--
 app/api/routers/scholars.py                   | 12 +--
 app/api/routers/settings.py                   |  4 +-
 app/api/runtime_deps.py                       |  4 +-
 app/auth/runtime.py                           |  2 +-
 app/main.py                                   |  2 +-
 app/services/arxiv/application.py             |  4 +-
 app/services/arxiv/cache.py                   |  4 +-
 app/services/arxiv/client.py                  | 12 +--
 app/services/arxiv/gateway.py                 |  8 +-
 app/services/arxiv/guards.py                  |  8 +-
 app/services/arxiv/parser.py                  |  6 +-
 app/services/arxiv/rate_limit.py              |  4 +-
 app/services/crossref/__init__.py             |  2 +-
 app/services/dbops/__init__.py                |  8 +-
 app/services/dbops/near_duplicate_repair.py   |  2 +-
 app/services/ingestion/application.py         | 34 ++++----
 app/services/ingestion/constants.py           |  2 +-
 app/services/ingestion/fingerprints.py        |  4 +-
 app/services/ingestion/scheduler.py           | 10 +--
 app/services/ingestion/types.py               |  4 +-
 app/services/openalex/client.py               |  2 +-
 app/services/openalex/matching.py             |  2 +-
 app/services/portability/__init__.py          | 14 ++--
 app/services/portability/application.py       | 12 +--
 app/services/portability/exporting.py         |  2 +-
 app/services/portability/normalize.py         |  6 +-
 .../portability/publication_import.py         |  8 +-
 app/services/portability/scholar_import.py    |  4 +-
 .../publication_identifiers/__init__.py       |  2 +-
 .../publication_identifiers/application.py    | 18 ++---
 .../publication_identifiers/normalize.py      |  4 +-
 app/services/publications/__init__.py         | 56 ++++++-------
 app/services/publications/application.py      | 16 ++--
 app/services/publications/counts.py           |  4 +-
 app/services/publications/dedup.py            |  2 +-
 app/services/publications/enrichment.py       |  4 +-
 app/services/publications/listing.py          |  8 +-
 app/services/publications/pdf_queue.py        | 16 ++--
 .../publications/pdf_resolution_pipeline.py   | 16 ++--
 app/services/publications/queries.py          |  4 +-
 app/services/publications/types.py            |  2 +-
 app/services/runs/__init__.py                 | 34 ++++----
 app/services/runs/application.py              |  8 +-
 app/services/runs/queue_queries.py            |  2 +-
 app/services/runs/queue_service.py            |  6 +-
 app/services/scholar/author_rows.py           |  6 +-
 app/services/scholar/parser.py                | 20 ++---
 app/services/scholar/parser_utils.py          |  2 +-
 app/services/scholar/profile_rows.py          |  6 +-
 app/services/scholar/source.py                |  2 +-
 app/services/scholar/state_detection.py       |  6 +-
 app/services/scholars/application.py          | 16 ++--
 app/services/scholars/search_hints.py         |  4 +-
 app/services/scholars/uploads.py              |  2 +-
 app/services/scholars/validators.py           |  4 +-
 app/services/unpaywall/__init__.py            |  2 +-
 app/services/unpaywall/application.py         | 10 +--
 app/services/unpaywall/pdf_discovery.py       |  2 +-
 scripts/db/check_integrity.py                 |  2 +-
 scripts/db/repair_publication_links.py        |  2 +-
 tests/integration/test_api_v1.py              | 28 ++++---
 tests/integration/test_data_repair_jobs.py    |  2 +-
 tests/integration/test_db_integrity.py        |  2 +-
 tests/integration/test_deferred_enrichment.py |  8 +-
 tests/integration/test_fixture_probe_runs.py  |  4 +-
 .../test_run_lifecycle_consistency.py         |  6 +-
 .../unit/services/domains/arxiv/test_cache.py |  4 +-
 .../services/domains/arxiv/test_client.py     | 12 +--
 .../services/domains/arxiv/test_gateway.py    |  6 +-
 .../services/domains/arxiv/test_guards.py     |  6 +-
 .../services/domains/arxiv/test_parser.py     |  4 +-
 .../services/domains/arxiv/test_rate_limit.py | 10 +--
 .../services/domains/openalex/test_client.py  |  2 +-
 .../domains/openalex/test_matching.py         |  4 +-
 .../domains/publications/test_dedup.py        | 28 +++----
 tests/unit/test_crossref_lookup.py            |  2 +-
 tests/unit/test_doi_normalize.py              |  2 +-
 tests/unit/test_fingerprints.py               |  4 +-
 tests/unit/test_ingestion_arxiv_rate_limit.py |  6 +-
 .../unit/test_ingestion_progress_reporting.py |  4 +-
 tests/unit/test_publication_identifiers.py    | 28 +++----
 .../unit/test_publication_pdf_queue_policy.py |  6 +-
 ...est_publication_pdf_resolution_pipeline.py | 14 ++--
 tests/unit/test_request_delay_policy.py       |  4 +-
 tests/unit/test_run_safety.py                 |  2 +-
 tests/unit/test_runs_summary.py               |  2 +-
 tests/unit/test_scholar_parser.py             |  4 +-
 tests/unit/test_scholar_search_safety.py      |  6 +-
 tests/unit/test_scholar_source.py             |  4 +-
 tests/unit/test_unpaywall_pdf_discovery.py    |  2 +-
 tests/unit/test_unpaywall_resolution.py       |  6 +-
 tests/unit/test_user_settings.py              |  2 +-
 100 files changed, 405 insertions(+), 401 deletions(-)

diff --git a/MODERNIZATION_PLAN.md b/MODERNIZATION_PLAN.md
index 6460767..d51aded 100644
--- a/MODERNIZATION_PLAN.md
+++ b/MODERNIZATION_PLAN.md
@@ -80,17 +80,17 @@ Commit message: "refactor: add structured_log utility to eliminate logging boile
 
 ## Slice 3: Migrate Ingestion Logging to `structured_log()`
 
-**Why:** `app/services/domains/ingestion/application.py` is 3,089 lines. 8 `_log_*` helpers consume ~239 lines. 34 inline logger calls duplicate event names and include dead metric fields. This slice removes ~300 lines.
+**Why:** `app/services/ingestion/application.py` is 3,089 lines. 8 `_log_*` helpers consume ~239 lines. 34 inline logger calls duplicate event names and include dead metric fields. This slice removes ~300 lines.
 
 **Files to modify:**
-- `app/services/domains/ingestion/application.py`
+- `app/services/ingestion/application.py`
 
 **Context files:**
 - `app/logging_utils.py` (created in Slice 2)
 
 **Prompt:**
 ```
-You are working on the scholarr repository. The file `app/services/domains/ingestion/application.py` (3,089 lines) has 8 `_log_*` helper functions consuming ~239 lines, plus 34 inline logger calls with duplicated `"event":` keys and mixed `metric_name`/`metric_value` fields.
+You are working on the scholarr repository. The file `app/services/ingestion/application.py` (3,089 lines) has 8 `_log_*` helper functions consuming ~239 lines, plus 34 inline logger calls with duplicated `"event":` keys and mixed `metric_name`/`metric_value` fields.
 
 Migrate ALL logging in this file to use `structured_log()` from `app.logging_utils`.
 
@@ -148,11 +148,11 @@ Commit message: "refactor: migrate ingestion service logging to structured_log"
 **Why:** 11 more `_log_*` helpers remain across 8 files (183 lines total), plus inline logger calls with the same duplication pattern in ~20 files.
 
 **Files to modify (all have `_log_*` helpers to delete):**
-- `app/services/domains/ingestion/scheduler.py` — `_log_queue_item_resolved` (line ~518, 21 lines)
-- `app/services/domains/arxiv/rate_limit.py` — `_log_request_scheduled` (199), `_log_request_completed` (216), `_log_cooldown_activated` (235)
-- `app/services/domains/arxiv/client.py` — `_log_cache_event` (283), `_log_request_skipped_for_cooldown` (299)
-- `app/services/domains/publications/pdf_resolution_pipeline.py` — `_log_arxiv_skip` (148)
-- `app/services/domains/unpaywall/application.py` — `_log_resolution_summary` (194)
+- `app/services/ingestion/scheduler.py` — `_log_queue_item_resolved` (line ~518, 21 lines)
+- `app/services/arxiv/rate_limit.py` — `_log_request_scheduled` (199), `_log_request_completed` (216), `_log_cooldown_activated` (235)
+- `app/services/arxiv/client.py` — `_log_cache_event` (283), `_log_request_skipped_for_cooldown` (299)
+- `app/services/publications/pdf_resolution_pipeline.py` — `_log_arxiv_skip` (148)
+- `app/services/unpaywall/application.py` — `_log_resolution_summary` (194)
 - `app/api/routers/publications.py` — `_log_retry_pdf_result` (343)
 - `app/api/routers/settings.py` — `_log_settings_update` (103)
 - `app/main.py` — `_log_startup_build_marker` (53)
@@ -168,16 +168,16 @@ Commit message: "refactor: migrate ingestion service logging to structured_log"
 - `app/api/routers/admin.py`
 - `app/api/routers/auth.py`
 - `app/api/routers/publications.py`
-- `app/services/domains/scholars/application.py`
-- `app/services/domains/runs/events.py`
-- `app/services/domains/openalex/client.py`
-- `app/services/domains/openalex/matching.py`
-- `app/services/domains/crossref/application.py`
-- `app/services/domains/publications/dedup.py`
-- `app/services/domains/publications/enrichment.py`
-- `app/services/domains/publications/pdf_queue.py`
-- `app/services/domains/scholar/source.py`
-- `app/services/domains/arxiv/gateway.py`
+- `app/services/scholars/application.py`
+- `app/services/runs/events.py`
+- `app/services/openalex/client.py`
+- `app/services/openalex/matching.py`
+- `app/services/crossref/application.py`
+- `app/services/publications/dedup.py`
+- `app/services/publications/enrichment.py`
+- `app/services/publications/pdf_queue.py`
+- `app/services/scholar/source.py`
+- `app/services/arxiv/gateway.py`
 
 **Prompt:**
 ```
@@ -185,14 +185,14 @@ You are working on the scholarr repository. Slice 3 migrated `ingestion/applicat
 
 1. Delete these `_log_*` helper functions and replace their call sites with inline `structured_log()`:
 
-   - `app/services/domains/ingestion/scheduler.py:~518` — `_log_queue_item_resolved` (21 lines)
-   - `app/services/domains/arxiv/rate_limit.py:~199` — `_log_request_scheduled` (17 lines)
-   - `app/services/domains/arxiv/rate_limit.py:~216` — `_log_request_completed` (19 lines)
-   - `app/services/domains/arxiv/rate_limit.py:~235` — `_log_cooldown_activated` (13 lines)
-   - `app/services/domains/arxiv/client.py:~283` — `_log_cache_event` (16 lines)
-   - `app/services/domains/arxiv/client.py:~299` — `_log_request_skipped_for_cooldown` (13 lines)
-   - `app/services/domains/publications/pdf_resolution_pipeline.py:~148` — `_log_arxiv_skip` (11 lines)
-   - `app/services/domains/unpaywall/application.py:~194` — `_log_resolution_summary` (21 lines)
+   - `app/services/ingestion/scheduler.py:~518` — `_log_queue_item_resolved` (21 lines)
+   - `app/services/arxiv/rate_limit.py:~199` — `_log_request_scheduled` (17 lines)
+   - `app/services/arxiv/rate_limit.py:~216` — `_log_request_completed` (19 lines)
+   - `app/services/arxiv/rate_limit.py:~235` — `_log_cooldown_activated` (13 lines)
+   - `app/services/arxiv/client.py:~283` — `_log_cache_event` (16 lines)
+   - `app/services/arxiv/client.py:~299` — `_log_request_skipped_for_cooldown` (13 lines)
+   - `app/services/publications/pdf_resolution_pipeline.py:~148` — `_log_arxiv_skip` (11 lines)
+   - `app/services/unpaywall/application.py:~194` — `_log_resolution_summary` (21 lines)
    - `app/api/routers/publications.py:~343` — `_log_retry_pdf_result` (24 lines)
    - `app/api/routers/settings.py:~103` — `_log_settings_update` (15 lines)
    - `app/main.py:~53` — `_log_startup_build_marker` (13 lines)
@@ -203,7 +203,7 @@ You are working on the scholarr repository. Slice 3 migrated `ingestion/applicat
    - Remove `metric_name`/`metric_value` from all calls
    - Keep `logger.exception()` calls but remove the duplicated `"event"` key from their extra dicts
 
-3. In `app/services/domains/openalex/client.py`, the lines that log `response.text` (lines ~87, ~137):
+3. In `app/services/openalex/client.py`, the lines that log `response.text` (lines ~87, ~137):
    - Truncate: `response.text[:500]`
 
 4. Do NOT change any business logic. Only logging call sites.
@@ -221,8 +221,8 @@ Commit message: "refactor: migrate all remaining logging to structured_log, remo
 **Why:** Self-hosted users need clear, actionable logs. Current logging has verbose debug noise (per-HTTP-request, per-publication), overly long event names, and no console display optimization.
 
 **Files to modify:**
-- `app/services/domains/scholar/source.py`
-- `app/services/domains/ingestion/application.py`
+- `app/services/scholar/source.py`
+- `app/services/ingestion/application.py`
 - `app/logging_config.py`
 - Any files with event names longer than ~40 chars
 
@@ -231,8 +231,8 @@ Commit message: "refactor: migrate all remaining logging to structured_log, remo
 You are working on the scholarr repository. The logging has been migrated to `structured_log()` (slices 2-4). Now audit log RELEVANCE and READABILITY for self-hosted users running this in Docker.
 
 1. **Remove redundant debug logs:**
-   - `app/services/domains/scholar/source.py`: Remove the 3 debug-level HTTP fetch events (fetch_started, search_fetch_started, publication_fetch_started). Keep only `fetch_succeeded` at DEBUG. The HTTP middleware already logs request.started/completed.
-   - `app/services/domains/ingestion/application.py`: Remove per-publication `publication.discovered` and `publication.created` DEBUG logs. The run_completed summary already reports totals.
+   - `app/services/scholar/source.py`: Remove the 3 debug-level HTTP fetch events (fetch_started, search_fetch_started, publication_fetch_started). Keep only `fetch_succeeded` at DEBUG. The HTTP middleware already logs request.started/completed.
+   - `app/services/ingestion/application.py`: Remove per-publication `publication.discovered` and `publication.created` DEBUG logs. The run_completed summary already reports totals.
 
 2. **Shorten overly long event names** (search all structured_log calls in app/):
    - `ingestion.request_delay_coerced_to_policy_floor` → `ingestion.delay_coerced`
@@ -396,7 +396,7 @@ Commit message: "ci: add CodeQL security scanning and Dependabot"
 
 **Files to modify:**
 - `pyproject.toml`
-- `app/services/domains/crossref/application.py`
+- `app/services/crossref/application.py`
 
 **Files to create:**
 - `.github/workflows/release.yml`
@@ -405,7 +405,7 @@ Commit message: "ci: add CodeQL security scanning and Dependabot"
 ```
 You are working on the scholarr repository. Set up automated versioning with python-semantic-release.
 
-1. Fix hardcoded version in `app/services/domains/crossref/application.py` (line ~294):
+1. Fix hardcoded version in `app/services/crossref/application.py` (line ~294):
    ```python
    # Before:
    etiquette = Etiquette(settings.app_name, "0.1.0", "https://scholarr.local", email)
@@ -546,18 +546,18 @@ Commit message: "docs: rebuild documentation from scratch with clean IA"
 **Why:** After logging cleanup (slices 3+5), the file is ~2,700-2,800 lines. Still the largest source file by 3x. This begins decomposition with the safest extract: safety gate logic.
 
 **Files to modify:**
-- `app/services/domains/ingestion/application.py`
+- `app/services/ingestion/application.py`
 
 **Files to create:**
-- `app/services/domains/ingestion/safety.py`
+- `app/services/ingestion/safety.py`
 
 **Prompt:**
 ```
-You are working on the scholarr repository. `app/services/domains/ingestion/application.py` is ~2,700-2,800 lines (after logging cleanup). It contains the entire ingestion orchestration in a single class.
+You are working on the scholarr repository. `app/services/ingestion/application.py` is ~2,700-2,800 lines (after logging cleanup). It contains the entire ingestion orchestration in a single class.
 
 Extract the FIRST logical chunk: safety gate logic.
 
-1. Read `app/services/domains/ingestion/application.py` fully.
+1. Read `app/services/ingestion/application.py` fully.
 
 2. Identify safety/cooldown methods:
    - `_enforce_safety_gate`
@@ -565,7 +565,7 @@ Extract the FIRST logical chunk: safety gate logic.
    - Cooldown activation/clearing methods
    - Alert threshold evaluation methods
 
-3. Create `app/services/domains/ingestion/safety.py`:
+3. Create `app/services/ingestion/safety.py`:
    - Move identified methods to standalone functions or a small class
    - Accept explicit parameters (no implicit self.xxx state)
    - Keep same function signatures where possible
@@ -577,7 +577,7 @@ Extract the FIRST logical chunk: safety gate logic.
 
 Constraints from `agents.md`:
 - Max 50 lines per function
-- No flat files in `app/services/` root — all within `app/services/domains/ingestion/`
+- No flat files in `app/services/` root — all within `app/services/ingestion/`
 - Fail fast, early returns, guard clauses
 
 Commit message: "refactor: extract ingestion safety gate logic to dedicated module"
diff --git a/agents.md b/agents.md
index a114a45..f2f16bf 100644
--- a/agents.md
+++ b/agents.md
@@ -35,7 +35,7 @@ These limits prevent IP bans and are not to be optimized away.
 
 ## 5. Domain Service Boundaries
 
-- **Strict Modularity:** Flat files in the `app/services/` root are strictly prohibited. All business logic and routing must reside exclusively within `app/services/domains/`.
+- **Strict Modularity:** Flat files in the `app/services/` root are strictly prohibited. All business logic and routing must reside exclusively within `app/services/<domain>/`.
 
 ## 6. UI rules
 
diff --git a/app/api/media.py b/app/api/media.py
index 878c347..3bed5f8 100644
--- a/app/api/media.py
+++ b/app/api/media.py
@@ -10,8 +10,8 @@ from app.api.deps import get_api_current_user
 from app.api.errors import ApiException
 from app.db.models import User
 from app.db.session import get_db_session
-from app.services.domains.scholars import application as scholar_service
-from app.services.domains.scholars import uploads as scholar_uploads
+from app.services.scholars import application as scholar_service
+from app.services.scholars import uploads as scholar_uploads
 from app.settings import settings
 
 router = APIRouter(tags=["media"])
diff --git a/app/api/routers/admin.py b/app/api/routers/admin.py
index 416b084..35c61b6 100644
--- a/app/api/routers/admin.py
+++ b/app/api/routers/admin.py
@@ -21,7 +21,7 @@ from app.auth.service import AuthService
 from app.db.models import User
 from app.db.session import get_db_session
 from app.logging_utils import structured_log
-from app.services.domains.users import application as user_service
+from app.services.users import application as user_service
 
 logger = logging.getLogger(__name__)
 
diff --git a/app/api/routers/admin_dbops.py b/app/api/routers/admin_dbops.py
index f465268..0f4d1f6 100644
--- a/app/api/routers/admin_dbops.py
+++ b/app/api/routers/admin_dbops.py
@@ -22,13 +22,13 @@ from app.api.schemas import (
 from app.db.models import DataRepairJob, User
 from app.db.session import get_db_session
 from app.logging_utils import structured_log
-from app.services.domains.dbops import (
+from app.services.dbops import (
     collect_integrity_report,
     list_repair_jobs,
     run_publication_link_repair,
     run_publication_near_duplicate_repair,
 )
-from app.services.domains.publications import application as publication_service
+from app.services.publications import application as publication_service
 
 logger = logging.getLogger(__name__)
 
diff --git a/app/api/routers/auth.py b/app/api/routers/auth.py
index 128fd65..a46d71b 100644
--- a/app/api/routers/auth.py
+++ b/app/api/routers/auth.py
@@ -26,7 +26,7 @@ from app.db.models import User
 from app.db.session import get_db_session
 from app.logging_utils import structured_log
 from app.security.csrf import ensure_csrf_token
-from app.services.domains.users import application as user_service
+from app.services.users import application as user_service
 
 logger = logging.getLogger(__name__)
 
diff --git a/app/api/routers/publications.py b/app/api/routers/publications.py
index 107f531..1d8ec53 100644
--- a/app/api/routers/publications.py
+++ b/app/api/routers/publications.py
@@ -23,9 +23,9 @@ from app.api.schemas import (
 from app.db.models import User
 from app.db.session import get_db_session
 from app.logging_utils import structured_log
-from app.services.domains.publication_identifiers import application as identifier_service
-from app.services.domains.publications import application as publication_service
-from app.services.domains.scholars import application as scholar_service
+from app.services.publication_identifiers import application as identifier_service
+from app.services.publications import application as publication_service
+from app.services.scholars import application as scholar_service
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
diff --git a/app/api/routers/runs.py b/app/api/routers/runs.py
index b55de66..8821ebf 100644
--- a/app/api/routers/runs.py
+++ b/app/api/routers/runs.py
@@ -25,11 +25,11 @@ from app.api.schemas import (
 from app.db.models import RunStatus, RunTriggerType, User
 from app.db.session import get_db_session
 from app.logging_utils import structured_log
-from app.services.domains.ingestion import application as ingestion_service
-from app.services.domains.ingestion import safety as run_safety_service
-from app.services.domains.runs import application as run_service
-from app.services.domains.runs.events import event_generator
-from app.services.domains.settings import application as user_settings_service
+from app.services.ingestion import application as ingestion_service
+from app.services.ingestion import safety as run_safety_service
+from app.services.runs import application as run_service
+from app.services.runs.events import event_generator
+from app.services.settings import application as user_settings_service
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
diff --git a/app/api/routers/scholars.py b/app/api/routers/scholars.py
index 0792aa5..87fd04a 100644
--- a/app/api/routers/scholars.py
+++ b/app/api/routers/scholars.py
@@ -25,12 +25,12 @@ from app.api.schemas import (
 from app.db.models import User
 from app.db.session import get_db_session
 from app.logging_utils import structured_log
-from app.services.domains.ingestion import queue as ingestion_queue_service
-from app.services.domains.portability import application as import_export_service
-from app.services.domains.scholar import rate_limit as scholar_rate_limit
-from app.services.domains.scholar.source import ScholarSource
-from app.services.domains.scholars import application as scholar_service
-from app.services.domains.scholars import search_hints as scholar_search_hints
+from app.services.ingestion import queue as ingestion_queue_service
+from app.services.portability import application as import_export_service
+from app.services.scholar import rate_limit as scholar_rate_limit
+from app.services.scholar.source import ScholarSource
+from app.services.scholars import application as scholar_service
+from app.services.scholars import search_hints as scholar_search_hints
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
diff --git a/app/api/routers/settings.py b/app/api/routers/settings.py
index 55e6a51..a3cc88f 100644
--- a/app/api/routers/settings.py
+++ b/app/api/routers/settings.py
@@ -12,8 +12,8 @@ from app.api.schemas import SettingsEnvelope, SettingsUpdateRequest
 from app.db.models import User
 from app.db.session import get_db_session
 from app.logging_utils import structured_log
-from app.services.domains.ingestion import safety as run_safety_service
-from app.services.domains.settings import application as user_settings_service
+from app.services.ingestion import safety as run_safety_service
+from app.services.settings import application as user_settings_service
 from app.settings import settings as settings_module
 
 logger = logging.getLogger(__name__)
diff --git a/app/api/runtime_deps.py b/app/api/runtime_deps.py
index 3a692a3..5a6e9de 100644
--- a/app/api/runtime_deps.py
+++ b/app/api/runtime_deps.py
@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from fastapi import Depends
 
-from app.services.domains.ingestion import application as ingestion_service
-from app.services.domains.scholar import source as scholar_source_service
+from app.services.ingestion import application as ingestion_service
+from app.services.scholar import source as scholar_source_service
 
 
 def get_scholar_source() -> scholar_source_service.ScholarSource:
diff --git a/app/auth/runtime.py b/app/auth/runtime.py
index 077b7a1..267325a 100644
--- a/app/auth/runtime.py
+++ b/app/auth/runtime.py
@@ -9,7 +9,7 @@ from app.auth.session import clear_session_user, get_session_user, set_session_u
 from app.db.models import User
 from app.logging_utils import structured_log
 from app.security.csrf import CSRF_SESSION_KEY
-from app.services.domains.users import application as user_service
+from app.services.users import application as user_service
 
 logger = logging.getLogger(__name__)
 
diff --git a/app/main.py b/app/main.py
index e83cc16..cf03376 100644
--- a/app/main.py
+++ b/app/main.py
@@ -21,7 +21,7 @@ from app.http.middleware import (
 from app.logging_config import configure_logging, parse_redact_fields
 from app.logging_utils import structured_log
 from app.security.csrf import CSRFMiddleware
-from app.services.domains.ingestion.scheduler import SchedulerService
+from app.services.ingestion.scheduler import SchedulerService
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
diff --git a/app/services/arxiv/application.py b/app/services/arxiv/application.py
index 255795f..ff53632 100644
--- a/app/services/arxiv/application.py
+++ b/app/services/arxiv/application.py
@@ -2,13 +2,13 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from app.services.domains.arxiv.gateway import (
+from app.services.arxiv.gateway import (
     build_arxiv_query,
     get_arxiv_gateway,
 )
 
 if TYPE_CHECKING:
-    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+    from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 
 def _build_arxiv_query(title: str, author_surname: str | None) -> str | None:
diff --git a/app/services/arxiv/cache.py b/app/services/arxiv/cache.py
index c0aa143..1e9dac9 100644
--- a/app/services/arxiv/cache.py
+++ b/app/services/arxiv/cache.py
@@ -12,8 +12,8 @@ from sqlalchemy import delete, func, select
 
 from app.db.models import ArxivQueryCacheEntry
 from app.db.session import get_session_factory
-from app.services.domains.arxiv.constants import ARXIV_CACHE_FINGERPRINT_VERSION
-from app.services.domains.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
+from app.services.arxiv.constants import ARXIV_CACHE_FINGERPRINT_VERSION
+from app.services.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
 
 _INFLIGHT_LOCK = asyncio.Lock()
 _INFLIGHT_FEEDS: dict[str, asyncio.Future[ArxivFeed]] = {}
diff --git a/app/services/arxiv/client.py b/app/services/arxiv/client.py
index 7318271..27f048f 100644
--- a/app/services/arxiv/client.py
+++ b/app/services/arxiv/client.py
@@ -6,21 +6,21 @@ from collections.abc import Awaitable, Callable
 import httpx
 
 from app.logging_utils import structured_log
-from app.services.domains.arxiv.cache import (
+from app.services.arxiv.cache import (
     build_query_fingerprint,
     get_cached_feed,
     run_with_inflight_dedupe,
     set_cached_feed,
 )
-from app.services.domains.arxiv.constants import (
+from app.services.arxiv.constants import (
     ARXIV_SOURCE_PATH_LOOKUP_IDS,
     ARXIV_SOURCE_PATH_SEARCH,
     ARXIV_SOURCE_PATH_UNKNOWN,
 )
-from app.services.domains.arxiv.errors import ArxivClientValidationError, ArxivRateLimitError
-from app.services.domains.arxiv.parser import parse_arxiv_feed
-from app.services.domains.arxiv.rate_limit import get_arxiv_cooldown_status, run_with_global_arxiv_limit
-from app.services.domains.arxiv.types import ArxivFeed
+from app.services.arxiv.errors import ArxivClientValidationError, ArxivRateLimitError
+from app.services.arxiv.parser import parse_arxiv_feed
+from app.services.arxiv.rate_limit import get_arxiv_cooldown_status, run_with_global_arxiv_limit
+from app.services.arxiv.types import ArxivFeed
 from app.settings import settings
 
 _ARXIV_API_URL = "https://export.arxiv.org/api/query"
diff --git a/app/services/arxiv/gateway.py b/app/services/arxiv/gateway.py
index 5c13b35..b352894 100644
--- a/app/services/arxiv/gateway.py
+++ b/app/services/arxiv/gateway.py
@@ -6,13 +6,13 @@ import unicodedata
 from typing import TYPE_CHECKING, Protocol
 
 from app.logging_utils import structured_log
-from app.services.domains.arxiv.client import ArxivClient
-from app.services.domains.arxiv.errors import ArxivRateLimitError
-from app.services.domains.arxiv.types import ArxivFeed
+from app.services.arxiv.client import ArxivClient
+from app.services.arxiv.errors import ArxivRateLimitError
+from app.services.arxiv.types import ArxivFeed
 from app.settings import settings
 
 if TYPE_CHECKING:
-    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+    from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 logger = logging.getLogger(__name__)
 
diff --git a/app/services/arxiv/guards.py b/app/services/arxiv/guards.py
index 9f7a35f..db88b3f 100644
--- a/app/services/arxiv/guards.py
+++ b/app/services/arxiv/guards.py
@@ -3,17 +3,17 @@ from __future__ import annotations
 import re
 from typing import TYPE_CHECKING
 
-from app.services.domains.arxiv.constants import (
+from app.services.arxiv.constants import (
     ARXIV_STRONG_IDENTIFIER_CONFIDENCE,
     ARXIV_TITLE_MIN_ALPHA_TOKENS,
     ARXIV_TITLE_MIN_TOKENS,
     ARXIV_TITLE_TOKEN_MIN_LENGTH,
 )
-from app.services.domains.doi.normalize import normalize_doi
-from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
+from app.services.doi.normalize import normalize_doi
+from app.services.publication_identifiers.normalize import normalize_arxiv_id
 
 if TYPE_CHECKING:
-    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+    from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 _TITLE_TOKEN_RE = re.compile(r"[a-z0-9]+")
 
diff --git a/app/services/arxiv/parser.py b/app/services/arxiv/parser.py
index bc1d7ee..f563493 100644
--- a/app/services/arxiv/parser.py
+++ b/app/services/arxiv/parser.py
@@ -2,9 +2,9 @@ from __future__ import annotations
 
 import xml.etree.ElementTree as ET
 
-from app.services.domains.arxiv.errors import ArxivParseError
-from app.services.domains.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
-from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
+from app.services.arxiv.errors import ArxivParseError
+from app.services.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
+from app.services.publication_identifiers.normalize import normalize_arxiv_id
 
 _NAMESPACES = {
     "atom": "http://www.w3.org/2005/Atom",
diff --git a/app/services/arxiv/rate_limit.py b/app/services/arxiv/rate_limit.py
index b5e5eed..56c8d4c 100644
--- a/app/services/arxiv/rate_limit.py
+++ b/app/services/arxiv/rate_limit.py
@@ -13,13 +13,13 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from app.db.models import ArxivRuntimeState
 from app.db.session import get_session_factory
 from app.logging_utils import structured_log
-from app.services.domains.arxiv.constants import (
+from app.services.arxiv.constants import (
     ARXIV_RATE_LIMIT_LOCK_KEY,
     ARXIV_RATE_LIMIT_LOCK_NAMESPACE,
     ARXIV_RUNTIME_STATE_KEY,
     ARXIV_SOURCE_PATH_UNKNOWN,
 )
-from app.services.domains.arxiv.errors import ArxivRateLimitError
+from app.services.arxiv.errors import ArxivRateLimitError
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
diff --git a/app/services/crossref/__init__.py b/app/services/crossref/__init__.py
index 8adb7ba..98882f0 100644
--- a/app/services/crossref/__init__.py
+++ b/app/services/crossref/__init__.py
@@ -1,5 +1,5 @@
 from __future__ import annotations
 
-from app.services.domains.crossref.application import discover_doi_for_publication
+from app.services.crossref.application import discover_doi_for_publication
 
 __all__ = ["discover_doi_for_publication"]
diff --git a/app/services/dbops/__init__.py b/app/services/dbops/__init__.py
index 0439955..3209dec 100644
--- a/app/services/dbops/__init__.py
+++ b/app/services/dbops/__init__.py
@@ -1,9 +1,9 @@
-from app.services.domains.dbops.application import run_publication_link_repair
-from app.services.domains.dbops.integrity import collect_integrity_report
-from app.services.domains.dbops.near_duplicate_repair import (
+from app.services.dbops.application import run_publication_link_repair
+from app.services.dbops.integrity import collect_integrity_report
+from app.services.dbops.near_duplicate_repair import (
     run_publication_near_duplicate_repair,
 )
-from app.services.domains.dbops.query import list_repair_jobs
+from app.services.dbops.query import list_repair_jobs
 
 __all__ = [
     "collect_integrity_report",
diff --git a/app/services/dbops/near_duplicate_repair.py b/app/services/dbops/near_duplicate_repair.py
index f7ebac8..76a295f 100644
--- a/app/services/dbops/near_duplicate_repair.py
+++ b/app/services/dbops/near_duplicate_repair.py
@@ -6,7 +6,7 @@ from typing import Any
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import DataRepairJob
-from app.services.domains.publications import dedup as dedup_service
+from app.services.publications import dedup as dedup_service
 
 REPAIR_STATUS_PLANNED = "planned"
 REPAIR_STATUS_RUNNING = "running"
diff --git a/app/services/ingestion/application.py b/app/services/ingestion/application.py
index 9707c65..9aa49b9 100644
--- a/app/services/ingestion/application.py
+++ b/app/services/ingestion/application.py
@@ -20,11 +20,11 @@ from app.db.models import (
     ScholarPublication,
 )
 from app.logging_utils import structured_log
-from app.services.domains.arxiv.errors import ArxivRateLimitError
-from app.services.domains.doi.normalize import first_doi_from_texts
-from app.services.domains.ingestion import queue as queue_service
-from app.services.domains.ingestion import safety as run_safety_service
-from app.services.domains.ingestion.constants import (
+from app.services.arxiv.errors import ArxivRateLimitError
+from app.services.doi.normalize import first_doi_from_texts
+from app.services.ingestion import queue as queue_service
+from app.services.ingestion import safety as run_safety_service
+from app.services.ingestion.constants import (
     FAILED_STATES,
     FAILURE_BUCKET_BLOCKED,
     FAILURE_BUCKET_INGESTION,
@@ -35,7 +35,7 @@ from app.services.domains.ingestion.constants import (
     RESUMABLE_PARTIAL_REASONS,
     RUN_LOCK_NAMESPACE,
 )
-from app.services.domains.ingestion.fingerprints import (
+from app.services.ingestion.fingerprints import (
     _build_body_excerpt,
     _dedupe_publication_candidates,
     _next_cstart_value,
@@ -45,7 +45,7 @@ from app.services.domains.ingestion.fingerprints import (
     canonical_title_for_dedup,
     normalize_title,
 )
-from app.services.domains.ingestion.types import (
+from app.services.ingestion.types import (
     PagedLoopState,
     PagedParseResult,
     RunAlertSummary,
@@ -56,17 +56,17 @@ from app.services.domains.ingestion.types import (
     RunProgress,
     ScholarProcessingOutcome,
 )
-from app.services.domains.publication_identifiers import application as identifier_service
-from app.services.domains.runs.events import run_events
-from app.services.domains.scholar.parser import (
+from app.services.publication_identifiers import application as identifier_service
+from app.services.runs.events import run_events
+from app.services.scholar.parser import (
     ParsedProfilePage,
     ParseState,
     PublicationCandidate,
     ScholarParserError,
     parse_profile_page,
 )
-from app.services.domains.scholar.source import FetchResult, ScholarSource
-from app.services.domains.settings import application as user_settings_service
+from app.services.scholar.source import FetchResult, ScholarSource
+from app.services.settings import application as user_settings_service
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
@@ -2369,12 +2369,12 @@ class ScholarIngestionService:
         Stops immediately on budget exhaustion (429 with $0 remaining).
         Sleeps 60s and continues on transient rate limits.
         """
-        from app.services.domains.openalex.client import (
+        from app.services.openalex.client import (
             OpenAlexBudgetExhaustedError,
             OpenAlexClient,
             OpenAlexRateLimitError,
         )
-        from app.services.domains.openalex.matching import find_best_match
+        from app.services.openalex.matching import find_best_match
 
         run_result = await db_session.execute(select(CrawlRun.user_id).where(CrawlRun.id == run_id))
         user_id = run_result.scalar_one()
@@ -2480,7 +2480,7 @@ class ScholarIngestionService:
 
         await db_session.flush()
 
-        from app.services.domains.publications.dedup import sweep_identifier_duplicates
+        from app.services.publications.dedup import sweep_identifier_duplicates
 
         merge_count = await sweep_identifier_duplicates(db_session)
         if merge_count:
@@ -2579,8 +2579,8 @@ class ScholarIngestionService:
         if not publications:
             return publications
 
-        from app.services.domains.openalex.client import OpenAlexClient
-        from app.services.domains.openalex.matching import find_best_match
+        from app.services.openalex.client import OpenAlexClient
+        from app.services.openalex.matching import find_best_match
 
         client = OpenAlexClient(api_key=settings.openalex_api_key, mailto=settings.crossref_api_mailto)
 
diff --git a/app/services/ingestion/constants.py b/app/services/ingestion/constants.py
index cfe2ba0..cf371c6 100644
--- a/app/services/ingestion/constants.py
+++ b/app/services/ingestion/constants.py
@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 
-from app.services.domains.scholar.parser import ParseState
+from app.services.scholar.parser import ParseState
 
 TITLE_ALNUM_RE = re.compile(r"[^a-z0-9]+")
 WORD_RE = re.compile(r"[a-z0-9]+")
diff --git a/app/services/ingestion/fingerprints.py b/app/services/ingestion/fingerprints.py
index a39c72d..0d04f01 100644
--- a/app/services/ingestion/fingerprints.py
+++ b/app/services/ingestion/fingerprints.py
@@ -7,14 +7,14 @@ import unicodedata
 from typing import Any
 from urllib.parse import urljoin
 
-from app.services.domains.ingestion.constants import (
+from app.services.ingestion.constants import (
     HTML_TAG_RE,
     INITIAL_PAGE_FINGERPRINT_MAX_PUBLICATIONS,
     SPACE_RE,
     TITLE_ALNUM_RE,
     WORD_RE,
 )
-from app.services.domains.scholar.parser import ParsedProfilePage, ParseState, PublicationCandidate
+from app.services.scholar.parser import ParsedProfilePage, ParseState, PublicationCandidate
 
 # Scholar-specific noise patterns stripped before canonical comparison.
 # Applied in order; each targets a different Scholar metadata injection style.
diff --git a/app/services/ingestion/scheduler.py b/app/services/ingestion/scheduler.py
index df20d2d..12ba3ef 100644
--- a/app/services/ingestion/scheduler.py
+++ b/app/services/ingestion/scheduler.py
@@ -18,14 +18,14 @@ from app.db.models import (
 )
 from app.db.session import get_session_factory
 from app.logging_utils import structured_log
-from app.services.domains.ingestion import queue as queue_service
-from app.services.domains.ingestion.application import (
+from app.services.ingestion import queue as queue_service
+from app.services.ingestion.application import (
     RunAlreadyInProgressError,
     RunBlockedBySafetyPolicyError,
     ScholarIngestionService,
 )
-from app.services.domains.scholar.source import LiveScholarSource
-from app.services.domains.settings import application as user_settings_service
+from app.services.scholar.source import LiveScholarSource
+from app.services.settings import application as user_settings_service
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
@@ -589,7 +589,7 @@ class SchedulerService:
         await self._finalize_queue_job_after_run(job, run_summary)
 
     async def _drain_pdf_queue(self) -> None:
-        from app.services.domains.publications.pdf_queue import drain_ready_jobs
+        from app.services.publications.pdf_queue import drain_ready_jobs
 
         session_factory = get_session_factory()
         async with session_factory() as session:
diff --git a/app/services/ingestion/types.py b/app/services/ingestion/types.py
index 09d87f1..1f6aae8 100644
--- a/app/services/ingestion/types.py
+++ b/app/services/ingestion/types.py
@@ -4,8 +4,8 @@ from dataclasses import dataclass, field
 from typing import Any
 
 from app.db.models import RunStatus
-from app.services.domains.scholar.parser import ParsedProfilePage, PublicationCandidate
-from app.services.domains.scholar.source import FetchResult
+from app.services.scholar.parser import ParsedProfilePage, PublicationCandidate
+from app.services.scholar.source import FetchResult
 
 
 @dataclass(frozen=True)
diff --git a/app/services/openalex/client.py b/app/services/openalex/client.py
index 83edc20..f418c1e 100644
--- a/app/services/openalex/client.py
+++ b/app/services/openalex/client.py
@@ -8,7 +8,7 @@ from tenacity import (
     wait_exponential,
 )
 
-from app.services.domains.openalex.types import OpenAlexWork
+from app.services.openalex.types import OpenAlexWork
 
 logger = logging.getLogger(__name__)
 
diff --git a/app/services/openalex/matching.py b/app/services/openalex/matching.py
index 8b3c6d5..1ecf115 100644
--- a/app/services/openalex/matching.py
+++ b/app/services/openalex/matching.py
@@ -3,7 +3,7 @@ import re
 
 from rapidfuzz import fuzz
 
-from app.services.domains.openalex.types import OpenAlexWork
+from app.services.openalex.types import OpenAlexWork
 
 logger = logging.getLogger(__name__)
 
diff --git a/app/services/portability/__init__.py b/app/services/portability/__init__.py
index 2c081c6..9f63c8f 100644
--- a/app/services/portability/__init__.py
+++ b/app/services/portability/__init__.py
@@ -1,21 +1,21 @@
-from app.services.domains.portability.application import (
+from app.services.portability.application import (
     EXPORT_SCHEMA_VERSION as EXPORT_SCHEMA_VERSION,
 )
-from app.services.domains.portability.application import (
+from app.services.portability.application import (
     MAX_IMPORT_PUBLICATIONS as MAX_IMPORT_PUBLICATIONS,
 )
-from app.services.domains.portability.application import (
+from app.services.portability.application import (
     MAX_IMPORT_SCHOLARS as MAX_IMPORT_SCHOLARS,
 )
-from app.services.domains.portability.application import (
+from app.services.portability.application import (
     ImportedPublicationInput as ImportedPublicationInput,
 )
-from app.services.domains.portability.application import (
+from app.services.portability.application import (
     ImportExportError as ImportExportError,
 )
-from app.services.domains.portability.application import (
+from app.services.portability.application import (
     export_user_data as export_user_data,
 )
-from app.services.domains.portability.application import (
+from app.services.portability.application import (
     import_user_data as import_user_data,
 )
diff --git a/app/services/portability/application.py b/app/services/portability/application.py
index 6285c5d..c696f4d 100644
--- a/app/services/portability/application.py
+++ b/app/services/portability/application.py
@@ -5,20 +5,20 @@ from typing import Any
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import Publication
-from app.services.domains.portability.constants import (
+from app.services.portability.constants import (
     EXPORT_SCHEMA_VERSION,
     MAX_IMPORT_PUBLICATIONS,
     MAX_IMPORT_SCHOLARS,
 )
-from app.services.domains.portability.exporting import export_user_data
-from app.services.domains.portability.normalize import _validate_import_sizes
-from app.services.domains.portability.publication_import import (
+from app.services.portability.exporting import export_user_data
+from app.services.portability.normalize import _validate_import_sizes
+from app.services.portability.publication_import import (
     _build_imported_publication_input,
     _initialize_import_counters,
     _upsert_imported_publication,
 )
-from app.services.domains.portability.scholar_import import _upsert_imported_scholars
-from app.services.domains.portability.types import ImportedPublicationInput, ImportExportError
+from app.services.portability.scholar_import import _upsert_imported_scholars
+from app.services.portability.types import ImportedPublicationInput, ImportExportError
 
 
 async def import_user_data(
diff --git a/app/services/portability/exporting.py b/app/services/portability/exporting.py
index 2f50247..cd88cc6 100644
--- a/app/services/portability/exporting.py
+++ b/app/services/portability/exporting.py
@@ -7,7 +7,7 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import Publication, ScholarProfile, ScholarPublication
-from app.services.domains.portability.constants import EXPORT_SCHEMA_VERSION
+from app.services.portability.constants import EXPORT_SCHEMA_VERSION
 
 
 def _exported_at_iso() -> str:
diff --git a/app/services/portability/normalize.py b/app/services/portability/normalize.py
index 176bfc5..41e017f 100644
--- a/app/services/portability/normalize.py
+++ b/app/services/portability/normalize.py
@@ -3,14 +3,14 @@ from __future__ import annotations
 import hashlib
 from typing import Any
 
-from app.services.domains.ingestion.application import normalize_title
-from app.services.domains.portability.constants import (
+from app.services.ingestion.application import normalize_title
+from app.services.portability.constants import (
     MAX_IMPORT_PUBLICATIONS,
     MAX_IMPORT_SCHOLARS,
     SHA256_RE,
     WORD_RE,
 )
-from app.services.domains.portability.types import ImportExportError
+from app.services.portability.types import ImportExportError
 
 
 def _normalize_optional_text(value: Any) -> str | None:
diff --git a/app/services/portability/publication_import.py b/app/services/portability/publication_import.py
index afcb580..a347f4a 100644
--- a/app/services/portability/publication_import.py
+++ b/app/services/portability/publication_import.py
@@ -6,15 +6,15 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import Publication, ScholarProfile, ScholarPublication
-from app.services.domains.doi.normalize import normalize_doi
-from app.services.domains.ingestion.application import build_publication_url, normalize_title
-from app.services.domains.portability.normalize import (
+from app.services.doi.normalize import normalize_doi
+from app.services.ingestion.application import build_publication_url, normalize_title
+from app.services.portability.normalize import (
     _normalize_citation_count,
     _normalize_optional_text,
     _normalize_optional_year,
     _resolve_fingerprint,
 )
-from app.services.domains.portability.types import ImportedPublicationInput
+from app.services.portability.types import ImportedPublicationInput
 
 
 async def _find_publication_by_cluster(
diff --git a/app/services/portability/scholar_import.py b/app/services/portability/scholar_import.py
index c0a4c48..274e7fd 100644
--- a/app/services/portability/scholar_import.py
+++ b/app/services/portability/scholar_import.py
@@ -6,8 +6,8 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import ScholarProfile
-from app.services.domains.portability.normalize import _normalize_optional_text
-from app.services.domains.scholars import application as scholar_service
+from app.services.portability.normalize import _normalize_optional_text
+from app.services.scholars import application as scholar_service
 
 
 async def _load_user_scholar_map(
diff --git a/app/services/publication_identifiers/__init__.py b/app/services/publication_identifiers/__init__.py
index d6a4263..c64a01f 100644
--- a/app/services/publication_identifiers/__init__.py
+++ b/app/services/publication_identifiers/__init__.py
@@ -1,4 +1,4 @@
-from app.services.domains.publication_identifiers.application import (
+from app.services.publication_identifiers.application import (
     DisplayIdentifier,
     derive_display_identifier_from_values,
     display_identifier_for_publication_id,
diff --git a/app/services/publication_identifiers/application.py b/app/services/publication_identifiers/application.py
index b758e84..7724f46 100644
--- a/app/services/publication_identifiers/application.py
+++ b/app/services/publication_identifiers/application.py
@@ -7,22 +7,22 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import Publication, PublicationIdentifier
-from app.services.domains.arxiv.guards import arxiv_skip_reason_for_item
-from app.services.domains.doi.normalize import normalize_doi
-from app.services.domains.publication_identifiers.normalize import (
+from app.services.arxiv.guards import arxiv_skip_reason_for_item
+from app.services.doi.normalize import normalize_doi
+from app.services.publication_identifiers.normalize import (
     normalize_arxiv_id,
     normalize_pmcid,
     normalize_pmid,
 )
-from app.services.domains.publication_identifiers.types import (
+from app.services.publication_identifiers.types import (
     DisplayIdentifier,
     IdentifierCandidate,
     IdentifierKind,
 )
 
 if TYPE_CHECKING:
-    from app.services.domains.publications.pdf_queue import PdfQueueListItem
-    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+    from app.services.publications.pdf_queue import PdfQueueListItem
+    from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 CONFIDENCE_HIGH = 0.98
 CONFIDENCE_MEDIUM = 0.9
@@ -163,7 +163,7 @@ def _identifier_lookup_item(
     publication: Publication,
     scholar_label: str,
 ) -> UnreadPublicationItem:
-    from app.services.domains.publications.types import UnreadPublicationItem
+    from app.services.publications.types import UnreadPublicationItem
 
     return UnreadPublicationItem(
         publication_id=int(publication.id),
@@ -184,7 +184,7 @@ async def _discover_crossref_doi(
     publication_id: int,
     item: UnreadPublicationItem,
 ) -> bool:
-    from app.services.domains.crossref import application as crossref_service
+    from app.services.crossref import application as crossref_service
 
     discovered_doi = await crossref_service.discover_doi_for_publication(item=item)
     normalized_doi = normalize_doi(discovered_doi)
@@ -212,7 +212,7 @@ async def _discover_arxiv_identifier(
     publication_id: int,
     item: UnreadPublicationItem,
 ) -> None:
-    from app.services.domains.arxiv import application as arxiv_service
+    from app.services.arxiv import application as arxiv_service
 
     discovered_arxiv = await arxiv_service.discover_arxiv_id_for_publication(item=item)
     normalized_arxiv = normalize_arxiv_id(discovered_arxiv)
diff --git a/app/services/publication_identifiers/normalize.py b/app/services/publication_identifiers/normalize.py
index 9743092..1308a8d 100644
--- a/app/services/publication_identifiers/normalize.py
+++ b/app/services/publication_identifiers/normalize.py
@@ -3,8 +3,8 @@ from __future__ import annotations
 import re
 from urllib.parse import urlparse
 
-from app.services.domains.doi.normalize import normalize_doi
-from app.services.domains.publication_identifiers.types import IdentifierKind
+from app.services.doi.normalize import normalize_doi
+from app.services.publication_identifiers.types import IdentifierKind
 
 ARXIV_ABS_RE = re.compile(r"\barxiv:\s*([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?\b", re.I)
 ARXIV_RAW_RE = re.compile(r"^([a-z-]+/\d{7}|\d{4}\.\d{4,5})(v\d+)?$", re.I)
diff --git a/app/services/publications/__init__.py b/app/services/publications/__init__.py
index 058e728..c03a02a 100644
--- a/app/services/publications/__init__.py
+++ b/app/services/publications/__init__.py
@@ -1,84 +1,84 @@
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     MODE_ALL as MODE_ALL,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     MODE_LATEST as MODE_LATEST,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     MODE_NEW as MODE_NEW,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     MODE_UNREAD as MODE_UNREAD,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     PublicationListItem as PublicationListItem,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     UnreadPublicationItem as UnreadPublicationItem,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     count_favorite_for_user as count_favorite_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     count_for_user as count_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     count_latest_for_user as count_latest_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     count_pdf_queue_items as count_pdf_queue_items,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     count_unread_for_user as count_unread_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     enqueue_all_missing_pdf_jobs as enqueue_all_missing_pdf_jobs,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     enqueue_retry_pdf_job_for_publication_id as enqueue_retry_pdf_job_for_publication_id,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     get_latest_run_id_for_user as get_latest_run_id_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     get_publication_item_for_user as get_publication_item_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     hydrate_pdf_enrichment_state as hydrate_pdf_enrichment_state,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     list_for_user as list_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     list_pdf_queue_items as list_pdf_queue_items,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     list_pdf_queue_page as list_pdf_queue_page,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     list_unread_for_user as list_unread_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     mark_all_unread_as_read_for_user as mark_all_unread_as_read_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     mark_selected_as_read_for_user as mark_selected_as_read_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     publications_query as publications_query,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     resolve_publication_view_mode as resolve_publication_view_mode,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     retry_pdf_for_user as retry_pdf_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     schedule_missing_pdf_enrichment_for_user as schedule_missing_pdf_enrichment_for_user,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     schedule_retry_pdf_enrichment_for_row as schedule_retry_pdf_enrichment_for_row,
 )
-from app.services.domains.publications.application import (
+from app.services.publications.application import (
     set_publication_favorite_for_user as set_publication_favorite_for_user,
 )
diff --git a/app/services/publications/application.py b/app/services/publications/application.py
index b36f2ec..023903c 100644
--- a/app/services/publications/application.py
+++ b/app/services/publications/application.py
@@ -1,46 +1,46 @@
 from __future__ import annotations
 
-from app.services.domains.publications.counts import (
+from app.services.publications.counts import (
     count_favorite_for_user,
     count_for_user,
     count_latest_for_user,
     count_unread_for_user,
 )
-from app.services.domains.publications.enrichment import (
+from app.services.publications.enrichment import (
     hydrate_pdf_enrichment_state,
     schedule_missing_pdf_enrichment_for_user,
     schedule_retry_pdf_enrichment_for_row,
 )
-from app.services.domains.publications.listing import (
+from app.services.publications.listing import (
     list_for_user,
     list_unread_for_user,
     retry_pdf_for_user,
 )
-from app.services.domains.publications.modes import (
+from app.services.publications.modes import (
     MODE_ALL,
     MODE_LATEST,
     MODE_NEW,
     MODE_UNREAD,
     resolve_publication_view_mode,
 )
-from app.services.domains.publications.pdf_queue import (
+from app.services.publications.pdf_queue import (
     count_pdf_queue_items,
     enqueue_all_missing_pdf_jobs,
     enqueue_retry_pdf_job_for_publication_id,
     list_pdf_queue_items,
     list_pdf_queue_page,
 )
-from app.services.domains.publications.queries import (
+from app.services.publications.queries import (
     get_latest_run_id_for_user,
     get_publication_item_for_user,
     publications_query,
 )
-from app.services.domains.publications.read_state import (
+from app.services.publications.read_state import (
     mark_all_unread_as_read_for_user,
     mark_selected_as_read_for_user,
     set_publication_favorite_for_user,
 )
-from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 __all__ = [
     "MODE_ALL",
diff --git a/app/services/publications/counts.py b/app/services/publications/counts.py
index 700043a..fc09930 100644
--- a/app/services/publications/counts.py
+++ b/app/services/publications/counts.py
@@ -6,13 +6,13 @@ from sqlalchemy import distinct, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import Publication, ScholarProfile, ScholarPublication
-from app.services.domains.publications.modes import (
+from app.services.publications.modes import (
     MODE_ALL,
     MODE_LATEST,
     MODE_UNREAD,
     resolve_publication_view_mode,
 )
-from app.services.domains.publications.queries import get_latest_run_id_for_user
+from app.services.publications.queries import get_latest_run_id_for_user
 
 
 async def count_for_user(
diff --git a/app/services/publications/dedup.py b/app/services/publications/dedup.py
index d2e17a6..d078f97 100644
--- a/app/services/publications/dedup.py
+++ b/app/services/publications/dedup.py
@@ -11,7 +11,7 @@ from sqlalchemy.orm import aliased
 
 from app.db.models import Publication, PublicationIdentifier, ScholarPublication
 from app.logging_utils import structured_log
-from app.services.domains.ingestion.fingerprints import (
+from app.services.ingestion.fingerprints import (
     canonical_title_text_for_dedup,
     canonical_title_tokens_for_dedup,
     normalize_title,
diff --git a/app/services/publications/enrichment.py b/app/services/publications/enrichment.py
index 49cf9c6..3980d05 100644
--- a/app/services/publications/enrichment.py
+++ b/app/services/publications/enrichment.py
@@ -5,12 +5,12 @@ import logging
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.logging_utils import structured_log
-from app.services.domains.publications.pdf_queue import (
+from app.services.publications.pdf_queue import (
     enqueue_missing_pdf_jobs,
     enqueue_retry_pdf_job,
     overlay_pdf_job_state,
 )
-from app.services.domains.publications.types import PublicationListItem
+from app.services.publications.types import PublicationListItem
 
 logger = logging.getLogger(__name__)
 
diff --git a/app/services/publications/listing.py b/app/services/publications/listing.py
index 92e7462..6bb50b2 100644
--- a/app/services/publications/listing.py
+++ b/app/services/publications/listing.py
@@ -4,20 +4,20 @@ from datetime import datetime
 
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.services.domains.publication_identifiers import application as identifier_service
-from app.services.domains.publications.modes import (
+from app.services.publication_identifiers import application as identifier_service
+from app.services.publications.modes import (
     MODE_ALL,
     MODE_UNREAD,
     resolve_publication_view_mode,
 )
-from app.services.domains.publications.queries import (
+from app.services.publications.queries import (
     get_latest_run_id_for_user,
     get_publication_item_for_user,
     publication_list_item_from_row,
     publications_query,
     unread_item_from_row,
 )
-from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 
 async def list_for_user(
diff --git a/app/services/publications/pdf_queue.py b/app/services/publications/pdf_queue.py
index 1456fc5..96ec41b 100644
--- a/app/services/publications/pdf_queue.py
+++ b/app/services/publications/pdf_queue.py
@@ -18,13 +18,13 @@ from app.db.models import (
 )
 from app.db.session import get_session_factory
 from app.logging_utils import structured_log
-from app.services.domains.publication_identifiers import application as identifier_service
-from app.services.domains.publication_identifiers.types import DisplayIdentifier
-from app.services.domains.publications.pdf_resolution_pipeline import (
+from app.services.publication_identifiers import application as identifier_service
+from app.services.publication_identifiers.types import DisplayIdentifier
+from app.services.publications.pdf_resolution_pipeline import (
     resolve_publication_pdf_outcome_for_row,
 )
-from app.services.domains.publications.types import PublicationListItem
-from app.services.domains.unpaywall.application import (
+from app.services.publications.types import PublicationListItem
+from app.services.unpaywall.application import (
     FAILURE_RESOLUTION_EXCEPTION,
     OaResolutionOutcome,
 )
@@ -450,7 +450,7 @@ async def _resolve_publication_row(
     openalex_api_key: str | None = None,
     allow_arxiv_lookup: bool = True,
 ) -> bool:
-    from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
+    from app.services.openalex.client import OpenAlexBudgetExhaustedError
 
     await _mark_attempt_started(publication_id=row.publication_id, user_id=user_id)
     try:
@@ -493,8 +493,8 @@ async def _run_resolution_task(
     request_email: str | None,
     rows: list[PublicationListItem],
 ) -> None:
-    from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
-    from app.services.domains.settings import application as user_settings_service
+    from app.services.openalex.client import OpenAlexBudgetExhaustedError
+    from app.services.settings import application as user_settings_service
 
     # Resolve the best available API key: per-user setting → env var fallback.
     openalex_api_key: str | None = None
diff --git a/app/services/publications/pdf_resolution_pipeline.py b/app/services/publications/pdf_resolution_pipeline.py
index c537a4c..b36777d 100644
--- a/app/services/publications/pdf_resolution_pipeline.py
+++ b/app/services/publications/pdf_resolution_pipeline.py
@@ -5,11 +5,11 @@ from dataclasses import dataclass
 from typing import Any
 
 from app.logging_utils import structured_log
-from app.services.domains.arxiv.errors import ArxivRateLimitError
-from app.services.domains.arxiv.guards import arxiv_skip_reason_for_item
-from app.services.domains.openalex.client import OpenAlexBudgetExhaustedError
-from app.services.domains.publications.types import PublicationListItem
-from app.services.domains.unpaywall.application import OaResolutionOutcome, resolve_publication_oa_outcomes
+from app.services.arxiv.errors import ArxivRateLimitError
+from app.services.arxiv.guards import arxiv_skip_reason_for_item
+from app.services.openalex.client import OpenAlexBudgetExhaustedError
+from app.services.publications.types import PublicationListItem
+from app.services.unpaywall.application import OaResolutionOutcome, resolve_publication_oa_outcomes
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
@@ -59,8 +59,8 @@ async def _openalex_outcome(
     request_email: str | None,
     openalex_api_key: str | None = None,
 ) -> OaResolutionOutcome | None:
-    from app.services.domains.openalex.client import OpenAlexClient
-    from app.services.domains.openalex.matching import find_best_match
+    from app.services.openalex.client import OpenAlexClient
+    from app.services.openalex.matching import find_best_match
 
     if not row.title:
         return None
@@ -105,7 +105,7 @@ async def _arxiv_outcome(
     request_email: str | None,
     allow_lookup: bool = True,
 ) -> OaResolutionOutcome | None:
-    from app.services.domains.arxiv.application import discover_arxiv_id_for_publication
+    from app.services.arxiv.application import discover_arxiv_id_for_publication
 
     if not allow_lookup:
         structured_log(
diff --git a/app/services/publications/queries.py b/app/services/publications/queries.py
index ac6090f..fb03b61 100644
--- a/app/services/publications/queries.py
+++ b/app/services/publications/queries.py
@@ -13,8 +13,8 @@ from app.db.models import (
     ScholarProfile,
     ScholarPublication,
 )
-from app.services.domains.publications.modes import MODE_LATEST, MODE_UNREAD
-from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+from app.services.publications.modes import MODE_LATEST, MODE_UNREAD
+from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 
 def _normalized_citation_count(value: object) -> int:
diff --git a/app/services/publications/types.py b/app/services/publications/types.py
index 62d038b..c8b1ad1 100644
--- a/app/services/publications/types.py
+++ b/app/services/publications/types.py
@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import datetime
 
-from app.services.domains.publication_identifiers.types import DisplayIdentifier
+from app.services.publication_identifiers.types import DisplayIdentifier
 
 
 @dataclass(frozen=True)
diff --git a/app/services/runs/__init__.py b/app/services/runs/__init__.py
index 829f7f0..5bed6a2 100644
--- a/app/services/runs/__init__.py
+++ b/app/services/runs/__init__.py
@@ -1,51 +1,51 @@
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     QUEUE_STATUS_DROPPED as QUEUE_STATUS_DROPPED,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     QUEUE_STATUS_QUEUED as QUEUE_STATUS_QUEUED,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     QUEUE_STATUS_RETRYING as QUEUE_STATUS_RETRYING,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     QueueClearResult as QueueClearResult,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     QueueListItem as QueueListItem,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     QueueTransitionError as QueueTransitionError,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     clear_queue_item_for_user as clear_queue_item_for_user,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     drop_queue_item_for_user as drop_queue_item_for_user,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     extract_run_summary as extract_run_summary,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     get_manual_run_by_idempotency_key as get_manual_run_by_idempotency_key,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     get_queue_item_for_user as get_queue_item_for_user,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     get_run_for_user as get_run_for_user,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     list_queue_items_for_user as list_queue_items_for_user,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     list_recent_runs_for_user as list_recent_runs_for_user,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     list_runs_for_user as list_runs_for_user,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     queue_status_counts_for_user as queue_status_counts_for_user,
 )
-from app.services.domains.runs.application import (
+from app.services.runs.application import (
     retry_queue_item_for_user as retry_queue_item_for_user,
 )
diff --git a/app/services/runs/application.py b/app/services/runs/application.py
index 4f6e27f..e0b464a 100644
--- a/app/services/runs/application.py
+++ b/app/services/runs/application.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from app.services.domains.runs.queue_service import (
+from app.services.runs.queue_service import (
     clear_queue_item_for_user,
     drop_queue_item_for_user,
     get_queue_item_for_user,
@@ -8,14 +8,14 @@ from app.services.domains.runs.queue_service import (
     queue_status_counts_for_user,
     retry_queue_item_for_user,
 )
-from app.services.domains.runs.runs_service import (
+from app.services.runs.runs_service import (
     get_manual_run_by_idempotency_key,
     get_run_for_user,
     list_recent_runs_for_user,
     list_runs_for_user,
 )
-from app.services.domains.runs.summary import extract_run_summary
-from app.services.domains.runs.types import (
+from app.services.runs.summary import extract_run_summary
+from app.services.runs.types import (
     QUEUE_STATUS_DROPPED,
     QUEUE_STATUS_QUEUED,
     QUEUE_STATUS_RETRYING,
diff --git a/app/services/runs/queue_queries.py b/app/services/runs/queue_queries.py
index 7d2e501..588a47e 100644
--- a/app/services/runs/queue_queries.py
+++ b/app/services/runs/queue_queries.py
@@ -3,7 +3,7 @@ from __future__ import annotations
 from sqlalchemy import and_, select
 
 from app.db.models import IngestionQueueItem, ScholarProfile
-from app.services.domains.runs.types import QueueListItem
+from app.services.runs.types import QueueListItem
 
 
 def queue_item_columns() -> tuple:
diff --git a/app/services/runs/queue_service.py b/app/services/runs/queue_service.py
index 530e5b5..855171f 100644
--- a/app/services/runs/queue_service.py
+++ b/app/services/runs/queue_service.py
@@ -4,9 +4,9 @@ from sqlalchemy import case, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import IngestionQueueItem
-from app.services.domains.ingestion import queue as queue_mutations
-from app.services.domains.runs.queue_queries import queue_item_select, queue_list_item_from_row
-from app.services.domains.runs.types import (
+from app.services.ingestion import queue as queue_mutations
+from app.services.runs.queue_queries import queue_item_select, queue_list_item_from_row
+from app.services.runs.types import (
     QUEUE_STATUS_DROPPED,
     QUEUE_STATUS_QUEUED,
     QUEUE_STATUS_RETRYING,
diff --git a/app/services/scholar/author_rows.py b/app/services/scholar/author_rows.py
index 42a8b2b..a0705fb 100644
--- a/app/services/scholar/author_rows.py
+++ b/app/services/scholar/author_rows.py
@@ -5,9 +5,9 @@ from html.parser import HTMLParser
 from typing import Any
 from urllib.parse import parse_qs, urlparse
 
-from app.services.domains.scholar.parser_constants import AUTHOR_SEARCH_MARKER_KEYS
-from app.services.domains.scholar.parser_types import ScholarSearchCandidate
-from app.services.domains.scholar.parser_utils import (
+from app.services.scholar.parser_constants import AUTHOR_SEARCH_MARKER_KEYS
+from app.services.scholar.parser_types import ScholarSearchCandidate
+from app.services.scholar.parser_utils import (
     attr_class,
     attr_href,
     attr_src,
diff --git a/app/services/scholar/parser.py b/app/services/scholar/parser.py
index e8ab1bb..1718b3f 100644
--- a/app/services/scholar/parser.py
+++ b/app/services/scholar/parser.py
@@ -1,30 +1,30 @@
 from __future__ import annotations
 
-from app.services.domains.scholar.author_rows import (
+from app.services.scholar.author_rows import (
     ScholarAuthorSearchParser,
     count_author_search_markers,
 )
-from app.services.domains.scholar.parser_constants import SCRIPT_STYLE_RE
-from app.services.domains.scholar.parser_types import (
+from app.services.scholar.parser_constants import SCRIPT_STYLE_RE
+from app.services.scholar.parser_types import (
     ParsedAuthorSearchPage,
     ParsedProfilePage,
     PublicationCandidate,
     ScholarDomInvariantError,
     ScholarMalformedDataError,
 )
-from app.services.domains.scholar.parser_types import (
+from app.services.scholar.parser_types import (
     ParseState as ParseState,
 )
-from app.services.domains.scholar.parser_types import (
+from app.services.scholar.parser_types import (
     ScholarParserError as ScholarParserError,
 )
-from app.services.domains.scholar.parser_types import (
+from app.services.scholar.parser_types import (
     ScholarSearchCandidate as ScholarSearchCandidate,
 )
-from app.services.domains.scholar.parser_utils import (
+from app.services.scholar.parser_utils import (
     strip_tags,
 )
-from app.services.domains.scholar.profile_rows import (
+from app.services.scholar.profile_rows import (
     count_markers,
     extract_articles_range,
     extract_profile_image_url,
@@ -33,8 +33,8 @@ from app.services.domains.scholar.profile_rows import (
     has_show_more_button,
     parse_publications,
 )
-from app.services.domains.scholar.source import FetchResult
-from app.services.domains.scholar.state_detection import (
+from app.services.scholar.source import FetchResult
+from app.services.scholar.state_detection import (
     detect_author_search_state,
     detect_state,
 )
diff --git a/app/services/scholar/parser_utils.py b/app/services/scholar/parser_utils.py
index 1bf8687..0bc3b77 100644
--- a/app/services/scholar/parser_utils.py
+++ b/app/services/scholar/parser_utils.py
@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from html import unescape
 
-from app.services.domains.scholar.parser_constants import TAG_RE
+from app.services.scholar.parser_constants import TAG_RE
 
 
 def normalize_space(value: str) -> str:
diff --git a/app/services/scholar/profile_rows.py b/app/services/scholar/profile_rows.py
index 0ad8f15..bb0d83d 100644
--- a/app/services/scholar/profile_rows.py
+++ b/app/services/scholar/profile_rows.py
@@ -5,12 +5,12 @@ from html.parser import HTMLParser
 from typing import Any
 from urllib.parse import parse_qs, urlparse
 
-from app.services.domains.scholar.parser_constants import (
+from app.services.scholar.parser_constants import (
     MARKER_KEYS,
     SHOW_MORE_BUTTON_RE,
 )
-from app.services.domains.scholar.parser_types import PublicationCandidate
-from app.services.domains.scholar.parser_utils import (
+from app.services.scholar.parser_types import PublicationCandidate
+from app.services.scholar.parser_utils import (
     attr_class,
     attr_href,
     build_absolute_scholar_url,
diff --git a/app/services/scholar/source.py b/app/services/scholar/source.py
index 3930f2e..08f22ba 100644
--- a/app/services/scholar/source.py
+++ b/app/services/scholar/source.py
@@ -10,7 +10,7 @@ from urllib.parse import urlencode
 from urllib.request import Request, urlopen
 
 from app.logging_utils import structured_log
-from app.services.domains.scholar import rate_limit as scholar_rate_limit
+from app.services.scholar import rate_limit as scholar_rate_limit
 from app.settings import settings
 
 SCHOLAR_PROFILE_URL = "https://scholar.google.com/citations"
diff --git a/app/services/scholar/state_detection.py b/app/services/scholar/state_detection.py
index cdc8780..75f7125 100644
--- a/app/services/scholar/state_detection.py
+++ b/app/services/scholar/state_detection.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from app.services.domains.scholar.parser_constants import (
+from app.services.scholar.parser_constants import (
     BLOCKED_KEYWORDS,
     NETWORK_DNS_ERROR_KEYWORDS,
     NETWORK_TIMEOUT_KEYWORDS,
@@ -8,8 +8,8 @@ from app.services.domains.scholar.parser_constants import (
     NO_AUTHOR_RESULTS_KEYWORDS,
     NO_RESULTS_KEYWORDS,
 )
-from app.services.domains.scholar.parser_types import ParseState, PublicationCandidate, ScholarSearchCandidate
-from app.services.domains.scholar.source import FetchResult
+from app.services.scholar.parser_types import ParseState, PublicationCandidate, ScholarSearchCandidate
+from app.services.scholar.source import FetchResult
 
 
 def classify_network_error_reason(fetch_error: str | None) -> str:
diff --git a/app/services/scholars/application.py b/app/services/scholars/application.py
index 51c1490..49f362a 100644
--- a/app/services/scholars/application.py
+++ b/app/services/scholars/application.py
@@ -15,15 +15,15 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import AuthorSearchCacheEntry, AuthorSearchRuntimeState, ScholarProfile
 from app.logging_utils import structured_log
-from app.services.domains.scholar.parser import (
+from app.services.scholar.parser import (
     ParsedAuthorSearchPage,
     ParseState,
     ScholarParserError,
     parse_author_search_page,
     parse_profile_page,
 )
-from app.services.domains.scholar.source import ScholarSource
-from app.services.domains.scholars.constants import (
+from app.services.scholar.source import ScholarSource
+from app.services.scholars.constants import (
     ALLOWED_IMAGE_UPLOAD_CONTENT_TYPES,
     AUTHOR_SEARCH_LOCK_KEY,
     AUTHOR_SEARCH_LOCK_NAMESPACE,
@@ -41,18 +41,18 @@ from app.services.domains.scholars.constants import (
     SEARCH_COOLDOWN_REASON,
     SEARCH_DISABLED_REASON,
 )
-from app.services.domains.scholars.exceptions import ScholarServiceError
-from app.services.domains.scholars.search_hints import (
+from app.services.scholars.exceptions import ScholarServiceError
+from app.services.scholars.search_hints import (
     _merge_warnings,
     _policy_blocked_author_search_result,
     _trim_author_search_result,
 )
-from app.services.domains.scholars.uploads import (
+from app.services.scholars.uploads import (
     _ensure_upload_root,
     _resolve_upload_path,
     _safe_remove_upload,
 )
-from app.services.domains.scholars.validators import (
+from app.services.scholars.validators import (
     normalize_display_name,
     normalize_profile_image_url,
     validate_scholar_id,
@@ -205,7 +205,7 @@ def _deserialize_parsed_author_search_page(payload: object) -> ParsedAuthorSearc
 
     marker_counts = _payload_marker_counts(payload)
     warnings = _payload_warnings(payload)
-    from app.services.domains.scholar.parser import ScholarSearchCandidate
+    from app.services.scholar.parser import ScholarSearchCandidate
 
     normalized_candidates = _deserialize_candidates(payload)
 
diff --git a/app/services/scholars/search_hints.py b/app/services/scholars/search_hints.py
index b33cb1b..7c5cf15 100644
--- a/app/services/scholars/search_hints.py
+++ b/app/services/scholars/search_hints.py
@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 from app.db.models import ScholarProfile
-from app.services.domains.scholar.parser import ParsedAuthorSearchPage, ParseState
-from app.services.domains.scholars.constants import (
+from app.services.scholar.parser import ParsedAuthorSearchPage, ParseState
+from app.services.scholars.constants import (
     MAX_AUTHOR_SEARCH_LIMIT,
     STATE_REASON_HINTS,
 )
diff --git a/app/services/scholars/uploads.py b/app/services/scholars/uploads.py
index c33fd47..b0cf766 100644
--- a/app/services/scholars/uploads.py
+++ b/app/services/scholars/uploads.py
@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from app.services.domains.scholars.exceptions import ScholarServiceError
+from app.services.scholars.exceptions import ScholarServiceError
 
 
 def _ensure_upload_root(upload_dir: str, *, create: bool) -> Path:
diff --git a/app/services/scholars/validators.py b/app/services/scholars/validators.py
index e102eb1..38ee42c 100644
--- a/app/services/scholars/validators.py
+++ b/app/services/scholars/validators.py
@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from urllib.parse import urlparse
 
-from app.services.domains.scholars.constants import MAX_IMAGE_URL_LENGTH, SCHOLAR_ID_PATTERN
-from app.services.domains.scholars.exceptions import ScholarServiceError
+from app.services.scholars.constants import MAX_IMAGE_URL_LENGTH, SCHOLAR_ID_PATTERN
+from app.services.scholars.exceptions import ScholarServiceError
 
 
 def validate_scholar_id(value: str) -> str:
diff --git a/app/services/unpaywall/__init__.py b/app/services/unpaywall/__init__.py
index a1baa12..ecfec29 100644
--- a/app/services/unpaywall/__init__.py
+++ b/app/services/unpaywall/__init__.py
@@ -2,7 +2,7 @@ from __future__ import annotations
 
 
 async def resolve_publication_pdf_urls(*args, **kwargs):
-    from app.services.domains.unpaywall.application import resolve_publication_pdf_urls as _impl
+    from app.services.unpaywall.application import resolve_publication_pdf_urls as _impl
 
     return await _impl(*args, **kwargs)
 
diff --git a/app/services/unpaywall/application.py b/app/services/unpaywall/application.py
index 1258643..fa9b83b 100644
--- a/app/services/unpaywall/application.py
+++ b/app/services/unpaywall/application.py
@@ -7,17 +7,17 @@ from typing import TYPE_CHECKING
 from urllib.parse import unquote
 
 from app.logging_utils import structured_log
-from app.services.domains.crossref.application import discover_doi_for_publication
-from app.services.domains.doi.normalize import normalize_doi
-from app.services.domains.unpaywall.pdf_discovery import (
+from app.services.crossref.application import discover_doi_for_publication
+from app.services.doi.normalize import normalize_doi
+from app.services.unpaywall.pdf_discovery import (
     looks_like_pdf_url,
     resolve_pdf_from_landing_page,
 )
-from app.services.domains.unpaywall.rate_limit import wait_for_unpaywall_slot
+from app.services.unpaywall.rate_limit import wait_for_unpaywall_slot
 from app.settings import settings
 
 if TYPE_CHECKING:
-    from app.services.domains.publications.types import PublicationListItem, UnreadPublicationItem
+    from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 DOI_PATTERN = re.compile(r"10\.\d{4,9}/[-._;()/:A-Z0-9]+", re.I)
 DOI_PREFIX_RE = re.compile(r"\bdoi\s*[:=]\s*(10\.\d{4,9}/[-._;()/:A-Z0-9]+)", re.I)
diff --git a/app/services/unpaywall/pdf_discovery.py b/app/services/unpaywall/pdf_discovery.py
index 312bf04..01d568d 100644
--- a/app/services/unpaywall/pdf_discovery.py
+++ b/app/services/unpaywall/pdf_discovery.py
@@ -4,7 +4,7 @@ import re
 from html.parser import HTMLParser
 from urllib.parse import urljoin, urlparse
 
-from app.services.domains.unpaywall.rate_limit import wait_for_unpaywall_slot
+from app.services.unpaywall.rate_limit import wait_for_unpaywall_slot
 from app.settings import settings
 
 PDF_MIME = "application/pdf"
diff --git a/scripts/db/check_integrity.py b/scripts/db/check_integrity.py
index b8d4725..bcb2c70 100755
--- a/scripts/db/check_integrity.py
+++ b/scripts/db/check_integrity.py
@@ -6,7 +6,7 @@ import asyncio
 import json
 
 from app.db.session import get_session_factory
-from app.services.domains.dbops import collect_integrity_report
+from app.services.dbops import collect_integrity_report
 
 
 def build_parser() -> argparse.ArgumentParser:
diff --git a/scripts/db/repair_publication_links.py b/scripts/db/repair_publication_links.py
index 44ef56c..ebd00ab 100755
--- a/scripts/db/repair_publication_links.py
+++ b/scripts/db/repair_publication_links.py
@@ -6,7 +6,7 @@ import asyncio
 import json
 
 from app.db.session import get_session_factory
-from app.services.domains.dbops import run_publication_link_repair
+from app.services.dbops import run_publication_link_repair
 
 
 def build_parser() -> argparse.ArgumentParser:
diff --git a/tests/integration/test_api_v1.py b/tests/integration/test_api_v1.py
index c3e67e3..41a9051 100644
--- a/tests/integration/test_api_v1.py
+++ b/tests/integration/test_api_v1.py
@@ -11,9 +11,9 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.runtime_deps import get_scholar_source
 from app.main import app
-from app.services.domains.publications.types import PublicationListItem
-from app.services.domains.scholar.source import FetchResult
-from app.services.domains.settings import application as user_settings_service
+from app.services.publications.types import PublicationListItem
+from app.services.scholar.source import FetchResult
+from app.services.settings import application as user_settings_service
 from app.settings import settings
 from tests.integration.helpers import insert_user, login_user
 
@@ -473,7 +473,7 @@ async def test_api_admin_dbops_pdf_queue_requeue_endpoint(
         fingerprint=f"{(target_user_id + 73):064x}",
     )
     monkeypatch.setattr(
-        "app.services.domains.publications.pdf_queue._schedule_rows",
+        "app.services.publications.pdf_queue._schedule_rows",
         lambda **_kwargs: None,
     )
     client = TestClient(app)
@@ -517,7 +517,7 @@ async def test_api_admin_dbops_pdf_queue_requeue_all_endpoint(
         fingerprint=f"{(target_user_id + 83):064x}",
     )
     monkeypatch.setattr(
-        "app.services.domains.publications.pdf_queue._schedule_rows",
+        "app.services.publications.pdf_queue._schedule_rows",
         lambda **_kwargs: None,
     )
     client = TestClient(app)
@@ -1290,12 +1290,16 @@ async def test_api_settings_get_and_update(db_session: AsyncSession) -> None:
     _assert_safety_state_contract(settings_payload["safety_state"])
     assert settings_payload["safety_state"]["cooldown_active"] is False
 
+    policy = settings_payload["policy"]
+    run_interval_minutes = max(45, int(policy["min_run_interval_minutes"]))
+    request_delay_seconds = max(6, int(policy["min_request_delay_seconds"]))
+
     update_response = client.put(
         "/api/v1/settings",
         json={
             "auto_run_enabled": True,
-            "run_interval_minutes": 45,
-            "request_delay_seconds": 6,
+            "run_interval_minutes": run_interval_minutes,
+            "request_delay_seconds": request_delay_seconds,
             "nav_visible_pages": ["dashboard", "scholars", "publications", "settings", "runs"],
         },
         headers=headers,
@@ -1303,8 +1307,8 @@ async def test_api_settings_get_and_update(db_session: AsyncSession) -> None:
     assert update_response.status_code == 200
     updated = update_response.json()["data"]
     assert updated["auto_run_enabled"] is True
-    assert updated["run_interval_minutes"] == 45
-    assert updated["request_delay_seconds"] == 6
+    assert updated["run_interval_minutes"] == run_interval_minutes
+    assert updated["request_delay_seconds"] == request_delay_seconds
     assert updated["nav_visible_pages"] == [
         "dashboard",
         "scholars",
@@ -2404,7 +2408,7 @@ async def test_api_publications_list_schedules_background_enrichment(
         return 1
 
     monkeypatch.setattr(
-        "app.services.domains.publications.application.schedule_missing_pdf_enrichment_for_user",
+        "app.services.publications.application.schedule_missing_pdf_enrichment_for_user",
         _fake_schedule,
     )
 
@@ -2484,7 +2488,7 @@ async def test_api_publication_retry_pdf_queues_resolution_job(
         return True
 
     monkeypatch.setattr(
-        "app.services.domains.publications.application.schedule_retry_pdf_enrichment_for_row",
+        "app.services.publications.application.schedule_retry_pdf_enrichment_for_row",
         _fake_retry_scheduler,
     )
 
@@ -2514,7 +2518,7 @@ async def test_api_publication_retry_pdf_queues_resolution_job(
         ]
 
     monkeypatch.setattr(
-        "app.services.domains.publications.application.hydrate_pdf_enrichment_state",
+        "app.services.publications.application.hydrate_pdf_enrichment_state",
         _fake_hydrate,
     )
 
diff --git a/tests/integration/test_data_repair_jobs.py b/tests/integration/test_data_repair_jobs.py
index dc02904..1e65489 100644
--- a/tests/integration/test_data_repair_jobs.py
+++ b/tests/integration/test_data_repair_jobs.py
@@ -4,7 +4,7 @@ import pytest
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.services.domains.dbops import run_publication_link_repair
+from app.services.dbops import run_publication_link_repair
 from tests.integration.helpers import insert_user
 
 
diff --git a/tests/integration/test_db_integrity.py b/tests/integration/test_db_integrity.py
index b6dfb62..d510344 100644
--- a/tests/integration/test_db_integrity.py
+++ b/tests/integration/test_db_integrity.py
@@ -4,7 +4,7 @@ import pytest
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.services.domains.dbops.integrity import collect_integrity_report
+from app.services.dbops.integrity import collect_integrity_report
 
 
 def _check_counts(report: dict) -> dict[str, int]:
diff --git a/tests/integration/test_deferred_enrichment.py b/tests/integration/test_deferred_enrichment.py
index ff15345..14f5bee 100644
--- a/tests/integration/test_deferred_enrichment.py
+++ b/tests/integration/test_deferred_enrichment.py
@@ -8,8 +8,8 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import CrawlRun, Publication, RunStatus, RunTriggerType, ScholarProfile, ScholarPublication
-from app.services.domains.ingestion.application import ScholarIngestionService
-from app.services.domains.openalex.types import OpenAlexWork
+from app.services.ingestion.application import ScholarIngestionService
+from app.services.openalex.types import OpenAlexWork
 from tests.integration.helpers import insert_user
 
 
@@ -84,9 +84,9 @@ async def test_deferred_enrichment_sweeps_previous_runs(db_session: AsyncSession
 
     # We patch the client at its source, and also mock arXiv to avoid real HTTP calls
     with (
-        patch("app.services.domains.openalex.client.OpenAlexClient") as MockClient,
+        patch("app.services.openalex.client.OpenAlexClient") as MockClient,
         patch(
-            "app.services.domains.arxiv.application.discover_arxiv_id_for_publication", new=AsyncMock(return_value=None)
+            "app.services.arxiv.application.discover_arxiv_id_for_publication", new=AsyncMock(return_value=None)
         ),
     ):
         mock_instance = MockClient.return_value
diff --git a/tests/integration/test_fixture_probe_runs.py b/tests/integration/test_fixture_probe_runs.py
index 0e721e5..49f72f0 100644
--- a/tests/integration/test_fixture_probe_runs.py
+++ b/tests/integration/test_fixture_probe_runs.py
@@ -8,8 +8,8 @@ from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import RunStatus, RunTriggerType
-from app.services.domains.ingestion.application import ScholarIngestionService
-from app.services.domains.scholar.source import FetchResult
+from app.services.ingestion.application import ScholarIngestionService
+from app.services.scholar.source import FetchResult
 from tests.integration.helpers import insert_user
 
 REGRESSION_FIXTURE_DIR = Path("tests/fixtures/scholar/regression")
diff --git a/tests/integration/test_run_lifecycle_consistency.py b/tests/integration/test_run_lifecycle_consistency.py
index b74ec1f..7592abf 100644
--- a/tests/integration/test_run_lifecycle_consistency.py
+++ b/tests/integration/test_run_lifecycle_consistency.py
@@ -12,7 +12,7 @@ from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 from app.api.runtime_deps import get_ingestion_service
 from app.db.models import CrawlRun, Publication, RunStatus, RunTriggerType
 from app.main import app
-from app.services.domains.ingestion.application import ScholarIngestionService
+from app.services.ingestion.application import ScholarIngestionService
 from tests.integration.helpers import insert_user, login_user
 
 
@@ -214,7 +214,7 @@ async def test_background_enrichment_preserves_canceled_status(
             return []
 
     monkeypatch.setattr(
-        "app.services.domains.openalex.client.OpenAlexClient",
+        "app.services.openalex.client.OpenAlexClient",
         _OpenAlexClientStub,
     )
 
@@ -339,7 +339,7 @@ async def test_partial_discovery_exception_keeps_new_pub_count_consistent(
     monkeypatch.setattr(service, "_resolve_publication", _resolve_publication_stub)
 
     from app.db.models import ScholarProfile
-    from app.services.domains.scholar.parser_types import PublicationCandidate
+    from app.services.scholar.parser_types import PublicationCandidate
 
     scholar = await db_session.get(ScholarProfile, scholar_profile_id)
     assert scholar is not None
diff --git a/tests/unit/services/domains/arxiv/test_cache.py b/tests/unit/services/domains/arxiv/test_cache.py
index 1586a1b..0ef753d 100644
--- a/tests/unit/services/domains/arxiv/test_cache.py
+++ b/tests/unit/services/domains/arxiv/test_cache.py
@@ -9,13 +9,13 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import ArxivQueryCacheEntry
-from app.services.domains.arxiv.cache import (
+from app.services.arxiv.cache import (
     build_query_fingerprint,
     get_cached_feed,
     run_with_inflight_dedupe,
     set_cached_feed,
 )
-from app.services.domains.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
+from app.services.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
 
 
 def _sample_feed(arxiv_id: str = "1234.5678") -> ArxivFeed:
diff --git a/tests/unit/services/domains/arxiv/test_client.py b/tests/unit/services/domains/arxiv/test_client.py
index b51273d..1b8e6cc 100644
--- a/tests/unit/services/domains/arxiv/test_client.py
+++ b/tests/unit/services/domains/arxiv/test_client.py
@@ -7,10 +7,10 @@ import httpx
 import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.services.domains.arxiv import client as arxiv_client_module
-from app.services.domains.arxiv.client import ArxivClient
-from app.services.domains.arxiv.errors import ArxivClientValidationError, ArxivRateLimitError
-from app.services.domains.arxiv.rate_limit import ArxivCooldownStatus
+from app.services.arxiv import client as arxiv_client_module
+from app.services.arxiv.client import ArxivClient
+from app.services.arxiv.errors import ArxivClientValidationError, ArxivRateLimitError
+from app.services.arxiv.rate_limit import ArxivCooldownStatus
 
 _CLIENT_FEED_XML = """<?xml version="1.0" encoding="UTF-8"?>
 <feed xmlns="http://www.w3.org/2005/Atom"
@@ -160,7 +160,7 @@ async def test_client_logs_cache_hit_and_miss(
     def _capture_log(_msg: str, *args, **kwargs) -> None:
         logged.append({"event": _msg, **(kwargs.get("extra") or {})})
 
-    monkeypatch.setattr("app.services.domains.arxiv.client.logger.info", _capture_log)
+    monkeypatch.setattr("app.services.arxiv.client.logger.info", _capture_log)
     client = ArxivClient(request_fn=_request_fn, cache_enabled=True)
     await client.search(query="ti:test-cache")
     await client.search(query="ti:test-cache")
@@ -196,7 +196,7 @@ async def test_request_feed_skips_live_call_when_global_cooldown_is_active(
 
     monkeypatch.setattr(arxiv_client_module, "get_arxiv_cooldown_status", _cooldown_status)
     monkeypatch.setattr(arxiv_client_module, "run_with_global_arxiv_limit", _unexpected_limit_call)
-    monkeypatch.setattr("app.services.domains.arxiv.client.logger.warning", _capture_warning)
+    monkeypatch.setattr("app.services.arxiv.client.logger.warning", _capture_warning)
 
     with pytest.raises(ArxivRateLimitError):
         await arxiv_client_module._request_arxiv_feed(
diff --git a/tests/unit/services/domains/arxiv/test_gateway.py b/tests/unit/services/domains/arxiv/test_gateway.py
index 934c4fc..5d73e6d 100644
--- a/tests/unit/services/domains/arxiv/test_gateway.py
+++ b/tests/unit/services/domains/arxiv/test_gateway.py
@@ -4,9 +4,9 @@ from types import SimpleNamespace
 
 import pytest
 
-from app.services.domains.arxiv import application as arxiv_application
-from app.services.domains.arxiv import gateway as arxiv_gateway
-from app.services.domains.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
+from app.services.arxiv import application as arxiv_application
+from app.services.arxiv import gateway as arxiv_gateway
+from app.services.arxiv.types import ArxivEntry, ArxivFeed, ArxivOpenSearchMeta
 from app.settings import settings
 
 
diff --git a/tests/unit/services/domains/arxiv/test_guards.py b/tests/unit/services/domains/arxiv/test_guards.py
index 0ebe422..a869433 100644
--- a/tests/unit/services/domains/arxiv/test_guards.py
+++ b/tests/unit/services/domains/arxiv/test_guards.py
@@ -2,9 +2,9 @@ from __future__ import annotations
 
 from datetime import UTC, datetime
 
-from app.services.domains.arxiv.guards import arxiv_skip_reason_for_item
-from app.services.domains.publication_identifiers.types import DisplayIdentifier
-from app.services.domains.publications.types import PublicationListItem
+from app.services.arxiv.guards import arxiv_skip_reason_for_item
+from app.services.publication_identifiers.types import DisplayIdentifier
+from app.services.publications.types import PublicationListItem
 
 
 def _item(
diff --git a/tests/unit/services/domains/arxiv/test_parser.py b/tests/unit/services/domains/arxiv/test_parser.py
index f93d719..6ab0418 100644
--- a/tests/unit/services/domains/arxiv/test_parser.py
+++ b/tests/unit/services/domains/arxiv/test_parser.py
@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import pytest
 
-from app.services.domains.arxiv.errors import ArxivParseError
-from app.services.domains.arxiv.parser import parse_arxiv_feed
+from app.services.arxiv.errors import ArxivParseError
+from app.services.arxiv.parser import parse_arxiv_feed
 
 _VALID_FEED_XML = """<?xml version="1.0" encoding="UTF-8"?>
 <feed xmlns="http://www.w3.org/2005/Atom"
diff --git a/tests/unit/services/domains/arxiv/test_rate_limit.py b/tests/unit/services/domains/arxiv/test_rate_limit.py
index 69b4947..73183ff 100644
--- a/tests/unit/services/domains/arxiv/test_rate_limit.py
+++ b/tests/unit/services/domains/arxiv/test_rate_limit.py
@@ -9,9 +9,9 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import ArxivRuntimeState
-from app.services.domains.arxiv.constants import ARXIV_RUNTIME_STATE_KEY
-from app.services.domains.arxiv.errors import ArxivRateLimitError
-from app.services.domains.arxiv.rate_limit import get_arxiv_cooldown_status, run_with_global_arxiv_limit
+from app.services.arxiv.constants import ARXIV_RUNTIME_STATE_KEY
+from app.services.arxiv.errors import ArxivRateLimitError
+from app.services.arxiv.rate_limit import get_arxiv_cooldown_status, run_with_global_arxiv_limit
 from app.settings import settings
 
 
@@ -98,7 +98,7 @@ async def test_arxiv_rate_limit_logs_request_scheduled_and_completed(
     def _capture_log(_msg: str, *args, **kwargs) -> None:
         logged.append({"event": _msg, **(kwargs.get("extra") or {})})
 
-    monkeypatch.setattr("app.services.domains.arxiv.rate_limit.logger.info", _capture_log)
+    monkeypatch.setattr("app.services.arxiv.rate_limit.logger.info", _capture_log)
     await run_with_global_arxiv_limit(fetch=_fetch, source_path="search")
 
     scheduled = [entry for entry in logged if entry.get("event") == "arxiv.request_scheduled"]
@@ -128,7 +128,7 @@ async def test_arxiv_rate_limit_logs_cooldown_activation(
         def _capture_warning(_msg: str, *args, **kwargs) -> None:
             logged_warning.append({"event": _msg, **(kwargs.get("extra") or {})})
 
-        monkeypatch.setattr("app.services.domains.arxiv.rate_limit.logger.warning", _capture_warning)
+        monkeypatch.setattr("app.services.arxiv.rate_limit.logger.warning", _capture_warning)
         with pytest.raises(ArxivRateLimitError):
             await run_with_global_arxiv_limit(fetch=_fetch, source_path="lookup_ids")
     finally:
diff --git a/tests/unit/services/domains/openalex/test_client.py b/tests/unit/services/domains/openalex/test_client.py
index 5aab58f..3d8827d 100644
--- a/tests/unit/services/domains/openalex/test_client.py
+++ b/tests/unit/services/domains/openalex/test_client.py
@@ -1,4 +1,4 @@
-from app.services.domains.openalex.types import OpenAlexWork
+from app.services.openalex.types import OpenAlexWork
 
 
 def test_parse_openalex_work_from_api_dict() -> None:
diff --git a/tests/unit/services/domains/openalex/test_matching.py b/tests/unit/services/domains/openalex/test_matching.py
index 7d01d0b..f2da0fd 100644
--- a/tests/unit/services/domains/openalex/test_matching.py
+++ b/tests/unit/services/domains/openalex/test_matching.py
@@ -1,5 +1,5 @@
-from app.services.domains.openalex.matching import find_best_match
-from app.services.domains.openalex.types import OpenAlexWork
+from app.services.openalex.matching import find_best_match
+from app.services.openalex.types import OpenAlexWork
 
 
 def test_find_best_match_exact_title():
diff --git a/tests/unit/services/domains/publications/test_dedup.py b/tests/unit/services/domains/publications/test_dedup.py
index d2875c3..0820ecb 100644
--- a/tests/unit/services/domains/publications/test_dedup.py
+++ b/tests/unit/services/domains/publications/test_dedup.py
@@ -8,8 +8,8 @@ from unittest.mock import AsyncMock, MagicMock, patch
 import pytest
 
 from app.db.models import ScholarPublication
-from app.services.domains.publications import dedup as dedup_service
-from app.services.domains.publications.dedup import (
+from app.services.publications import dedup as dedup_service
+from app.services.publications.dedup import (
     NearDuplicateCluster,
     NearDuplicateMember,
     find_identifier_duplicate_pairs,
@@ -87,15 +87,15 @@ async def test_merge_duplicate_publication_migrates_links_and_identifiers() -> N
 
     with (
         patch(
-            "app.services.domains.publications.dedup._load_publication",
+            "app.services.publications.dedup._load_publication",
             new=AsyncMock(side_effect=[winner, dup]),
         ),
         patch(
-            "app.services.domains.publications.dedup._migrate_scholar_links",
+            "app.services.publications.dedup._migrate_scholar_links",
             new=AsyncMock(),
         ) as mock_links,
         patch(
-            "app.services.domains.publications.dedup._migrate_identifiers",
+            "app.services.publications.dedup._migrate_identifiers",
             new=AsyncMock(),
         ) as mock_identifiers,
     ):
@@ -112,7 +112,7 @@ async def test_merge_duplicate_publication_rejects_missing_publications() -> Non
 
     with (
         patch(
-            "app.services.domains.publications.dedup._load_publication",
+            "app.services.publications.dedup._load_publication",
             new=AsyncMock(side_effect=[None, None]),
         ),
         pytest.raises(ValueError),
@@ -160,7 +160,7 @@ async def test_migrate_scholar_links_drops_conflicts() -> None:
 @pytest.mark.asyncio
 async def test_sweep_returns_zero_when_no_pairs() -> None:
     with patch(
-        "app.services.domains.publications.dedup.find_identifier_duplicate_pairs",
+        "app.services.publications.dedup.find_identifier_duplicate_pairs",
         new=AsyncMock(return_value=[]),
     ):
         session = AsyncMock()
@@ -174,11 +174,11 @@ async def test_sweep_returns_zero_when_no_pairs() -> None:
 async def test_sweep_returns_merge_count() -> None:
     with (
         patch(
-            "app.services.domains.publications.dedup.find_identifier_duplicate_pairs",
+            "app.services.publications.dedup.find_identifier_duplicate_pairs",
             new=AsyncMock(return_value=[(1, 2), (3, 4)]),
         ),
         patch(
-            "app.services.domains.publications.dedup.merge_duplicate_publication",
+            "app.services.publications.dedup.merge_duplicate_publication",
             new=AsyncMock(),
         ) as mock_merge,
     ):
@@ -194,11 +194,11 @@ async def test_sweep_returns_merge_count() -> None:
 async def test_sweep_merges_each_dup_only_once() -> None:
     with (
         patch(
-            "app.services.domains.publications.dedup.find_identifier_duplicate_pairs",
+            "app.services.publications.dedup.find_identifier_duplicate_pairs",
             new=AsyncMock(return_value=[(1, 2), (1, 2)]),
         ),
         patch(
-            "app.services.domains.publications.dedup.merge_duplicate_publication",
+            "app.services.publications.dedup.merge_duplicate_publication",
             new=AsyncMock(),
         ) as mock_merge,
     ):
@@ -227,7 +227,7 @@ async def test_find_near_duplicate_clusters_groups_similar_titles() -> None:
     assert second is not None
 
     with patch(
-        "app.services.domains.publications.dedup._load_near_duplicate_candidates",
+        "app.services.publications.dedup._load_near_duplicate_candidates",
         new=AsyncMock(return_value=[first, second]),
     ):
         clusters = await find_near_duplicate_clusters(AsyncMock())
@@ -255,7 +255,7 @@ async def test_find_near_duplicate_clusters_skips_unrelated_titles() -> None:
     assert second is not None
 
     with patch(
-        "app.services.domains.publications.dedup._load_near_duplicate_candidates",
+        "app.services.publications.dedup._load_near_duplicate_candidates",
         new=AsyncMock(return_value=[first, second]),
     ):
         clusters = await find_near_duplicate_clusters(AsyncMock())
@@ -277,7 +277,7 @@ async def test_merge_near_duplicate_cluster_merges_non_winner_members() -> None:
     )
 
     with patch(
-        "app.services.domains.publications.dedup.merge_duplicate_publication",
+        "app.services.publications.dedup.merge_duplicate_publication",
         new=AsyncMock(),
     ) as mock_merge:
         merged = await merge_near_duplicate_cluster(AsyncMock(), cluster=cluster)
diff --git a/tests/unit/test_crossref_lookup.py b/tests/unit/test_crossref_lookup.py
index 67712fa..8b883b5 100644
--- a/tests/unit/test_crossref_lookup.py
+++ b/tests/unit/test_crossref_lookup.py
@@ -4,7 +4,7 @@ from types import SimpleNamespace
 
 import pytest
 
-from app.services.domains.crossref import application as crossref_app
+from app.services.crossref import application as crossref_app
 
 
 def _item(*, title: str, year: int | None, scholar_label: str = "Shinya Yamanaka"):
diff --git a/tests/unit/test_doi_normalize.py b/tests/unit/test_doi_normalize.py
index 84b0ad0..0b14294 100644
--- a/tests/unit/test_doi_normalize.py
+++ b/tests/unit/test_doi_normalize.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from app.services.domains.doi.normalize import first_doi_from_texts, normalize_doi
+from app.services.doi.normalize import first_doi_from_texts, normalize_doi
 
 
 def test_normalize_doi_extracts_and_lowercases() -> None:
diff --git a/tests/unit/test_fingerprints.py b/tests/unit/test_fingerprints.py
index 3965c8e..87c12ba 100644
--- a/tests/unit/test_fingerprints.py
+++ b/tests/unit/test_fingerprints.py
@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-from app.services.domains.ingestion.fingerprints import (
+from app.services.ingestion.fingerprints import (
     _dedupe_publication_candidates,
     canonical_title_for_dedup,
     fuzzy_titles_match,
     normalize_title,
 )
-from app.services.domains.scholar.parser import PublicationCandidate
+from app.services.scholar.parser import PublicationCandidate
 
 
 def _candidate(
diff --git a/tests/unit/test_ingestion_arxiv_rate_limit.py b/tests/unit/test_ingestion_arxiv_rate_limit.py
index 6f25796..68f2792 100644
--- a/tests/unit/test_ingestion_arxiv_rate_limit.py
+++ b/tests/unit/test_ingestion_arxiv_rate_limit.py
@@ -4,9 +4,9 @@ from types import SimpleNamespace
 
 import pytest
 
-from app.services.domains.arxiv.errors import ArxivRateLimitError
-from app.services.domains.ingestion.application import ScholarIngestionService
-from app.services.domains.publication_identifiers import application as identifier_service
+from app.services.arxiv.errors import ArxivRateLimitError
+from app.services.ingestion.application import ScholarIngestionService
+from app.services.publication_identifiers import application as identifier_service
 
 
 @pytest.mark.asyncio
diff --git a/tests/unit/test_ingestion_progress_reporting.py b/tests/unit/test_ingestion_progress_reporting.py
index 1567a42..ed470d6 100644
--- a/tests/unit/test_ingestion_progress_reporting.py
+++ b/tests/unit/test_ingestion_progress_reporting.py
@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import pytest
 
-from app.services.domains.ingestion.application import ScholarIngestionService
-from app.services.domains.ingestion.types import RunProgress, ScholarProcessingOutcome
+from app.services.ingestion.application import ScholarIngestionService
+from app.services.ingestion.types import RunProgress, ScholarProcessingOutcome
 
 
 def _outcome(*, scholar_profile_id: int, outcome_label: str) -> ScholarProcessingOutcome:
diff --git a/tests/unit/test_publication_identifiers.py b/tests/unit/test_publication_identifiers.py
index 745b62c..1ec44ce 100644
--- a/tests/unit/test_publication_identifiers.py
+++ b/tests/unit/test_publication_identifiers.py
@@ -5,10 +5,10 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import Publication, PublicationIdentifier
-from app.services.domains.arxiv import application as arxiv_service
-from app.services.domains.publication_identifiers import application as identifier_service
-from app.services.domains.publication_identifiers.types import IdentifierKind
-from app.services.domains.publications.types import UnreadPublicationItem
+from app.services.arxiv import application as arxiv_service
+from app.services.publication_identifiers import application as identifier_service
+from app.services.publication_identifiers.types import IdentifierKind
+from app.services.publications.types import UnreadPublicationItem
 
 
 def test_derive_display_identifier_prefers_doi_over_arxiv() -> None:
@@ -47,7 +47,7 @@ def test_derive_display_identifier_uses_pmcid_when_present() -> None:
 
 
 def test_normalize_arxiv_id_handles_urls() -> None:
-    from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
+    from app.services.publication_identifiers.normalize import normalize_arxiv_id
 
     assert normalize_arxiv_id("https://arxiv.org/abs/1504.08025") == "1504.08025"
     assert normalize_arxiv_id("http://arxiv.org/pdf/1504.08025v2.pdf") == "1504.08025v2"
@@ -59,7 +59,7 @@ def test_normalize_arxiv_id_handles_urls() -> None:
 
 
 def test_normalize_arxiv_id_handles_raw_text() -> None:
-    from app.services.domains.publication_identifiers.normalize import normalize_arxiv_id
+    from app.services.publication_identifiers.normalize import normalize_arxiv_id
 
     assert normalize_arxiv_id("1504.08025v1") == "1504.08025v1"
     assert normalize_arxiv_id("arXiv:1504.08025") == "1504.08025"
@@ -69,7 +69,7 @@ def test_normalize_arxiv_id_handles_raw_text() -> None:
 
 
 def test_normalize_pmcid_handles_urls_and_text() -> None:
-    from app.services.domains.publication_identifiers.normalize import normalize_pmcid
+    from app.services.publication_identifiers.normalize import normalize_pmcid
 
     assert normalize_pmcid("https://pmc.ncbi.nlm.nih.gov/articles/PMC2175868/") == "PMC2175868"
     assert normalize_pmcid("http://www.ncbi.nlm.nih.gov/pmc/articles/PMC1234567") == "PMC1234567"
@@ -79,7 +79,7 @@ def test_normalize_pmcid_handles_urls_and_text() -> None:
 
 
 def test_normalize_pmid_handles_urls() -> None:
-    from app.services.domains.publication_identifiers.normalize import normalize_pmid
+    from app.services.publication_identifiers.normalize import normalize_pmid
 
     assert normalize_pmid("https://pubmed.ncbi.nlm.nih.gov/12345678/") == "12345678"
     assert normalize_pmid("http://pubmed.ncbi.nlm.nih.gov/12345678") == "12345678"
@@ -117,11 +117,11 @@ async def test_discover_and_sync_skips_arxiv_when_crossref_finds_doi(
         raise AssertionError("arXiv should be skipped after strong DOI evidence.")
 
     monkeypatch.setattr(
-        "app.services.domains.crossref.application.discover_doi_for_publication",
+        "app.services.crossref.application.discover_doi_for_publication",
         _fake_crossref,
     )
     monkeypatch.setattr(
-        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        "app.services.arxiv.application.discover_arxiv_id_for_publication",
         _fail_arxiv,
     )
 
@@ -158,11 +158,11 @@ async def test_discover_and_sync_skips_arxiv_for_low_quality_title(
         return "1234.5678"
 
     monkeypatch.setattr(
-        "app.services.domains.crossref.application.discover_doi_for_publication",
+        "app.services.crossref.application.discover_doi_for_publication",
         _fake_crossref,
     )
     monkeypatch.setattr(
-        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        "app.services.arxiv.application.discover_arxiv_id_for_publication",
         _fake_arxiv,
     )
 
@@ -190,11 +190,11 @@ async def test_discover_and_sync_calls_arxiv_when_item_is_eligible(
         return "2501.00001v2"
 
     monkeypatch.setattr(
-        "app.services.domains.crossref.application.discover_doi_for_publication",
+        "app.services.crossref.application.discover_doi_for_publication",
         _fake_crossref,
     )
     monkeypatch.setattr(
-        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        "app.services.arxiv.application.discover_arxiv_id_for_publication",
         _fake_arxiv,
     )
 
diff --git a/tests/unit/test_publication_pdf_queue_policy.py b/tests/unit/test_publication_pdf_queue_policy.py
index e8e1a94..b88cb26 100644
--- a/tests/unit/test_publication_pdf_queue_policy.py
+++ b/tests/unit/test_publication_pdf_queue_policy.py
@@ -6,9 +6,9 @@ from types import SimpleNamespace
 import pytest
 
 from app.db.models import PublicationPdfJob
-from app.services.domains.publications import pdf_queue
-from app.services.domains.publications.pdf_resolution_pipeline import PipelineOutcome
-from app.services.domains.unpaywall.application import OaResolutionOutcome
+from app.services.publications import pdf_queue
+from app.services.publications.pdf_resolution_pipeline import PipelineOutcome
+from app.services.unpaywall.application import OaResolutionOutcome
 
 
 def _job(
diff --git a/tests/unit/test_publication_pdf_resolution_pipeline.py b/tests/unit/test_publication_pdf_resolution_pipeline.py
index 8574a5e..284be8c 100644
--- a/tests/unit/test_publication_pdf_resolution_pipeline.py
+++ b/tests/unit/test_publication_pdf_resolution_pipeline.py
@@ -5,10 +5,10 @@ from types import SimpleNamespace
 
 import pytest
 
-from app.services.domains.arxiv.errors import ArxivRateLimitError
-from app.services.domains.publication_identifiers.types import DisplayIdentifier
-from app.services.domains.publications import pdf_resolution_pipeline as pipeline
-from app.services.domains.unpaywall.application import OaResolutionOutcome
+from app.services.arxiv.errors import ArxivRateLimitError
+from app.services.publication_identifiers.types import DisplayIdentifier
+from app.services.publications import pdf_resolution_pipeline as pipeline
+from app.services.unpaywall.application import OaResolutionOutcome
 
 
 def _row(*, display_identifier: DisplayIdentifier | None = None) -> SimpleNamespace:
@@ -165,7 +165,7 @@ async def test_arxiv_outcome_skips_when_strong_doi_identifier(
         raise AssertionError("arXiv lookup should be skipped when DOI evidence is strong.")
 
     monkeypatch.setattr(
-        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        "app.services.arxiv.application.discover_arxiv_id_for_publication",
         _fail_discover,
     )
     outcome = await pipeline._arxiv_outcome(row, request_email="user@example.com")
@@ -183,7 +183,7 @@ async def test_arxiv_outcome_skips_when_title_quality_is_low(
         raise AssertionError("arXiv lookup should be skipped for low-quality titles.")
 
     monkeypatch.setattr(
-        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        "app.services.arxiv.application.discover_arxiv_id_for_publication",
         _fail_discover,
     )
     outcome = await pipeline._arxiv_outcome(row, request_email="user@example.com")
@@ -198,7 +198,7 @@ async def test_arxiv_outcome_calls_arxiv_when_eligible(
         return "1234.5678"
 
     monkeypatch.setattr(
-        "app.services.domains.arxiv.application.discover_arxiv_id_for_publication",
+        "app.services.arxiv.application.discover_arxiv_id_for_publication",
         _fake_discover,
     )
     row = _row()
diff --git a/tests/unit/test_request_delay_policy.py b/tests/unit/test_request_delay_policy.py
index f45039e..680e53d 100644
--- a/tests/unit/test_request_delay_policy.py
+++ b/tests/unit/test_request_delay_policy.py
@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from datetime import UTC, datetime
 
-from app.services.domains.ingestion import scheduler as scheduler_module
-from app.services.domains.ingestion.application import ScholarIngestionService
+from app.services.ingestion import scheduler as scheduler_module
+from app.services.ingestion.application import ScholarIngestionService
 from app.settings import settings
 
 
diff --git a/tests/unit/test_run_safety.py b/tests/unit/test_run_safety.py
index 81671d9..ac0c297 100644
--- a/tests/unit/test_run_safety.py
+++ b/tests/unit/test_run_safety.py
@@ -3,7 +3,7 @@ from __future__ import annotations
 from datetime import UTC, datetime, timedelta
 
 from app.db.models import UserSetting
-from app.services.domains.ingestion import safety as run_safety
+from app.services.ingestion import safety as run_safety
 
 
 def test_apply_run_safety_outcome_triggers_blocked_cooldown() -> None:
diff --git a/tests/unit/test_runs_summary.py b/tests/unit/test_runs_summary.py
index 14ea44d..2c224d6 100644
--- a/tests/unit/test_runs_summary.py
+++ b/tests/unit/test_runs_summary.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from app.services.domains.runs.application import extract_run_summary
+from app.services.runs.application import extract_run_summary
 
 
 def test_extract_run_summary_includes_extended_metrics() -> None:
diff --git a/tests/unit/test_scholar_parser.py b/tests/unit/test_scholar_parser.py
index 7c70dd3..ee3c3ec 100644
--- a/tests/unit/test_scholar_parser.py
+++ b/tests/unit/test_scholar_parser.py
@@ -4,13 +4,13 @@ from pathlib import Path
 
 import pytest
 
-from app.services.domains.scholar.parser import (
+from app.services.scholar.parser import (
     ParseState,
     ScholarDomInvariantError,
     parse_author_search_page,
     parse_profile_page,
 )
-from app.services.domains.scholar.source import FetchResult
+from app.services.scholar.source import FetchResult
 
 
 def _fixture(name: str) -> str:
diff --git a/tests/unit/test_scholar_search_safety.py b/tests/unit/test_scholar_search_safety.py
index ff21c1e..2bc5be8 100644
--- a/tests/unit/test_scholar_search_safety.py
+++ b/tests/unit/test_scholar_search_safety.py
@@ -3,9 +3,9 @@ from __future__ import annotations
 import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.services.domains.scholar.parser import ParseState
-from app.services.domains.scholar.source import FetchResult
-from app.services.domains.scholars import application as scholar_service
+from app.services.scholar.parser import ParseState
+from app.services.scholar.source import FetchResult
+from app.services.scholars import application as scholar_service
 
 pytestmark = [pytest.mark.integration, pytest.mark.db]
 
diff --git a/tests/unit/test_scholar_source.py b/tests/unit/test_scholar_source.py
index 179ca8b..654cb58 100644
--- a/tests/unit/test_scholar_source.py
+++ b/tests/unit/test_scholar_source.py
@@ -1,7 +1,7 @@
 import pytest
 
-from app.services.domains.scholar import rate_limit as scholar_rate_limit
-from app.services.domains.scholar.source import FetchResult, LiveScholarSource, _build_profile_url
+from app.services.scholar import rate_limit as scholar_rate_limit
+from app.services.scholar.source import FetchResult, LiveScholarSource, _build_profile_url
 
 
 def test_build_profile_url_includes_pagesize_for_initial_page() -> None:
diff --git a/tests/unit/test_unpaywall_pdf_discovery.py b/tests/unit/test_unpaywall_pdf_discovery.py
index 48270e0..2695fb8 100644
--- a/tests/unit/test_unpaywall_pdf_discovery.py
+++ b/tests/unit/test_unpaywall_pdf_discovery.py
@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import pytest
 
-from app.services.domains.unpaywall import pdf_discovery
+from app.services.unpaywall import pdf_discovery
 
 
 def test_looks_like_pdf_url_detects_path_and_query_variants() -> None:
diff --git a/tests/unit/test_unpaywall_resolution.py b/tests/unit/test_unpaywall_resolution.py
index 6dc7481..37b4764 100644
--- a/tests/unit/test_unpaywall_resolution.py
+++ b/tests/unit/test_unpaywall_resolution.py
@@ -5,9 +5,9 @@ from datetime import UTC, datetime
 
 import pytest
 
-from app.services.domains.publication_identifiers.types import DisplayIdentifier
-from app.services.domains.publications.types import PublicationListItem
-from app.services.domains.unpaywall import application as unpaywall_app
+from app.services.publication_identifiers.types import DisplayIdentifier
+from app.services.publications.types import PublicationListItem
+from app.services.unpaywall import application as unpaywall_app
 
 
 class _DummyAsyncClient:
diff --git a/tests/unit/test_user_settings.py b/tests/unit/test_user_settings.py
index 7897de2..05d8607 100644
--- a/tests/unit/test_user_settings.py
+++ b/tests/unit/test_user_settings.py
@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import pytest
 
-from app.services.domains.settings.application import (
+from app.services.settings.application import (
     DEFAULT_NAV_VISIBLE_PAGES,
     HARD_MIN_REQUEST_DELAY_SECONDS,
     HARD_MIN_RUN_INTERVAL_MINUTES,
-- 
2.49.1


From 1b15cc22ab96420c3b00d24eedd24f50d6a88ea3 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 10:58:30 +0100
Subject: [PATCH 18/38] docs: fix logo dark-mode visibility and add FastAPI/SSE
 to architecture diagram

- Add white logo variant at .github/logo-dark.png using <picture> tag
  with prefers-color-scheme media query
- Update mermaid diagram to show Vue<->FastAPI REST+SSE connection
  and bidirectional API<->DB relationship

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/logo-dark.png | Bin 0 -> 88769 bytes
 README.md             |  18 ++++++++++++------
 2 files changed, 12 insertions(+), 6 deletions(-)
 create mode 100644 .github/logo-dark.png

diff --git a/.github/logo-dark.png b/.github/logo-dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..a3e5424a20d134ca32996fe8be1d5f2b363f3208
GIT binary patch
literal 88769
zcmZ^KRZtvE)a-@?0t7;E5AN>nZi_DNu($_X{3DRy?wa845<EDI23Z`I;J&!a&0n|b
zueuNSVX9}&R9DZ`Je;ZNIguJb1x$1jbN~Q=siY{Y1pvJJ*L?>-{U3ngZK3`HN-ISz
zH2}bm9smdl0{|ZWg+lfL0547e;LscZ5Y7Mq2;FkpHAVkTAX%y?$O2x!$B*~?8=<)=
z8hil&KH&aOdjrVIA^I15@2R9F_x=!x6itw7=IUDl0Dyezr=#zwW#L2V=HY5%?*yjw
zgt&nzeVyF^0R8Z40~L=WL5$Tcyf5z}DWwhs<G?4TFxI`hS<FKjr6ybvjv88YxsX`1
zw_4jh60f5YcQf7E(;btLk=*N&8!*%GAA>sUC3*jSygsX!hlebg-w$?)EKH73$=>dx
zCOXIDPAP)hM&Hb50;1#bFnfM#;7e2OSH=H15X15t`zrN^{<BTs{$1<ZNn+}47z049
zDO2!D*Trdt99o0oXqFO@ExSMSsdP?>@|VzKQrzF4ff*sC{qLE1zfAb?1+lnQgp16-
zML1&c1hE9&gr3w9APK}qCA%BR_&kIS{sxehwBlLDc=H0&vU%M`u=9bgoOY8h_@9Y8
zLLxJG)KTaI$drChNm9;H+5GwwgF4Ls39%6T?>3$h@TOOqF*NqH5?j14?z;Q;^qalj
zW?7K2k-}H@?#=7|&;AL0G6`ahYMfv|UfjmtGnd%;8XW3nH_7*?y{9@&`ctuYnUons
z0a;mInyY5`G=(T5NZ1%dsZSVp-yUhZS14l}S2^6Ju{+(vasuCmYs<9l5^1;KB&B)S
zlelS3l1!iq-;6W)l8m2P<FUeK3qu_i=I`<B=ni?dw!1E)ABLt!j;D`vllzYiVr#7?
zp;QMrFC=j7j?odmbS5$bZ8UlwE9rter`r#>AOkuT!$cFDFBz<O-?n8{ur)%yokOXZ
zhAxc$9@izL2yrClhTbqqgArtW>}1#B9ma2V$mf7V7bH?Nkk#vM4V9UrdhaiBZDpxy
zwO^X>Q=cCzcB)nmHoxsB;nP=K62*1OM=P8D!a75CH_lZf<Yvb+t75nFy#1bj&X%MC
zo0jO5-5@$mX+VQ;`8{?pefTOy%X~+Etg3CNIDp^ApOk}*ltL7jS=U$hTcHBYnf@1&
zGo|^w-TH`&oZEi*FKU=@5)0Vk>n-=wyIvk_0?)YFK;k9j)aFk`tMu&q@<07L{t^V3
z{ow*wWuk}dn-->$obJ}@YxoJ-sw=l>_!Sv5++xOm?NLOLv^FkEC&Sv>AWn+Sj<74g
z##A>H-k4buZ4oQbbye#hmGHJLt!%MTS9$gAF{y1W9KessXJKpv1b7mths2eTskr;r
z)Utx;*h<Q|vr?P*)U=+y-~py$e#tiu9OHJ0?h{vcHN@~`=j6N_M!ZX(-c0gB;>+QY
ztU8a=r(_nQoEcUMgXF|Ja=KTI>E4L0<I9z-G%dm*Y+jXxLcaIP_bUi<<cN9az@--F
zWxaNX;!^#6emX}yLb;V8o-yO;nmED2R6RGi6ie;K=V{ZF1(vR=P0V*>{AThM{3dyF
zhbFF((X0&L+fs$9g-)^pwTjKuEEN4peaj}d?2Q$|cV3*De!(6^y{(w$uU$c3TlzAu
zPpeBu>dSNdN2i2vrl{c_*5Q=4R_+ot<oZFPymN;mD!)RP^S)WlLA3<$VB43Cy$X3H
zYh!@3s99Fa_IFaiA0qEpIMfruvl*kxdlkBBxPYFM3jY<1TWtJRGRp4dr@7kNUi1yq
zXHD`^9Tgo}zNbB*+TkutNdl^3UHN$j(2tS?SZBEzpAT8)427^=NG+CPnApjYqPamC
z>|;E87240N4Fi(Y8|dd;FO@zfd!C4+&wLRr5JgPZdH}^EHCQBPB0l{f9KEi0I}_f^
zf^gy-CW6K9Y_CEoi23l!E>e+ymXxUE>jsE@85@JVWJlG$rR^!dd*HmMm97Rrc?^Bi
z@wd~P5qQ!bi9`LPkFtbawLib|;Uda~^b|ZZ90YbBiz6GB?~HJFlG`0pKuJ@1lQmej
zd+Zm5?GCA_0a|+14N2;U6(C)Ys>;B*ic-qp!b?AI=BekES;ysB9v6^Kmzp28+&$^B
zqDKn9hzn}aU5qpHRDL}<Y@~a1p|?fV@skY=rtvj4<|XNLx|E~2JOKAO{~65VfCxPu
z<Z0=tdL*4%+>OYaieI?zxc>+tcC1)ECtUYG&4FL0i^K-=|7nuGvBrEUlze%gG@h7!
z`Elc4P65z)%ISMrTX=$ntvta00Km=3&CkZk&Bo28!zCch#V5?e$->Dg%*iRVG?nxJ
z5S(4D?QJ0ce}ZC|59L1s<Nqpn+B<{4cv}3+D*r1Ypu;I7%*QXx!}EVdq!57Kf7uP7
zBrB!kyL|k-RJ*O*x)}L9GQMhcVsa@uHJjOuSXFOtcPK~3^j=|W{j=s$==}SvXXE=f
zil+@d2_n1S>NnZu{rnrJX{7wD<)kDv+x}kP5kdXLhdEh$kX2Cg@M@;g!++M?iYU;H
z@p1B=uU~*5dLANd4Ed^N%R$3$YRo7t+dOYsF3JyrY%HzbqM-I%k0z!vq#eHw4GjJE
ze$6KDf9}ck2p4-XO6wrnl2~F|C{M}SS+}fiyiu(itmxrdWyp%%xa82{(dJ%mFx4c0
zR*wp3Z9Vn}Po8%b>hdhXCOM8%JUacq!wFnJa&k)Uzn=MXR6-s)GUxm5a8z4CFEIIi
zz4hbm=ZTMNgRTY!>O5GM&(B#!3ydp*jHVsC3AYLQ9JZMCIKf6hv5G@X8gAh&c+JK>
zFrRIoSx55bkYr0DI@j@=DXEbm(4)B^R_!&`VZusSib&ev6pZ`X8{(MQ75=g{vCQMu
z-C$r=f7k7l3`hV!5zw@+rb1j@vlP2s&k(%~+t+PuOhR3{5c&<fYHK<o{hvx2ExZHG
z%)#+#vHFfQ{l@z0)!C*`y}{oM_D)566j^F3UK9zYzE;;+1><Ym;=iHv^Vg)nD^1Xh
zku|A0xF6NZHVws9ZYb`>I1n^NyY4|%!m-f&sWk8EJvr0Bq39l?6`UI+*WImHlU~(2
znuQ)(DB+qp%^%^FCb9HukD_y#;6e29PCKx5D_`oVtSLp=hv4JNvtBhnEQ#0FfUD0?
zb8M+-vuV6_dpomm)PEgfJJNX@^`fS^g%yb^^bTP8o_aAOi8&26cicSA%t9KufMQnS
zA(u-nhU;vPy_NRV3NkR)Ijz>!!k>~lDMlBM=1#{E*_|>l!j=%8^AiEqGM21Vwv3F3
z()U#-OW?voZ9B42G!IQAlONgCUDZng=I_=UoA`zm?@ElZe;9VgUi-eGY@?rU{jIx#
zlpp|FhggscKWgcC+RAr7|5&f_tqQA*Ri(p6L~ko~jyxX`+FiKX4y5Y=4K!a<?^r_f
ziK8Cf98RD#ii7c3^)~i=F~B_c7jF5g49XzVRS)f>TwW|>NcC6wnWDWt^@_hq6L_hT
zT^}9bX&g3$CND?l|BZY}-<~Gu0<MyCd}%4iqOq{Q4Lsd6qJM58Wn#qKixP|!VgzhY
ze~(hj8oIlMp#ypyCt~REPd?CS0vNq-?Xdx)j1&2yn|ZPgzPjH4=6@_QD&KED%*|#w
z&4kk}A=#-o!YoqG@VY8vC5i8k-z^~nKt}%wR_^dHKi;aIF8OB5dRO2AMw|DBEbs!<
z3y=x~9jebu*PDkH6|4>SIq~?LbRN-A(E$}$)V`pL4~Dfj`9Z_Xw9AK`7LD0&w;UHu
zBlXxfQv|4rw8s;99>nq1TCtJ>apD(#53=;Jf0N1;Qlh;Kcp216c033)8Y=l_cyzI<
z(4<wQR=VU!{965BS37mtJt<V^1ZGpx@yT;&EESp4G*apEna=c|Ve{+5hXewi2!$sB
z$tFP`Dd<OKmM_d;A9QK~8soI9{MIyOz&DhEI%OgY+a`WVrzQb@F)e=@ks^lgtT!cd
zo}qn1zwuT9*|>o1YTVb7_L!9vJ_T!RMi@eW?FrwfRQMD$d_mFU1#=m=<$l3z1blJ&
zPn!)Zf~1y@WMZ<=fnn+?%aeyFv~Z~iW|BN!B&Oc{u#4vylL1ft8EflUG^@&ypdoad
zmYOV37E4bG7L!pUzI!atJ-)Rcl4-t`e_0htC7Z1}bp9wWP+oB=@*!9bD$e8kU#>U3
z4do0F@@#HC;QWRtR#8dh7Tb{*M*V>5$eRWIIdePT2zUpsDl-<V)~ahnp0QEm>*yp~
z?U~K;C2>ZzU*<L7JJ@)6ZQ8ico3o`EpGQcskz8~w$=QZ6U!7B@k=1h?UYV3dUo5Q0
z1*221zc<fncjM+n&lLd{%zDlm#{62ToZhehVNVFI9rzFSy9}H=)$oejP0dVNlB(JI
zDxKLyn{3iG`>W-u;=+kY%|K?fRnxO*FJMbd+WJ{sEiJj=0i^xBkq<mOWUq|9&HVMn
zEN-5*^^0A!CJuCq?sSEjRYR($LD<M(uuBvq*5f7f0NmFGoG{q`NIk$S$g~+pgDf-}
zRXVkLeWRq;xdqxqCzb@|K)ORUofnyfeef|upJr4wO+YT7GVR$!m4qd0U5TufCcBDj
zN{5&{keo9w?Mhm~gTr0ipj|XYoTl3V^n}OsXw!%o9=)D?RX~~&n8oN@TOf|4Hs0!7
zR0cE}z_Og-th`XO2eO=fb+In(RB&l>2o`<ZViP7tSa)WaUvQQAdwJB!^afQxyvfN4
ze|Q~})t46lhCmO15m9b6DgM@BDdOifXO;RKZpWolDcUHzZrdLG_95l_z;32`;F@e8
z4~<!ML7@uxxOhRhY62v{R31C$;LR{W)PYiDBpY$%uXVO}(;c5XfaW`MJ^gTjQt|Mn
zY>pAqv{3jNh8<nNeb@q^bzE(5tz7SLI`YK*jvcwiiAfUqaR0qimj*6MX6E5uftQ{|
zS}vzv`YzwVqip_1`=4^JZ_7~sM`uUKxvhmcH<aOr1BCjZ4RCS9+hDiZo3SA^v7V+Z
z+R~JhyA??q=kB6#qZm7qKNj)p6wX0<pBIxA9i6|(m(fDEI(fGm__wIJ*9@#&NcHT0
z8TR-yrz)bMbn8S}9t|#lSTT&hhSr*JifQS;RpI}=8_~Z`qFOcDJaIMu9`4BZERfUH
zhnfP`R0t-7l4R;QTn%U;JC|z#6i0neAb`d4Xi$K71An)&M^xuSOCN*ME%Uqzg!>4T
z7-isO<ZB-pL;#1|XR;<E@~#bdrPf8i9D-3KQcFG1)uZpP?jA1Ip{IEKQhQ2LxZUa^
zCf*Z<Gg~E77`;2j#q!fvp!+Y=yQOhDZuF_5rJipn4Oq0sEbt}%^VKr?Rd3Is^hm!R
z5corR<|9NujGOjDvG(_UTL-@JhBCc->pqpZfCWLO*h;&%oGEf|WR~CCcWJ?E9JGR=
z@H)|mWTz)QmdnL@Qbc5vX;jOQO-dU)3GN}n%RPoYIVy;1Jb#c>gq{CXgS=N#cb2i<
zx8a-91e1zYKDM|=2FP%B5TPp+ZjPm?Roin6Z;NeGC%btpeh|43kYUz=faTsNB|3O&
zr;Ak*0t)hFS7?S&pVgc|?WpET;wpY3S%iQm0aZE!y9S=*zrwx5k+>dbltmIe?|g1x
zE&ieGSxbEbzCJoaE@Z8|OIv1@FcCI`TJnlW%}{wgpv_~$`jT~e=e7VFkWA0fg1^%A
z-em{YaU6~nm!|V-$<E(0gBUd7TbetTMaAm@O>LNn!&Zgjr`i{3Cg&V!U#L%lp#C6e
zwB0O{p4Qmc@AsR?K#`{O+#TekgF4Go4B`on*C4gI!z8lJArg*VuUHfr;hv(NpK@d)
z1MuZ?SCbaMaO9YRXZ`8vy4AAyyR*kEr_AvM>E=D%^#FLcq|rq^=^g7Umn26-#e<A`
z($H5as;mzZ%W<52n_qFYrRd4q4r9DJeeXG=Tg)w+XwOvJQHVaiXu0a+*CSxdGwYso
za?LXyMhwAeYjf*B5wf(V)eI^Nb<_7t-VtTUy00mh$h6Gu#5!p-SrjoWCu`6Sg0hLX
z;7NiY0~n+Xd=#wBOo_6dPpze*i%{6}qxmZ$BKN-hv(*zIyXq^~yzU^BuDtbYsQzlg
z<U`Z42QQ<&9=y`=&m+~H<Mm^anT4YG7`Ie2SBB~tuiO(#)abl&W^`UBYo!K)Zi@47
z>v+Tgw$&5a^M$Pcf1}#$K~3CdyfKzOY<oU0yK%*yf%7ELyzHNzpr9w>#tJ@Fuop&t
zOjMk#3TyGYq@;Z4_Q`uBszR{E@~6i>9Py>hH!}Srd=yqrLg=^2?ZE6Hu*k6txUeNf
z*30Ug6yHb_L={w!Ee>gtH#m6`;8Ih-Pj;>BE}kgK<}Py8NL-Iv2xvrSDY)jE$STZA
z^J_q2AA1xKTTJOpMdL9_eI%G}BDRmyMRA^sKOC9`%YEG}!dN{_WUxvk$GGazCRcY5
zXA{AE%}t4yhRun9uc}x3W|=I8B2YvwL_f{IyEjlP#mhkM1wNBEo|{h2;3kG>t3tnJ
zhOe7%st>6rR#;w)cy=EbGpqAFf1l%}hL+OUJ1&O^G{4j;^5xwcG<`pmx8|`lC+<Gn
znPw_yKkR6-JS_Y5PV<0Zj5|3Nykx=dKTcHMl2Gv1ztUclpX1p9-c$kKQhhIzJ@0!=
zqz=ywEC12Ezhf3#65h+K@P!AV#OE_XvC%;$B7O5X=Ec(gEZUa3o@5fd7QMzLoRytd
zsU~p#<pypr)38}nGpUtedklS~`p6PZM?Zn20nRe^>SBHwh1LU##(w<O)lGeAj`>5y
z>{E__;w?OS>B`j-l0{t)S`Qvny?+g~Q!(80JBM?^tR>HP?7(HbN!E$p#iO|>4I`<b
z>n>ca2353$qLnfm4d5u2b0ki#cl1^G!OJXbZkBCrQ-{HSj+N7#YQm=y;M<^<?&E=`
zx&tmQCL%g9nQ)JpK)~oS2=l>_9<j5Nn0Pepc-dm&%`6xnNA?`Mpa(vQo1Z4F$m?JR
zhx^z}5OFN#mU)%a3|*_POy>nTD%FMC9BVf7=JG3wXD?pab-r{|xajGcp)HHPwq|%T
z6;|o3ee|WKS6Cc9ja>^uOmcrKW&K?%_VQ|t@#+zpK9q{Thb#iMmm2F=oQs~FwDAWw
z?WihuuWbkh<nk>_<KD9#giqzEj?Qp3n#U6c!}#RZhI{(A@9tWW-{SU9At$JRRh>ua
zJK&SEp9C&4jeq`H1KsFl?kY-SV`V;y#;J3%Xk0~GE11oS6w2J3)VNsp^czizlJ;hg
zo+<K8FT;gn1-*!;HnGSb`>*UWey_NrDrU{W1`nF<#MrprD9!6-e^%RkO4^HMOm29T
zUb*$yL<1Z)q(%JAt4Wan&gOpXMBSu;B6dDl<qa=g9i?`;9Pkk|Hw$WSFkZdhXggh?
zm8M@<MP{FdRYQSkrqM<lU7V^XKV+_Q-Ec^XTlt8PXQR59neEboG5B1YBziu_>2FHp
z3jP(U#91`OZtLRHW(ZtqNU0WtzyIOzK{CT`yy^gMq)OjD@STnETpIyA6j&<b{vsbA
zlg~WEkXTZZ$=&Kd(E5kM;;)$7{qumBn}j9!A_)Z7O$|6zijpJAi`KbByR(`yQp{dU
zxRl*?BjVz+uJ1g#Ui!4v1-Pg|N^V4}P-au_ha-*bNvBEJ*NP_po-`Z{mGzfBiENVF
ztB4l0bXY|kFN&SC0O{A;E*)f2-yv)nOzCW<-r}UcI(Z2oKLY0=RF3>H``Lu+Wf!2L
zU$lGOD(1=Wsl*<`8RFi}o{dTiGcX*oQE+T2d$vrGs?;5bt5+DT$Han)6r(mi01l(o
zu0Ysk?=^97C9qVyJ#wW9>{VE0x=NB2lO*x-{g~LHaz-OJa|K>gq>n6Ql=^IbZ9?k}
z4h%|MRAV^#Ur*a@sv@?(x1CFj8Ts5_Pl$z=jaVSddvyNEC{BfSmb>$*PC05|F%uI!
zO_RY+z8=Mf`{gf4@GPgsY|bbj+q4_9-;a8O2PH&)%5HhF^=Rsj)8>jNsx$N!n*^dc
zC;zZUHOyItare9&mz&HzP&#*lpPjF1_cq3vS)nSpgc2gU!O+rF+X=<Y_hu5x%2IjP
zrw2UxdAjrr43qxvI45SXIqq!A^N*uwHI48RXY!&lT&I(QtiHcg?b^i7r0!_0cMb5`
z$thzxbyuPSY|I6i#B*z@p7fsNS1rcj2FU^Y^b+5;5z~=M%~jqJ?+lJIPxaI0xk3G|
zS_aeQg-W=t-9d`%DmnUd%b9A0PN$;&=ZOfhz-D5`l?yW)k+D2XYZaS@T&4pjJ-2~@
zH8{oB^`z37C~g6iY=yk+2BaC}kd2y{Dx6+5fQa>eYjN;o=y*dNPefL?&btub^lJJC
zjumR`u1WMj<}bWFT8}?48oxXumlb?)s=wvQtlFv_v1^tN=Kjzw=ub*L&85fdZ{NV5
zegYxz?@uQ58fNJGa?NWJ?c$vsx9DPU^33nw#nPw_DUj0iPZw?W#qkn+`IcV@M=UwJ
za3g`s^Z_#z&36#bd^qK4n0sg2NLrd$c~G8%JU20cg%V#7q{0z0b-9e+Cam`U%p1@+
z$NDm=<SkuYd3r(^9*QTCv(F}Ufpd8)zx13T_ouof?R>?Hxp?tsrdbnz1dnm2uZF2g
z1x+@aXb(*l(g9LP8QhkuILe-P%Q!7(7ka^Kpapf+f^q=LPJfb?e>B&8!(Pj4<m$Ir
zCrZ}DcsCr0af~76xa*rs@AH(Z^3)bWJG%C&$Hf~Bj!g+h1adI5SriX_G={|`COYe4
zgBq`nLc2EFn&rqZH}S+$#T$xwf_$k|wV9Ir8Eb|P@szBNmq=7QC4H9O9W?299HO^`
z5dYGT^WoPoPVAMC!$J>NNegyVk;vA0&L?{&d}3Wxzo?wE{1uK!Rp8NDD82Z6h_=9U
zjKSoBj%-xB%nW0|={zcm>j@ZXeYr5o8a)=Hv2h|+wwhFIn~cZ}4h^;Q_fEVVFxT-H
zDFhqN6w{Lh{vfk{2u>^v{hJ261^SEOc_+qOCJ%Sx-SQVbRfu%+D%Fl{S`m9)Mx>*~
zE+#Q7ePTJvJe#BHQRZ(mtT|@%>mIF%5~;#hz+RKPK1iu&v!H8I$@z4A?oQR*^(VI_
z$5t*zmVWZ%Qj1}Qw3x8j6X-lG=1xOs2?1h1WN=7QC)~!j!z}*Hveku^{?jIMQkvg_
z>GUd$dDH#WNvZYHER}2o9SKP?M@lX5C+dS!iNEcT#K?i+OaBS9+jWPud$SpF9H<-K
zp@F~11cz)*N>nDj6aZIHS@Jjju2`$*>>`J5I;)nDFVQ}y!0emdYsdxz(%~LI=dmVt
zE$g|cq6Mw?R)a2r@_X3V6(bQa)@!>LXW~{yAw0Kv-iqsi^XzYmQ`|Ga=O|Nr$nEJ-
zaSa2$i@~*pRH+w6lqa(q+=LIRK7x${%QNp}Oo_Kq=YiY|Yzm=lq6(ivZ`b<i#sWu{
zALGD*-{gkXz}adq-6M>RuU;uF;x*9Uz{IRBUi$k^sjZnT-ALulRF6~K7ynD{n{6KS
zCm|)y+@^JYPTWBYnzNFOt=IJAkYB63Lk31QezrW^Mr9M9d-IMyUD0yU6^GS&xW&Eh
zX4j98+O|7QX{`6LUK0%G`J`&fv&0Vg2vj0dK0GoPrByBKkzOY|B;Gy(CmS{RMS78b
z07>C>4fz_08KEb=JkPp>Ddn9(dManIfkj6L`f76wdWyHK0`86m)<;j!S@o!-oC;ZO
zly(leER&ZVBinV{(X1G`?hvm!ntXpFcL<CYZVzHpst-1^r5gD%b*9-a>boL!jowRN
zGVl>LaJ<fBDodj%N0*6A8T{_hPH73)nf})Sca6%mFi49nnT$s>N4Fsc)fpava~+<6
zGA4Hy$nM&`ER>Sy*R@<<bojQe(dKrhE4zRognQD(-}=^vLpXM<?;{;%!anC1A#an3
zs>^dfRq|X{Q#0x(Iu*MjD3wc^#%*FgL8q)i-uL#**`pyN*}*mrb?g6FeRLqo%+5;8
z#bl{kYtLNwSK%a3OV9z2aWg?kjF;x=Zj;vBn8u2&gUBo`@?ImLX~p)J@k}$oRrDC+
z!*5`5Cl@?XR@q5ArQfEUen3+t;U1vcA~dn0r=2=LFVVl@2@!hNUsKWTsn(g}V5qtz
zXlQ2W`A$J0?q-x%)$)Ehp=7?y=p`wB3#Hj^Z`IFNWyU_-Axwa463i)`bNtflFMNBU
zP<{}XYYj*K5}>2e{Ox>d!1Ks;ILOh0L7(FyqUs{Z=Ygg&P;UY!2^LTDoCi5vkBoi#
zRH;}_`?eyQ8yO2$++Q*1W?a3VdRsS6`zOaP`DHxIKovCUrrw~&@*G%Yqguv+0i~K8
z@YrrlNIi3`#Y(aykAk3r;n6)!)bLRUhK^BrzLmV{Gv}O<!##XP?UcCu=SycqMVJ9c
z>&wzn9v(H51z!pp0BZ5yO03y!RqdD5vL4lY<^0uypd|ZUOikjI<cAw!-mS5prwe&x
zb1T3*qbJ+LuuD_gbXSG|LOgK6iu|EeK6t^my^BGa_O+q&Jc}%x6N<E*=*q+~6Z!+j
z2;5L4luo+1AGp$8C6Ju?idD+PICIsIn=*5lx6TK$X5*M2y%U3bSXt?5-uh+EB{VH5
zx>|{KX?$a7tC|x9mrw}mV)rHY|Fo@C6Plv@<&HgGr**npoN>g_CNWnhbIp$PTVM>A
zQRFuyvAq&*<QXvO-y_<X&jv@T!{Y`o{gl`%K1Lp5zOuA-O*GsjeqFArR#Ohh0++G}
z$6MEa;VGkgqg6afpuT$_?$Bv_VaU<2qp#OP{aD5<&JvY(Cv`5a)WKoXmU^@~xbj06
z7_de@rh2#H`?v8)^^M1)yoL_CIMY-TUROoC?CsJ!{Mzo8Obz2z^|7KTCE9Y*sLvj}
zS}&jV3OD{{IeDGeB%7FZeXyDdvLa5|>CxCd2bHch{8<FU!8j3EeiiG4hk9vDzTvsM
zqXdT)Bp<vbyOg_`@01$xAnD1~0u4U(1{jfmG*bn9Dqgtu_<e^HFy!xB>?O?8hL22-
zsqu&?PkZq;@o6|=c~6!N_7wm)1E}a5Dr4;e8hmhQE=?PJ)R{&&&%bVA?xkIXnbkPU
z#~J%`1TFj$5H+3RumygoL}!k(bI-d`+8P@-F{||%+z*B5y%lK$Y%KHvpGvY~nH{Sz
ze1S2ON+^4-X)7!i&Sv1C3R_)@1={%WG=?_kPF%$`Er`2}#rngZ$?=l~Uh185#r&Vk
z9ZZg|Rn?<6ti0k7c;*c%J1ADmJ#p+Ny5QC;Ex@s}Nq5-VuvzwtKW=rD_?F#|{Sr2A
zbn8aI_JY@uuwFs{Ss}BtWHnZl{h1QC+x60DB@WW&7#|mRlk$u8W>>q~MQ(0Jh@LPH
z^a0||Vul~5Q!(FY>1(AiFLS{uWZ+CLwYE+u5K0m}Q<Zk=n&6$m=cwCOcT}%G<<yPy
z7hYND&Crbd6qNa5TOdbsFoB8_W1;nZt&-DV3$X1|Z}(kP=NqcV_JW-19kir|xx69Z
z{wn1e7P&%~atqXjZyrAW>`M8$r)RNO*`ITG1fQP9X+8KM?j8G^+Ts&mMdh_@eTxnL
z=@ufxxo9M9y+O%;IF{&*q^HMJM>!Yv$2stOq$pR9+}*wk+S*Rjr@W6k6B-)u=!xZm
zUD`!%e*SIYtXF3PwrqfqMDb*@?qmB|+_J%FU%@ek){M~S>5r+dvJV~8rc6rPP+St1
z4t%cKJ#DE`oM#YcU2(9tA5D$K%tQD<d&T1C8FhtsD&q?`VP<LMGLr)dzL*Q76+?<=
zMl}Uq_RR-6r$5qKeRAiEDDIs?xrbB(^3&U>Kx@90aT`foOT9gn{RFGIuwYz_09*;-
zQ4*e@v&$xTyX~x=0>?1&_JYpo{H`FVZMW$7?@};pW!^J=@Cqo%F%FS*3uF>=NO{>+
z-_6`TG+a2nV&SG(@^+d}fzKQo@<E7cVG7{$pvt~ahVw?CXZ`qF>D$$TLlU8N`ETU+
zbMUY_8Mx|vSsX(Ebr0DSTc{{qWvqp!CzOzy<s47;9x0^ca}+~f%Ir_fpVqOfE`ILC
zCponBJ6ZvvVYo9XQU*wpJZQNC-rH(_vrDTR_87%;uVm$W+gm}+k@Mq9KS3|a{6m(Y
zo4g1_k3$^$s4MJBwHB(zxBlv^)M99JbSTKc)zviJt+~$VJm$NgO6`D6Vi-dJsGtvu
zpe5HDqc#$#9<-x>(~qe(gOa2@uxoEnS9RQ8p59*akY-zM5K!Iep>x6mLU)(D2H_@a
zI-QKRD(-%8AZVr*9=fkeG+(A+&meMd1MnsfD2`YcPd8CiCS2;I@;QucAH$e2LA^c7
z$Upa!(mIi~f+jA}SpMo`B%dDby43Fy0x$$3tW(!CN{-}BxVwdQ<6O6`Axg4sd}Paz
zhjJfygIY^wfv`tg_0`jSrO;8Lz<@S6bx1BZF8D(T9Zk8}&Xm|IzhYw$VA6QEc<tPu
zFZ)$GFSSZ0>#hBKYXQw%w|1M^$YOKd2!Z5v4f;|ns}gTx`jWUFG5iyZJz0l*?wNPF
zz2DeHV%r`}I&6Af*l*TQQ7IM6ZjHHhm3AO64V~FNyFSS(uB@H#WpnDmlDv?eb|>Uc
zEe;fpZ$;+PJXgBL%~TDJmxZ><U_dN!QzUkU7t6Q0Tpac0b>~ytm4Xo5Q|T$ug50yW
z-Oojh1*fDrY$B0TVR8$LbxIvEa*PlkiCk;8<;q}<GV}$bQvj<7g9bbU^#RwDBx2xi
zSN(3$BS3$ofgQSp7H#5jC30SIb6|Et7px9S6ykh_!n&3~CcL-IhYl={6gq8;18oHm
z?Z$A29(pzk-AzR32k_m>=3;o-EAN|u${spV27^fyl?$>hr0)wdb$e_+9}0j&5VBD`
zKt*Ig4w(&A=Z2c()sC_zrn06jAPK4<Zo*4QD|9lsl=kWeCx!@S2|HRdsoo6Ty~5`D
z#)v-wv1~dz7GCxa0uygc0?>BC0P&{P1fLmB*<T>|_;U1%A8F1QT)oc7MJLW%?F&r)
z=rOMvLB&$mgL_L|!VNc^r%Jw4Pd?-+)VTHl5{g-J4fn&<!gE*t*%1j9T>-F|!HeXL
zx%<hoaU4*zUPb11#UU|Gi6;Ztkkch_zPpZ&r$9Noe;#mcEo+cI+*E0;i8i}@{E4@O
zG&JNBfl@&i?PEuzS+)mq$en-mKa<M8t_)!AlUkXb=T&h^C%60~>xgTO;QI}E4D(mP
zXTdS0d)hVVtkALi1Bcn?!3T$OkJhJUtIXz@p2mE7#_BXn63?km&L~0Yynmy6LuV0$
zKH*uv9fzNUh-<&e$H5tDX{Sx2T)!iJ(x|(orrjvF%th@Xb@H(Es?Qjui7Ri-sFo($
zKB*{Z>b{|@WvW2mzOLyZm~EAPaL$&0L)k5N=-;jMA?)s9K|=Tfi0P#n*9yF*;dw@5
z;8507wYWbUj-bLv=|l{O6vfls<1al+HMDz{*v~>vEfsQZV-|0<PiLx_lLm|oWP5u*
z%I?&f0yNxpCfN5CmX`<9F&Z+LD`i*TqlxR*=bf(^@AZLh0xQZonD%uHoCvP3ERrqd
z-NFpegylOaLY$gx-1%72TTq?23+*AzEDbUyRcgKW!&r8BfgKp3;>Q=Xjqc0kwMPD9
zd3S+x&aCT-)fL*iM|2{z17+8i51~%Tyt<kc>CU;<Z9Z;05fWJVYG12#gAKYi{TM5y
zod-l`i(1ESgFijaJ(q~QaI1S&P%nwe(gS4a_WT@-UoOl*;>UGA>&eurR@?dh6Vx0c
zy#agSAp@46QM)<svWF8oQ^E7>h!nFXP`6P=s}aXP$8@Yf^;ZnL_3p3NWA{w%QfOH-
zr71}3XFsPx{GxB(2LpdD^5~7(WFs{V)`^~0TM(BbPEt%5h_Mpz!_taz-bYD@ydOP^
zDrh#(D&(8>p{froA(&upY?+6Nzj;3@XzFA?y29xAhvfnZU6w_%a?FbvD@*i`)Va_b
zvDzZ>bEqvrO`**_8fog+Zgg%<nn{n8RhoZBkIOt(YqeeQF!93dO7avQIb3@aMafrF
zW!5vf`E)}oW7iSq#@SBh7_W!0k2(P^bK$=KSp6;thL3KC)8@kA8nj$$svzjE=!^}R
z^L(suSZ*?1md%E-No^)8`6<g606skh5+h0KZaMG_2yK-FYN=0*ibC_B2nN+V8;&+D
z`4-W~g0C(&pV^K|_wQI}Dobql5{}AyAN`*xvucw~-e40*8$f<}XY(Rr&*C5=p{0>4
zKyG)Ppx<+G<H}nvoZ(0%AINv*lf$qdg87<wHjTTQSWeVaN7DW7y>ttNwRcy++b{FF
zs6VvX>@5=(P-tu-lT92IWU**GVvj$bm}<_j=62^NBTOBvT1D{c(lHnr1Cjd$)3P~!
z)aVv-V1Ng|0;9!EKgyXUaL<aD-$s314*be?)n6AiDFsr;xv(`j35<@DDa5O;&y9dK
zsruYQZ)_eP8<wi@4f3M=1kKNA@X}IKDIJ+T5k^INBhq)@5X20I(Dl#m=eIp*wy}w3
zAbAO$csn$%RlFH#&hwi)fE}-wWoutiY364gHgdVf=M(Ggv04N}LO{DY-aYMcJ<Y4h
z^iIct5dAM=ZX}8So~-o&yasmMFy+rtha^CxBBx}B>BLkWTeIwBIv)FB(}EJ_&8FeH
zb&~ww49ZvN&FAS?UB__^?S#;JJz%ik3Z3b}v>~05P$4ul)O%;&bufsr;fdi|K`VD`
za&JG^ATgz!4UlC|d30eGKYPSz`D4zGY=BOF$M^|2cq<cuD0GT0zC9g|R=U==%ku8@
z5w<{rCGZN(riVPUWMATq(02(aiLE2SS}9M2{5zV@^@=5^u5F2W@(ogMMCemhjNsW-
z*YU33?@*#1YL><Q__nC_>Hb8@?x{5LSHP5mQsL5Gl{SC+sSp2#SPFp?7LXFw^&FfN
z!pqUuG>rhfv!ShZrP`C{b;3LmjwRuON68fT98dQ^oQouA`X2RzfyuM|&J%kZR?KS4
zTPT8l8Y$r$$F1tvJF)WaPhJO3L1bf1T|6+7`-`^y(%iu$n%SqZKhraw8OMGWXHh?F
z{h#jLmIVHaZQIk8eJwunc*(0#>YUB=jq}Gd`nc5r%>$-k)87IU7DVEH#PW%!Nd|Ge
zhZ|8>+@lCAR!Q1lxC$pV1c*qL;%o)i@gJ%)7+0D%naa%I{=F3^YULIc$yx;R|F)L_
zVa=&xt#4=Yo0N}E>N0iQRxj?1fn1&8BhnXNyh}FCgNKG2E^`#N5QDydUDo?$on!DI
zAF2k{DK&pw$gudwAi)=KX(t(fQI{jTe~6RH%#{=t(RF=uR-_2K{B2<%Z&Jec1*^(M
z{lOaU#`RfRL+`Q(;jK3RqN1nUHDhR}+-2OKC8>eV|MtTDF03cU9HM*J>U<^zjq>GH
zzCM7cE7-hYTq$gen`g)!!<xi^zK1^f%y&>5e25!+By5s~fFU&F9ojc7^b;cuxVO58
z`1bP*=jad&%wYPfhyG87p95dVf2TGWtYAze^(LR2A~N-fBD;w6Zks9_Yw0FMtim?A
zMsOvu57{zvDSPEX`N+SItkphm_m}3`dEYZ3?9-_v-gD6ew-yDbrI#5}*p65FGw`Yl
zo|mITE#esp*9<<TzuwK0z9Y=uD8OaYe%U+Y+d=-Wt0YM36907BNu4J~(6{wSO;RMn
zh+by26!Rzl<Q%cHgf>d;>NH$Ogp0=uhA<ZNT=_HazQE7`4GYvu`_#2|ycRO#-?A^>
zdQ_}(JSldG$s5hQoqo%0soUOu`1y5wl+HQS-PDS!&(~A9B@9u>(Pd{A`DH{I$b(O~
z42ze{Ym#h%@+VZ4%GaJ<wuIO6;b^fg$oL_?U5YG5F8IU!dUfQSwOZT;hYQmKT?#Jv
zq4KVI?$#{9w#s={oR%R~3j<T3jmfW>zku(W^|)p&&#FH%#PJO8EN#K%(jU*<rA7W&
z9Te)w$&UFqKeaYkD>h6Mv~Uq8G5oEj>*ni4ks#K<_l2R2F?nxt6kzqmF$wsYWJ0yG
zqWs96i?NB@*IT7BIWsO=yC<UUPR4qC3?u(~5>BW0Kk^EPM^vBThL64jn2DZ^*FsMS
znv;vH`(alGK}ko{|Gv1<%nTRVxBkBJq4Jf>0T7?$+PQc`W=`DbftjD|!(Pa`NE6}m
z6Mw)ZaZ%_1rO-%Y0IC`8ddnv{z!Ku?vP*ysvip(jP0;sY8~xSj7J+Jo29w;}v-&PK
zLu;CIKbjIzxPbYp#J{u9ykCHWuPHL_ob{s;mExf$+3Nkw+;8**AY<3)u0C4FnPr+~
zz_D;aFOXEye|!%RH?5EAD4TeckG#euY$jx^f6EzKjh#msTlYqN3I1}=$+xjmJeRps
zgjfff&eu30n#f7MXjX=(N=CGQyZ>uH6E<q6WPi<;hp~EzpOBj3H6PnL4TXbcmU%Wi
zGC}6C^K@<S?NRAf*iP59Mfgzu$xfh!N)Mr}oon~ajFO%oIwjEZ_}wc0078~V-wlUb
z>%H-l00<qhqrBG8GQzDL&SRr6D>1JC>mE6O9Ah5S$yxvOB)Yo5jrrfmwL85LEuHpR
zmeVsR9PnwKIr4@65br>+hVSS;SwW9Si;$t7BDBC-=QiCHgQ%~M9=LumX=!m{mb1Fk
zsM!!NpJtkpj_0E;QeSnJU)YR=4me<IsH4%tb8M}`KR=Q?4~n}<8D|pr;|Si4P$-}h
zZ0K|id*E}&_~RNAyP89EGT<Z=GY7Z1?;fcw^cP?rF(M#0<(Bcf-hDkIugZ|)H)8?o
z`94-Rz$<z@p+>YzUBsIKZ?cMGNRS7|>VDA%ulM>09W=@E>Da#9JpcNt|Fg@scJ1XC
zs-u-AsjZHaUSLqmndjzV?oFE^MMdnF%rmlTIsIzfo@hO~<3F&!>V5nfzdA-%Qp3o3
z=68BH=<P;SF65Jpi6h&km$%>}`LchcVPybHEG()@?@k+d6Cj}_1VZB1!er1b8IFZc
z;z@*5z&1!}D$W+&fYO}>_$1c8^{kd-UHG6uB*M$}z83qIuHP%7(#lP}k&QYe%0#*t
zqc(gp%(A3AzJZc<vf1lObzVTV_}cQ|!hK`HT)u3$FH3(e%!wxZweLAkhaoc_r1|DY
zKck1UMxiP?30`M<fGMFu3AVuu82#r{+k;9M<`(1+2OrTHefJP^wv48~zNeYE3J1fr
z>D6fiF^k>Xw0OMx(jX1G^cpP%JetEoqBQSFh}`y07%9wVbH^gpOilt5D3|sKX|L0f
z%f7(L`!yrrZ|(2q-i#K<Afu%`x1_uqME9jy)en~Cy)$MLKl1PmnkPA59bdsewu#WU
zS+c;^5vP~)k91mvs;D@s<N&arntZWj(|zs<tggCy?NASPU(5Cq5WN(0Yv8_ga%P(2
zI|AdHt(Gq{&W#1N>N-S<FDBi@@P(=Vn^E6Kg#eYp>-z9SD;aX65bUh1nBRbpr7RJM
z-(@lIpf{B83-!LQc;CPEoEeq(R26{kITdjLF&TQ}aZl?X1KHE)4j(Qgi8jeMZ<_kS
zL$N(~?#2|ot*mSNdDocHhqp?&Wt~`aNdN5=E}LRGTJ&;Ows4AlpS=xx_Ud#TA0Vk*
z9vqk&%^2MIFFe_S?k0>WuyBX%a-C_(AHnfQs#i4Nu#ZqI6iHH_DyosG=!0dqUZ5aA
z+c>zWS>odgrX4M*_U2!C)S(||2>Q<gX<{_4*>pO$6|I0L#Xm0$e*;sMFf$AVdM$pw
zWFOERD4H}t3@0*q@48lz%hjF@X{8i3=hCnFuQQl?&vCB1u!0y~=sPX;t|fh!T|^EG
zl_$srkH>JEz3)hY(}NQFwFmkForySWpV0I8sVVX9oUzbTrZGPl{3vt})+Iz=MAd;~
z#gJeulcc2eKeo+E*Z=Oj?;ja@|H#UsrXE0|uK3}@;Z|6}#OG0=oJrb@eZ5^_ni6YF
z6wu9(xm(dUl}jI=YROFZ>l&KD22t4e#XYE)5p9_Fqt;agO!0&n@r;I&aG~(Eta)_U
z{H~@U1a{D@tdf@P3E~sW38J_M^@a_fD}{Cnab(CU8M7oIt3y6nzOHY2rCFlMp>Zt#
z&64X^dF;Ws$xscr+GS02yR&l?wHZ=Mtnfj)GQ;_Rn{1!Ba#)C|BysW64^SmM>-J0h
z+_Y<YsygH+KUrx(po-ax_;e92qNEsj?dq}Oq^;T4vE<H2AcJz>bCJGNq)UR^G&FK4
zgYrtS-Wj9KkUS-#xYyl2`=(N<dNzT_Tub||qIFXFNu0^Tp0iwjKAabthZEOMp_)nD
zBtLlc+45wQS16<*35!ssTZReIeAa3sS*1i;?RAimEXi3ML$O5Le#>!KnTJYpgMS81
z-_|30>qRd+mPc#U1PXV~)+84qYUd~W$rDudXex41SrN=Ln;iaF;@{k=&U^VjIsG0y
zIHlN|how`bwB1fvQ!U9;&P(_EevdlTB}wy`%rBHHXf0;W@o-SXDK@Bbv~RXd=c#e<
zoeJ!rq{8ZlQYWhCx_=6RjO<JG$xE_$)(S_J-#zzS`m5XPUCoA4pgmMU!TW=x$L2Ec
zjCb$AP>W1Y#dlvN;S8;LWwv6B4jBat$%-ErVXDZ{301`x=_1T@(H#K=o#d;U7>_u#
zbdQ)SD+Rff-7ha7;K4bX?d&7(5l@^1W?~Akg=hU$w;bHfHS76fgE~TpY5?0tQC{X3
zVSfu<Fz<+yr4+-I;EJJ82AUO1ne%Qg)!clDotelx^3~9^fieLDu@`|}VYx2chGivd
z6|X=4ap<R!&*DPSvelf9ANY{?h?}1qoYtCxeK;uYP5<1TTPX5U1s|qBrXPaiu!t?u
z*{j!WA&%^6T8KwN%wFfV*8$frc1aP-fT$$vc^53mvF*|_b?ck&Q<}7}Khd8)v9<j(
zgmxnf5U~vGi+$1*Jx{~w*sf-`qr9Az=Wj-8FlqAvsLC3%MfbzEvNPi5rYBsEVo6^A
zRh)9PTG2w{!vdoVhs`k}@#zj}D6a5sYVm7X3;vU<wuJ;x&NOovuxveOR+%U$J}{r^
zj*T*91D$JrD0LMB?~dgdn#Qmyx-Vc|!#n9N^6RLsnVMoBNp9-VZc|?4-Zd}R#dk7>
zydMVUkn03UgL0P8CVB4@{nOu>B=j@n76f5?U`rkg(cGbC^^Z^`H~(C}E?BEQ4s%Zm
zDv>blz>>d5k0#%7{2-TaRewUv;vL#R9NxXMw8fUYF-IaES{zE_-J;T==Ui{+tO8FI
z;N)_wV+l_W{tC2u)($#oIlK8zqd78#EGwoX8;nPjjZA6(s<}EAn`fnZsXociG^FAH
zK4b!)lrc0Hh;w`w1{M+003`@~*7_eydbRsLTjl{I>J$ZaO$C3kU{6SUOSg`@AFmeX
z_+nUKR_!z4-M87-S5r5r0t}o(Di&IYkr)k+L?_@=SmvlSx>x(y*kZRkhMw2;WDU)N
zcQ0~AsJ&j)`oW0wi@JVhZ_~^?@*0pE%Grsp#h7`wK+*W!2Pu|9g}S_ThQIqlFOel@
z*XIOrBL~G7n}C5qOQ3__y31_++tO54_4%|HlN<kN-!B>D4_<-<dN8Z%7^Rhwx_~rI
z4jS&vmO_d{dcgvWzdbJu-AuZ9`^KyjH5)={aLYv6Xyc|_OHOz|Xf4s|m>yuRn(ag`
z&!jJH+~J#N8oC)B;=hr*QF_2)UvPiK(qd>UhOk)VOa@0atwc`U+cfe=XFr3TCVq+w
zS}J?Kh!=j9O=1Ke(@dNn&RWESlrdak*7Vy>u*k)cTf+Pqd4H|;*_7pg!2OjiZjcH1
znQ*~>T2G)m#x2`=HY8)AZUi@afp75hWkIxDFmZquc%~%MSezj;kb{sb_V;bWs!MOg
zwY^bDuSmtU)-)~=_mP2TVtryyWy9}LkNVz~##_H$EM!`nPiH<ig*+jhCkF6@Uj~#@
z*#x<%{e?38h64hlpO#5Krswc3gzf$oMUuSm*(}7vH2zpJM^?zK57urCRuGZ-w;=(F
z3mpM_J^4q<u}nZ?9Ux&)(kRR>Ey686Y$earcxVClcpzP%+-uVSv5y!OC4{0F!b)><
zrdf_LSy`k^I>+O%xdcWLNnT8&^4ae~ieBQ-n<h&O+=YXF;tZNYD)R3j>R#TA?az4Y
zL_Eb_`2LDbN$(mlqFh=m-uzx6iX3_+L=Kt0OTOB+gG}lSPEbMQt$Ce0;5X*A5%kY>
z@52N5Rj8eiL7xDd?aaV#EajHJ2!$=2*|e0ixSFghQiYZ;l_2sql_bUfE{5RP287WP
zov+^Tt=j`$zB6`2{-={a_)=dh!<mS+3no7q*EBYZ)rb|O8I5C5G<}EGDiUgMKGcY^
z`h;GOFDW5RI|v-&@6Iz!{*}>zlITx9{M@YFE~qYh6RoG;hfwSNzM>eQjrvUOXCk!6
zZtbA#5hvCLQ{g>{7UPYIagyPlS6C#rx!(s#NtwA=(d=e#b`hL@Ei*ClZg%zIwNz-z
zeNy^&**PV3M~l{lSGE}T&1|zrAVwLNv=ViFcEt_eq28GA=4EuMgAfL?>*~R|pk>fD
zP}4+#K6EtQaXKOE8v4&ui4D^<a0)9qI_Z_8vX3l_`{B;FHUKxprgV`XE1->t4sU&?
z7M31+7{xUj#GEz%L!#MqaSpdg)jqSpT-Iu5muP55Ibv!w8D%3{hahD-)36GL!6m-1
zvRYTxn`LjXvIe8ToFk%EXnOlME=qF=lGND&@8o6L0SUL)aYyo+{><%Fl~##6*Dfxb
z7lcfF2i^B)l3=))QFK5x)x%NQg6!hEG-uJUu{d_<-~;1HMZs<l_c_8w`ME9obE<=v
z-m84K+fs%;7s<aj60_UXVmq};nKO(izt@V0=RrcgHaoHwZCQUM_J;TIyY!DCU`Knh
zNhS<;8sJ1jaZ3deldG#I?YmabZ9eo$X(->dINBUt58wyCiO|w(==*oG&E%;UjTUd#
zkS;7>f*!SY8ZB0z%@SC(o$(b)=e&$SWM3<k+q|tEFm3+C34b8|S*ZU_wl5A>zwmp?
za>oEnrgL30e%7w78CdC>v&)R*<213rHn^i16u{c1H|x_1bD(oHaepHznzz^WRjC>m
zZjO8YjA^8r^BN`o+CXBojVu0KCp`Ho63HUxYY*%(>of~n^gpKt{(*7n+rBRRTd@T8
zUJcI78wSLUpa37T+60h^rcEY#pI{=FT({E8Eo3q57IQWTx65%>+pTV`qAQ^#J8%1h
zq&1pZ08ZRDawQ(=Bcm#Cw?~@mz#a-2?ovLG>+A*hIQgv>C-aYu+*<S-*6f>-#J@f^
z4T|rpsgJ_I&AMGqOM+MF`#(}?s*P#t@y>6jld%gDi1#o^yNx;*DTSAX;MNe*xhnak
zD*p@am=v>8G@1fGq3)V8z$XeMEsUd0JvJrzj{<@xqgA|203vj8)W5kM8`5+OQOTI!
z)YJzodcJLw__HaWmfvxi|EdYG4AF9r;!iy3{r2?(w4p=ph^;5MJ6!lgZ;;o4@6C_#
z`kAXTZ7Jt8v=0Ew5K?z7V3xsVwf8yPdWA&M)zJ${a*jp*Bq!N*4rodX-fZj1^L>0d
zh^R?c9L305gz2I4Rcd03l)K)dJu-ytmF$0sV>SmKg_#kw0%*JBUnDtoqO-N4!td;Y
zm|Sr^s#(^BMvuf)M!1>2;U=aRT1GR*7ul;$Gzz&SsppR`V}o4xG+MuhQM~>imac*!
zs^@DjT}w-sh=6p*(ujaaiHfjvclXjEAT1$Xf`rnbbT=%p(p^g|NOy|w_4j{2z`b{8
z=FFKV&Y7*qY*8A$J*hXUA+~^jzRyu>uF}hzm;eL;=&V+F;(K+$d_fz{PK4VtGaJH^
zBu6UGaOR7{i1R>GYvG$HysE#g9@;9N2?YK;LD*0~<{ea7F21r6*Fea(ZyplK&tWXu
zlteQFvJE_S_u-S=pQi;+#sr67oiemnQ8_G9Gxd9}@JoIPU;j1e+EoufW+TP07|P37
zNG|m{RHs4|)VPPGl03SVyoR#u273$k6}?7jX@&`BF~RmW#L_ITt$MFj#$R!;_?J9U
zRUI!{bjs0ftowv0%(aG5D}T%>ZkVHusp}e~-tABgw9dwSuIM{Vk{a05@k(-qzUnjE
zi7gyid%UTTNhBWd<gKd47reLcgVcRH28tw!8n{ad2FW6~*)w%t27abm=Kd4^uwLXV
zQeFFvciiJHS!>8%8X_{*{PVGl{d5USL*2Z<s#4YK3LRM6ic*%Xe+#o?gsQ4p3hO|8
zh}H<Y$#$xYuq4fAED_(}XX(@JzY|f`J#Pau$o7g>Q&f6Xp6Xi*&YM{nTh$@Yl_!pd
zX|_%{{3loaPNH3Qeh&@kuWaNRE!Z4jR#w-*&(LtKdx#FTKjdVy$<r+~4Ss#u<dm-2
zj?;wIc~iy2Bb}K}wXXjcv9d$vJyFO`(mOH10~)m<QcS+KW6MEq@Qy{Zj5XN~g`XX?
z=&Ub4uIGeVeOzFZO6wk~27P5oK!5%5bOOy<Ve7u!idKcTafLVipkL>#=1I{<W#4_*
zZWeckiF2=OOWlf@0d*dF`&Y{JCqoNCiRL9Mbo+lG@Ry=wN`XcRQMRXbFP)N`>0GO;
zUk1$<-B_q1gl-1C>e;M=IKOG{W_skZAM6Tn23VL`r(8|*yzc9_y|ss^w2a6j&4W{d
zN^E~2-89CFHvA3;n#R7{r+0<VleZrXo<;jE!4Db5vVL^&zF)OTP#*PG2|u}~n)&d1
z63zo|e#`NtkMt5ZH+#9yXFvMK^gda~PIStHKHpS{H&f4r7?C+=Dm(iDp5_9td-b7b
zG_O*bqp01S6P*Od-OjWbepl@<ogcE`k+eHs`)Ki<vELHYy8Ry`vY_?ZcHBPS_DZp7
zrUQmAOcF1!>hc?2xUFJ(|6PXi*r1WHR!e+6%%NCgqy6E={&U6NeW8>r%>NeBKS{h5
zWg3XA{9$&unPVF@Q?cR1)0^m!_d2SZJ>p{~cbV?^NtWV#>7C)X=Zz=*uO_qdhM4=c
z$Le0F3V*l~*|8^&t!G~N9eVU#(Z!2o!yDWCK1M3TY<-So<=syq^1eS15?@uX%Q4)k
zs1K5~wX0DwAhtl-RNtqELmB(uZ4Solq)UCahRu(nhU5!sda}7J#wibaYyZSL)YdXY
z&x=hx5BAmZtY)|S+o3C++$KESrXvd0*)NMO&U1cK9w?NyKsB}9clA;<xA4j%cCYKI
z&W3MDJI-!(`}72bEi0Xv_Vbr!+*DVd3b?C#!*TmsM+u!Th7xo!#gkmrqJ*dv{Yw_@
zsZus-u^VnwhJ1ceT!eVdpkMoyrQOF=d6>-8@vq%@op{0zqitO~ccM0*)8E76rTYgb
zk<Wr626IE3Z$*dCpgyat1n6B3cxH<)D#WN6v?#wW;-|1K<Q4W>stnF_*ZOK6@Vn0p
zf=_Jw9oA_(WP1_4YSCSfh705<Gq;+rc_~#Ek~yT_L9s=+Jhc7z6@Ci3G0B$~c<w6n
zCMU2**`zo-k67$^yFT-q>lQmT{urgQd9wueZl%iGfoGd7)CyZL|ApAYey4ejJhqJX
zc<{M+zB-eIBX_t>mD>}><Gqsg6(&gAAj`}3m0FxvW?i$<Lm<4?pF_1|IPg7}<emf7
z>c&uN;@Y~LpMxPeaX^2o4lEvRI9qBWldVk7kk8NOCYzq6Oy}>=_o~?AvD}YpROhk+
zU&%i-WN~V~KrRn-6Ey#}b`e5<8_m$@os=t@aSJ13Xy&et<dLb(Xi0HX%pY>Y*O(Nr
z+$i_m`!>u_p5ok-fqE=%yqM_CN{udVlT#Ni+ZPkt-pN}`F8C((;aVz4TkEiyHPwoO
zbDqii;Y@YqQ6DMj9eDG7KCa~Bp<Cj)XddOjox*q*xpDGM*wI|9(;MyAgcscI^TfHm
z2e&je@Fs4@A~C~ZuTuu|LQ-1U6|S`$h5G)&>AC{U1CoO3wZCI`jz4lIYwjg;e+iB7
z_mH*h2p05M@k+j(FRUB3;Cj7%N>VbO8FE5ll-jEGe!4i9bb&wRswC4ndi9mLL)%9_
zO%M4P0;;0`yManU`DKxS)YJWzz&Brh4;?K~<)|v&d5AW^eeUA^vYY!WOS*;YYXJRA
zT0Fc>r>W<4L$V8RQ;JhlxSQXfpFh`YOZL9$voCP-n;YWe;D33~MRJZtqMUi8#Z}ed
zu*lq|og5M+A4y}CVVYs-RYO3Yj%9TAG2xu1$#-zGK~(JqJ)2?PDAtJd&x?amc!#uh
zAeUv0q~&vuZ0BH~qQ>h*(wY%`|FQ|%pqmjo&S&;PpZ)N^tn*a4Jx6O`e%<q9oK2_i
zvEtJ;ll%7Tl$LQB5^sjdBr6{r^o^>In(y_zJ9Hd%TyB?ozrwlQ_pLG%=#l(zdXspp
zt7zgSB&8+{A)&7uOD&-8>^ZOUqX0))n_gu)@6rMb@9cvk%Ttmea&Nx}l7|9ACDpUm
zrsP~b^`Zb3(Le=7&`YKt?HQ%I5Gd_TZrzV*HKe*4$nM}{RmSk!6XJ7NvRr0g=VAyZ
zlnp4cz;q|TZlI2xy4&8(*ndak*rW2*Zlb6M9lnoxRstE-B61C0PUrqr0{=wl;9Gu{
zp4T)WZFHKbUSCaZrkPJ1J*@Qh#E*niOOf!+s;tv15P!;w(!AITgii7t>Op`=hy-y)
zJbYj2xNdzqso<eOIq)qMluwH;;Aq3H=sTuScj_wa>UiP#&1h5WbHs-9aUD~U>Y=27
zimk`qW5+^ysdt+RZQKvUP`_dZaVTDk$IiHUMjQPmm`Z%ecFdLkq`|&*jgt5#szho7
zV=tCkW2s*5t-N=SnN{M0ol>8QDp|^Xg~P1u?*zvBtWOIQ<@U<A`;R4tehQ5IXzqOb
zTKE+e=v~@^$9(;WqNFBtOC?dh=VyA!_hy|LSBo;YSI;tQ+U^ZbZ|oms`_x*<q~*P}
z=>V;Tdx;2Sn5M!gA)Q*hZmD$!D3{_1Mz_4Ir7fBSsA&!lwr=bbl}xr|i6sa-`~%;N
zgpt&H7*o%I=+dUqL*69()8}t8hZBnavbaDu>3f>evXpS4N2LyErGt}QUzmfsGATjB
zQtl?NxIrhxg*QWTqvz>I!K%k!o#)xc1b;NGC961DM(%WtSNE}ZIK3Zzc?|wD*42)6
z>5>v=u=Yep9AR+i#>05xe3Nn4x`wgmAZRiOaz4#g)5<5bH7xM7Q&{u7Ic199Pg4__
zNpo=bu6L1le1!J9tCM#Ck3Spj)k9;ZA@-ijyI4fkbU8NkU4tf@=HB-Tt<T~i;%Dk^
zmI)Z_BCjH8e9zO(Gyc$TaI-fKLp45oq!Bu~B<H~f31q5&I}w1Z-L4dpf4Fy76~4EP
zu~|A@m2v&1<`v2mOi!Mi$On2fnXoAHg*~f&*z}YKv|E%i9pB12qyc&{kn6zRVE%-w
z1cxvim(dXTigltiusf*4dnhz&t3orYPK3modN7QtyRAj%tU5oA_d@XM&7XeQn~KP>
zd25EUdv5am5^w09Ec56t;utd+dFv_}>eD}6v5Teq!pb5SoJn<NfpcGQGmxCXq%Npo
zlfcL(1bl_c4>D}4al$$~-=o%d)!@_Vy|g8&>4U(wKcDZn3J$k3%ga%iXVF;FtfCA`
zba)Oby;Q#tBGX7+)5Eibf;h`fIjr8+cq&HdWc6ipo+R&4o{+t6OYpAv`}O|acX@)~
zrC_QKERm)sayZI+M@@Qv1#uu_&`Ouj1l+iqrFsqyO0C;64L4EBt*$wkcd^ta<_#W<
z8BZ4;f4|+}@NMt7^^2hluGJ})LIr;>dC5gk{>t(O^iEj>P3rVBmBI6c<ILeb-S8}E
zB8HIJO56F}Q#{am8AD94Z^gpR$b{X#&()Q|(Ss$CYebB}8X0>=;iTLPb-EbR#ieaV
z+2c^0!+N<Of1B!Zl|?*iqx}r+pwME2-!w(L#m)j5@84RT4*8j%)z@ZgbFd`yf-D#q
z=f8IBaJ?zQ%D2_&`qBK25r@^S$hQh!V5tmG{_;CuX^Q4VO8ko-p$=-bkCDhFM96;>
zO2n_)aAL9$FS+K<=$?!tg{0sruZ`*(^dz6U3@*k?@Ub3y=NfpnE$h57+94yY2!r|h
z={rtt3CdFj+ga8+NN&#mPI8Q@=y~^)?T2k0C_f^vzpnMflry!YxmvS(T?8YHh>d|c
zdR1V|HPP5D8?wD4V%P@~#kh5F&AVGdit_m&IJ3a>{oR?=2Y$3aM|Yb1PkvR}`Td~}
z?Dyf~<x$s!x}%=9){rj_1M1RGf$tNlRFNJtI-)I|uPd(n`4<9`(SvDfJO@u<MTt@s
zo21`*xy?_>a-7*z>e9>`D|XGyCd^Z@yxh~1{kyQn+&{r6?H6_t10QAR{I_|<8sQj5
zCmEhf4nk(ZT5~DJBI-EQS1<F5rcgDd%56KE$wm=k80qFBeY8PDC(iCUzAZGRlNMZB
z(_}Ri!auQIkE|tT8_PuP&!(~Td_N2p6Y(e%IiK{i(0rGX+M~IQ&2kx=qr38T503#1
zZg#3~S0r)^tuxr<EYUT~oiFA}4`D9z-)3%Tf(IC#gm{Wl3z}fY>hWR=Yi6L!y%E*?
z%*~f8$K;8Ts`xjd!=9n7=+OQh-+1rV==4)zC%~(QS#Ce+DRhizb`Xu(wr8m_o%`h!
zPc^es>0jg0WgD*?_~%dHS#P2X`nXqwr`AAkfdWn#FSa{(O)vA9O9WqIuT!e7U2}9(
zjqZjJQxn3_>Fg7+zs2V+abG#f9|!lPZMLwL0XHmA4coKXev${SF-+u9odq$+Ut49C
zYBnzFe%<|Vew#npC*)q7@Unq~&E0HczG&=+Z_2!^a)o|NI+Y=vhx$U<q>mQvMbzP<
zY_eEuv;4IEg@%RlKdG`sJ-gyI8nQ6x*PrTKC-rdGHCW!=-_V>!QOLNY=}WEQ9qGCw
z2z1HmrR6Tv;dM17g2omM7rQDywhod}Q;(8&Q)YGMNv1LUS}ijy0%G6VdJ!d}C?0`o
z=>`{@QEyPNKR@W9cD~OcVS>$4-#>r*ZHHsKD7Kr?h$M^qSgC>(S?3PyQVU9sc<ZN(
zIuaP5Z-Mk{Rl4QA-QW6!3G~jK!v^q=n)(<RPm-?uz3K>jny}&XPUhS)+vACFFVaf$
zCN0vT9&EobVd?or^pp#;`a)~FfX~w!CT5s|{!i^69^6Y=p0$=cR%BQCqdh({GukrJ
zY)>0-E&h&R<-S=L6<B(A$RG?*<}b<YGZq^b_YKQ6RX*1?Sv$b(9#t;d`l8ru8pvGe
zw(j=h$i_~~G1rfU`%d?-jint<G8<ag(1;rmsxsAGY?J}sB|qleFASGzBa%nkbG`~*
zO(*v2kNQ5tA5(#<-s1+Vpv$G&_-b>=b3QQ=*0KMy@|<U-^c@8#)3qjv81J(K!V@1f
zB+Ty2hI54XdtrRJP1si2Df?+SSmif?aVT;B<FizME|0YD<Sc1)-P0Mx>dhkph(HaO
z?3nBgYIgB<1<D70`_?V2s>T6BqvH=0qBOPP2hpK7+u0IW!CpYuD5p^2kunQ$1#9zk
zKZ0rHV};-g{WhYxtsinLe`^!BB*n$-Xh<4BNOk^$1re3J+{F!#@z|3A;)_I!IjUv<
z0!VAJC;pA7T=O95BO#=nC9Z1675oQke(WuXjndG;YPWV!P+7bS!s{BUke#h(9waIX
z>y<oo&-0VopvYV9?5=MS_!QU31Nsap{~59HNNOGGXodOwD6N$^X=U4i2<YNj_JhB|
zeK$Mu>8V_Vaw>IW%lPM4qj=TQT2q8qtD;jy6_^SEr3bCynxLnDHDspZPWTh3o=h&Y
zT6(@0xX@m|(6W%{cb&Kt7r4K4j~2?_qGuN$c)lx=gDrFNp`~@*n(-vt+rJp`QA-7<
zR4q2jReVJ3(Bg@P$H`ki;x@gHPy9sM?_GZ!l<P=9xnGWf_wMb`F@x)ObcR%8y+<ux
zome87K1ChH<UcU&Pg|^pT)(~f<S$FXP_FJ&G~eJXWgZj>v4SE&%8)UN%QKOIxk-;O
zwonSE(@&90>!ejTy=+;r=|8seaTSv+BY9vfyV|>{;(zrp@17qAlzM4D)A?Fu<UiyU
zSzaRe{kw;xmEQD1@vyGtSE6~E^g}mpiIphckQ2WP<mWBY%V|dpC?@Ey$tt(%K8m^o
zGQg_g7I#xjCzvRO#J*}AU=jOqOxeTm1lI!LVwUzMzT85#wgh!e1;(68^%kkHUNG--
zq5$eKk>0RA)6`M*68sG3H<M^F7nch6AKO^kAFJT}K@x$nOQQFyGTjlU@d`@tK^d%4
zT#!bYAGHV6L*XiSi+<H5ajW~_*ZEC`-+ivKlvOx|=)6_%GA;Wm=iu!_Z%0)hx&@Ay
zLC=xqxVLu2=W*yOOG*BH+}}8YPA!9PgdE90$mg%N{cIv6P2kzj*tDY`?J<aKS~?mU
z*cq)_md^i?B>xn?0=DPxJ0ZI~pBrV=IN|9)Cd@7C!b>t5{1Hd6UInAmT*7*4{;#g&
zb_AurvlG|9<DX>t7F20nHoS67-C46vd8bccadC<Tk~Tws#}2YsjM1qB3BxUT{&q1E
zMuW`q^VhV$;|0MRKq*nsmz`RBA-oK}BelIU@n=}G*H}83dHCugOUQ<$ZK4F&0IfZk
z`ls6@U*H3mtfRJely{Qm>J$rT^CoTteQmrw@eNOxH8qW&HXi7}ZJQJ0=G3(D)Vn=-
zV4CzG2>Pewh-1jFU}Uowo55;V5J9F4>7VuQ@r*zGRd=s0fJEGcF!^*6$kdFnVR#dK
zV=#y8j@s!-@z%vDVuI8eUSPC;&ICW(?N3I<<xy@pC1Jxn*2xt?0&^PmbNUw@za4kH
zQLl~DXneVA(~=FgC01QNSKj3m8)b8&Cp7jMpO7PbhG_M5!TL$w6<`86Px)SCpV@^P
z)BFU!edZTtg3hO89g;FU*F5iJ3F&#h+@=}+C=+fwG5hr;YzTbD?fN0c07>QF=Op3r
zb7hrZlqKREHsXDsODDBOz6Yi;5xCL&_6(E)Yv)*zVIB)X7Ux>Mnjb<BR#VQs>~g|3
zI$Wca7r5%+WI1C$Qh0wcq6ThGKi9S5D`^}9W<kJrL`}W8-L}gt%Te??!`MCY=w{Hb
z-q5~tGx}VfK<@NXNpxIl8NHgk9;YNE6n|oj0`$Y5D@i66>3y5&J{jv5(U)BSZr1e>
zfLcUtWN*-RAjx7zcFF(nSPx<c%v^_btYKflhOm2F*RpnV_J;#;E>2}>d{UQ|_H-q&
zf`1FUYH2tjZbJPpsANZxEsqzslKG0d8rM!-EBgY=XH_5b8otXlF9b1weLbKS#8l$&
zs%tDis7aKDqvOOQ>n!b=xlQ&5hK>ymE(iWlj(Dcmf#_vJ=?s>n8pUZg;I!j@&;Gc5
zHlRiPiW<SMZ74Crd8%&78nm~`XX%S>gwBWe*ibm?JpStI1Umm+l;|E}>UF=6F#nE;
zS#75ikm{XpSlM+gs%CE3Gf9th*NHkdBoB{sMe0MC+1}f0fKwDGOYCJ|=y@oeTZc$g
zfM8+u;S|lg^?E+~&%3hYNWh;{Shd_)(B+miYGu#AOUy1ru!zGVo0(c<GmlwzufH%G
z&TL%%El|ecnQBdpbFGd;R+$8_zXWFsx7Bf1=hgWSiL{$h;dqGWaddBE9KlA2?*|=?
zjx*F}WlfqtfVA%+%=EKD{%@XfWZ8&_4Btuy9ojD#Hu~P5tF1_wyqxX=|9M>mB4JO&
zDiS>wY>#2AT4${+$70r0v24e^F~jo7{CTxgIF6enw2#HwcU_iD_UG%B9*pC8nXK+6
z>%p!d+$r8Qp6@2YoZhU%>o`kK<}5XBX;V26$y&7|)S20+j&=c2D?Ysb7A*C-8-YW%
zqAuF+t~_rG+l1hsjnGFt9!zPvzdLi(vpcs-jIuGM^Wq=pw@44mA_2Ylv*LF=lnJZ*
z!Zz$q#cj6Z7D$tJAsG<DOS#hkuBG89gZu%TOny;FP`q@HwZBhtr(bKFx$(xuFgguQ
zTSEFV9!De2X*7P-$X|#}^;%Hhj?_%SP*=><PuX;9nN|x%auest;e%YS>xn=3Cx3M+
z;341OdqnAXiU;cR(jWO4n~}Rw_0VQ{)b5t`BDc2oXJ@b2#Laa)6Y?a#bmegG*I2`Q
zxg@n$qxSI?n3lx1#SO+_3Ar?wmuoQGU{hiMGCG94_tiF@@bDzF<$lC5_c&J_JC-cK
za6vxxYA|-*;leRgD?rf4@;F-X6GCVGF6A?+>jeMP8PW{tCESaQC7>793xWkgouruW
zYZJVj{6LXE(za8c^p(9Wi<*q3==z((>_FO?G~Szi*&YfK|5@pd9GaY$g1=HgYd`AY
z;Fh@oSKeb*WypZ*rO0bK^+lf%7J$@bNo^C_JG7X7Sm4A}GmD+(-*pf1U&->C(!tZh
zBfhk9@zUffUQhh`1a$2;*N-`f+FDmRaviuVm#cbl*H=T1natt$$NI5Tckl=oi%$pg
zkI_}{7UbF!YLZcCu!fF;bkS6t**__Fi~PrD5`6jxT&cgPWI3~KJTvg&Jyx(?{DR1g
z;+uF!Y^6osrygB>JB!Z*y1-@^S-|BnO|E^bL%i~Yi7H<?mE>77^i%QC-Q|bNji?wy
z-;wHG=6Lr+g6vII4G}|#I-JHeK@#A=S3dphGt>gH`-Kf@f*9DdQ4k{>i<adZKb9jl
z&$rLtF(!mPe;~HR0}0xyvrP{LrWOCaV-;p67gc!E`=OeyX!uC|TlMG44D0D-?OcBm
zaoV5+$fetdWP{BoX-&nNXZC_8QAal+z^7Qb{H<cX>@mIm@FcT{w0eo=E6|3l8vgZ~
zvCFwEJE-s~I=5~3&7zv*I_q@D;3S1Y<+q;@`cY=v&#@JTQ1oEDFVb`@)!_YX#TGT>
z)3sLGCY4-Fx%rdA?dhK}sKzVLbjw5xdejqCW3Q*ilt<90aP6>qAX4TEHthF)&V(*T
z>yY2*W-{En+E6yvjiu-X>cAwxv6rTFgLlYtWLt2tI4Z+r^%JY$ces(k)TvqjW!WTZ
zoc)o%L;=NPJCvvY<yXxnH8i<Y``nk7*=0Sm^~Q3gvRbc`Y?VbbzS33xCIkKM9lx;#
zgcA(<El%s3ROb)lCF74aNW~ia3>nWt6UxV}2l?xQf_-V%_#e7a9alH1<kpMl8?&QD
zs>!24yB8EZAbtp4|H+danilM9P4;J?57sxB<3fg@oloThid(%u-l$!9w^RA*`kq#%
zD(Bm?vA4aQyuE+35#}>U1jl5-8uYr9blNPvrVgIIvTM>D%U4LFp`7nA8gmclYaF|Y
zUd*3w@<&`Pt)XcG$3I={QV<)SW_o(Ag-wBBw=BJw`YR1G<Skt+$){||i30%&0=ee$
z3^pokRuZVk?b=bBWW745^r~_^Fbxk>?=md=4D^D~2A~6m^0G0=>q~F`-I^F_`Yoy1
z8$fDV^q3Zw3~jhiWojJ4SgC!UC!?SgrxXM45r({rWP$HLMU!*rs3I!n`Mbe5+<{e1
zF4^pxWUSf*S_`0xTc=p|MY|DtOX?E6Z<;zSDGhEOsf`K9-b}ma3H$;C7HvL4^FEVq
zX-kBweB8SN%~Ai&nKOkNJ5Ajd$D0O(ygyv9-**~auH|Jiyk~~k_)P4n40Ua9msfud
zTSu#|a?-FsjleE{4>z2CQ)>2FA+QfU=VUul=`9~6rD)zYL&ui&;YkR^EtuM5dYd!t
zkZ8{1ezabo4L$gKq>|iIZb>4!H&@Yj({_>+8+sZ!dzo|WismLd8FEdwYMoyPz;*ju
z;yO2(9sM*`JL8VcZnT8_7M-7F?>QQ-qm;`V$1xAyI}li8&`cpHQ>0mx;d_liS^dxo
zjU???bxkVoq*(KZVp!>$ve>}+1b~9Yhtt@Zc2A1ZHA#h5T-fWqNaL;Ub;Ul1bynSk
z=(lc@(}DX}(A1;QlO+^l&-IOP1PSC|6Nast#U(cyRZhlOwJWC+rqR$g@YPf`jeEq8
zQSrob>vYpZg={1p?^z^wZD&C)nQ+B`RgQZ7b-b~ASY#_oD4^49>X%wc;GkZh<t6NC
zi}af+3_`6U(3*8}ye3{blRss*X=0c%`ycbqW>4}}b`5(jj*e<O8ROlfj9qicxdo~=
zu5H=k(ej`hA{|@aOWQPg^A>}HhA-JSa?S^H2e}h~h<De%(;~9szCwG(&Yy7gS~`?;
zr*Ffq?=3=@=Bc>8_$aqd)UJ3>5K#xelG@+;Kc59_c1;BoB3Un8Gxq%Zv{UB>%qBli
z+Thm?E5E;vl0`9I>6*u(VYoD4Ej)PnT4X6FJx_-xfncd7t~~taGvPzzxxcIGI!=o#
z%9VZ&1>a|Ty2j(WL0xOrUJhNo{|3#z=VH5!V^chBw`Jl)AUfyEU69v2?w_g}htskx
zneNy;R^JpR3awEvH4S+CBNSF@R-OPggi*O>_}E7m){VzqR_SVfuH^6MHY=_=T~B;#
z(P+`|1i8@`lJ@H0YU;n6hpt31360tZC=VIJN@ti_Rgbgk6EE-8z}fx*K-^GM-C(6b
zdIB$n4L#$EpBtTJ0>^>m;aR5kt<%K1SNp&Tb$ZhWDpxD=zefQmV|HS-nZOt;gP6V!
z$vKXWXrqlq)rnUmcY>~M6`G)9+mabQWu`ei^xz#5NJZprt9YO^0ICz-8lWUlkbXR?
ztjbKKx8z(>8ysRcAuX-jELpMCf+|P;T82^@e3uHDIDciOOQFtNA(@J^Fp8GY?zi7n
zK_s@53Kh<gY|<5le;cEVQXN>vVwQ_~=m82xKikwzGv@Mw31@o$<qWJ_$mvA-%BKsb
zerXcjL_NPai;xe>_faS(YU!;*=I!%7bP{iXaFG1Orv7q7My@=|0`i%*GyZYIW_CXy
z5G83~S0T9j%RFM4ejTjSG-f;Yo1~qVP~q?_MR{qH5&?s=={xig9TVZQ^PiD{{PNJ>
zNc$`d)f0UTG()o6U4~#1$kkG2Ru*Dckt9!k=%{f|`+i%td3tX;JH<tXV*PcP^B}CI
z2L4a-HqYLoO%or5rDg(iGAX#?7HNGyXqbDNs_D=y|6$npVZqE8{JTjhbh;<?p_0(C
zH1vn(<IGcWp8$iuA7sT|x}cBHCL2B6nK(%tZ6lov+Yfe&BC4MCAZk@q<yw2GJ|D87
z$r`Vs*U@i2rfTYj@VeLRezz5_uo}FQ+7M`HLfEg=js*vPGn13lTpB2XB<Eqeq?bc$
za8D;qpl6Wb_sO(apuaPEppW&O8lX=dn2vqDAm0&z9;ZvUXmW!s@TyDczZa7C+5=P_
zM{146`FfBoKxqz4khWxm28zPX#{!kG-&4*$1%0L1eDvf>dn9Hx-}X3^4|QL1&uT+A
zmhnI&y`65&gahe=@VbQaT|@=Ov57S_A{3lXKF+q9$El0?c3OmAy;rcpO27Baf0Z<|
z>Y*9>h$+|yxC^+||7`Mj4UP{QKWyh;HV+UQsf)qL-lW!n^i<9LI}kECOk)658k^Xs
zi%zC)jE#~-iDz;nhWR!M=284+iX*x4LS7y8S_X?mB+*)ob?CcZ4$AM?Y5hgo`pa8a
zeNdlbb^(vW9@nov7taSnZr5}n10(^jd;KnOi__azc^zxKvL_#@{7pW~{F&(`Kc8;6
zXQd{u-^!>8XU$$gsFl+~)j)&qN4*F@u8Adp8?z7|5*4Kq3EhTnKUQw+q`FUn-%52T
zy(Or+VUTr=RBkm3SHA_*XoN`T8^pNXrJJD1HFesR>Cd+<J|fQN1~+JL>5_mYs6Ccm
zwBd+%(^Q`D7}x&tP!P#v7*c3Q`30_#9$k-IikBZ-jG7M-7_~IWEy{iQS=NRw=YKQ3
zv^dqnjXfznF582CH;1sSbPMMbSEF*@*Z)3l^SiIVyBmoncAdL=@(~ch_+79<hN^LG
z(DJF{a6uQss<PKs0!vu!15a=uaL>x)S#iZQUPH&zSsT5OzE8|mH}OZ;xdW9!owzaM
zy&uttu&t~J`i1qJ?G*?>v@~pNqHIF@TbQ%g6hWOFfK{r&cTcO%wL6It@&>L_am^F+
z_c|kprB-+KLgN8F>a2zv*ky?ovS%c#S=u(*B&by$Bd-b50i%csz&f&P_&9TYW|P{J
zHp2Med6S%mdm35ym=b@B9Ol$4*Vj3m&#`Hm{O{osZ=@@pR<w+}$cIdSGeFC~VX+7B
zgYr$I+FNwFWOnTA@YR#U)gEa3HgVH1TI#OI8>Tp=w;!};pc~%zBg9f`gn(#aQYay&
z4G0wwZX1(&WU0Bnik`PB8EC|nmg%Er&ttZqiN-}%EYDI`*bmd<LHS9SB{t2mtsTzK
zK`z)Y0e8!(V1@6RMWZI+kB5Cllu{u_mQ3Ewpz1?3Q{yPPOif()LbnmnknXQfI@uDE
zxMYW0a^vdzB%5(agM&3&#^&C;=lx`C3s_5CINd{AX9%nvhqp|wxj;>@_$?1wc2r5#
z*#M`<S#k*IK$6^fZU)9#4PW<4${eRKUB@rBTIZmpa^c%7sLZu=sitQK#o<<!N0^qW
z=(yt9Z_V}_7qJa}=7C{b=DX}V!q9%Js_bv>?Fqusal{dxysjAm^cI?vIr-x@oEG6I
zDWqQ@lCkPqE$@rHoD*D1T*V@*u5RpDkN^~g@6a5VyY^~j<t@mPY*hBy_M2Qa?=~qP
ziH;#&FZUDzgALjN$XH-Nu5sbKfIkvTv#C#=@i?7Al$w8JjVa%Cu-;aGjM6zt^=oFF
z(KD83Ad6*N0rUwKKTA9<Ub`x+{NFMz9uLd=8(>t^7)`u;^i45W@wg4GX{Wo<=_kM~
zG&HK|7hQCExz1_b$LUY-owc$b$^$Zjh${LrU#r#-*-{1%I=?`BT;@+EHSwjsWtBd6
zWYUN!nA1g1QXvhC5;A66=@NBDzhU!VTve=L@WDC*oZRxLHullIEE&<0z0@Rrs~DFb
zY_YZR@sOFc3bXuWdlvZ-g*i+u4BKR3F+J)z%Pn^<X|u79UO{wPL_jIUd+{_}bA+;y
z<?+i^<2FyFwi$_=dZcqtXX4nz%O5YA+&j!^NY*Y42}qu1ZT@`csQ$8plRBNp{O`9L
zP$``HyB~=it7Wp?a1`2WENq6^jrw>$NdE()`~DV5Nn<A#uS*hn+)v}eaW#CVratpS
z*JM=dCb_=DY>J^AYh(Z&7AABQK6RvhyL`4j?1RX80xDHT<Bm2kgHxe#+3yj8t#)b#
zW#ZjZRSl4wD9>Y~IHlx7$)#<|D_FNGKxAT=!|?afWNgvpWZ0V}%Bz5D-8oscIYBR+
zE#tCsHi}cImTCf8R2YU|b(Te&ALbSHJc-%gdWvcqq-ZyDp3M0&Zo`%dkbGd&qk!H&
zEP)XL<`4{;rQ`TnPBUL8GiYb*h}(c)#{lFR|KIo@_vwEN?T(wLVsN`=)){Q;_>X%~
z*$8KTLpDeuMTvcS^#O&CvS*1DlTF}VGgGh6cPtQ8;T_cvwmLy=>rh)3Y&L9Z-*a8F
zs6W|j__NocG3q+%z~t~Cnh=D6+Z+hMRVP%6rJi}DRc(j%7&basUtnPv6x*rf=x7#C
z31TB4Cr>7FKi4(k1K7Ao<yqv2u%SqtQXLER3AwC$n4c7iaL-}F8Wg)!7?%9X9dPjQ
zHD=R6`L^uX*g3BCGANT(toAJ_<7OEUEs#lw#}a=NFRdv%9j8<In<W!EV8`;)BJj&z
z8KL$Cr&X;bvmfn6pf+`CZSt{#>&;Dm6^0F=yYH{_m)wL_HT5&jG6FkKSe?JyEQ|eq
zkOvsSk*;SCenPRt`0IIe&{v)VJG19jKR~Z3*p#|3gc$NSc>k#GZ{yBhCsjd|6LK}C
z%f|ngpY@l3(_xzz0YlI(It7O0ka>#a6v%+BzT=X3gJs{FjHAnWZW7B_H2)oGs=4EH
zNp!wRvb4&WmgrC_v}I<wJ%^%{56^UfjF<<trn9G)HnHXt(*wOcVB~vM``HC6#XRtY
z*z4VN?*4!|;1~kxqy=AOV=t9IoP$z#$|;aG&I*057(si~*rg7Dg@$rLli<Ej8gTdi
zL4JPn6o@l4%^G}6+#0EXx|@wQ{cT|y(`v82Z@Yp{f(3%Hz$rirk8~$ou5MdKsyns*
znd>*vimAFz0M!9PHiKtIcLPuMSf~Lus(*W4vm6(qQj3$07awN_^sL=oVFeS#_7T9o
zH(Q|Pf07O515HtJi+vFl4|~$C@_m<x9Vd+FS0S9+Pkh+2@{F})zNdEP2Dnwfw{Dny
z#U(-izE^ssZaCO+KlB81k5vUK{Ncsfcl6+@-57}ucWs}<t64?;H_-~I-0j`dxu8!D
zo26O1QayY~sU2Saup!<{msBnw{Y66ZJp<#Ege)D-GQ3+iuKt<G*Mky^u?EB;L+n`~
z5@V&-4CDHqJZT&`6HgHbzEppMt>Kq?=^|KFI+@okRuk9nL&&=uR1<jp#CxHY#}wA$
zy=dE+mDx&#<L?G(k9<ZMoZPb5Tg`GD>ud5AIc*pL@2+(6j!V~Nz20oN+T5Ica7Ipc
zTsperL`P?l6qK}aT4uX3WI1SA=+R4_q~0IGOHjgOwNpJvRw53kGT45kEdC3CQM7Tz
zqTEJjNvNewK*Jehzdfvxx6Vm#%`iGQRW&-uPC4jFcdo5;8_IP!v9H3L%f)&O^#i<u
zUezZm3x0r#FaK2v?eW|b=+);uxrwu*JnJZh?6oJxE}_ZUChb#qHo~-{o7H1Nxo!z`
zODGzy^17(yg8c5^d+{AfMHNgZF>Z6)hW?KDGn_V>V)SVF+^3u9{Qc9>RK(vOfi{a$
z*+JCl!9(0<`|H%!P5oHF;lNUq0;F5vWP~~6*{7DJZ2@Op_c}sRK5XjrxT)v$nZ*^U
zoU9AxVty?SXpirB1Ni?Y?)wF;SM}rMXJRU87)qvlWSA!gWFyhjAaLl|Z)zZbl~~qU
zh<!R8505|2`dh^CT+NvzXQ4wAVg?TGtU2VZG{u%Z`ME(K5a`qbW#6nd2mZcIb_Gp%
z-ZnNWZJDw)8ho%XdryFoOvK>JT|L6A;hJ$~u!i5lWgiZ#pBe$ne|Fav8sBxNgg%&B
zT@BEw8?`WiM#DH3-q)YPL>^lF!@6SL^UK)&3Pj6aP_A@Bd#M?{)Ro@@78-F4?#V`h
z)0(=s@b~_Wd~!(N>G;#4)F#CFx>t13LBW#krWw8Ga{!Zj`HepH90$w>eJC<B4pV$L
z_fH_`V?14tGjP~%2&ai7s(y_9dj-}_VwTh<8Zm50Srib7&0YXj@fLs$PQ&vP4*%YL
zi*2JvOZ|lnQ<GoX<2i~hRzTCN#Wjg%xVOqMm%W3GLMz=;o&V82V00ArOPfIc5diWJ
zC!Owjh-nn9=iHcn;LGM#Wu&AN-9b(L5iX|DM-xqIG7Mq}r`=K;CjhYwP#}8SBHIMb
z3kh$7u)p*z^KdNylvFhqn_t@s)2fHJqN=V#B&F7Qj^-^eVjRVi92d2R%t*b}x#cY>
z!?17k=b>cSTO^=~*ryDDs})27bLkeN_5c`OqNRr0&>xiAKQb?z$<XtOsj=?})`_uF
z7rkXgm;Fe&t91}7*rfaM)WL5pG&!g9!SA#1((OS*>2x_N;EWiliv+|Bt_KO@YI}#S
zUqA?}OZ%w)!D&b3ov`phO_OC<%JC3<Ye$Fd#w@a3+fkq=NbL~E_-c@enVBNK=lN~*
zM(FyX*i)Tp+`(s0ziK<MvoTz)Dq77CXpNl`1P;NrcYoP7`vP%SS4bnUMiVsrpQ52#
zf*^?*f1y`MD3K&0?)&)&gXD_gaW?TW$t1DP4(2o2Dsh!J8SA|F(!TqqOeIa7I``_A
zf(n{^e}Felk~!QuoQ19)(>a}HCpa{#L@IZd*0TiKZA#*iL}u*lP*I@u5^(;eNVXvE
z^)fe^C{m4tUAlbWGC*-v3ikXD#0c|PCiA?%4q0^x!|^v8{fRwSluP+cNkFHQe@u^#
zUE_KtSPxLcXAX7_xkbGE@6@eyHy^V%_5z9q={9ug--$A=1`3$bMacy9^Bf+>BY?6f
zw?aHoO>q&I2R(?4A8baCyk*G%lpMpNKr>=e-TOqjv6r=d`$@}OkHO?Luwb<6N)9sB
z{ak^Ylt9H1u|xI20>%O}u3VxnhDspF?f!A!;brF-C5Zm-A0mLwTVA?l!wpabM0F#K
z%>A{%53pfN^prWvExC`#^BLiiX{y0wpt>yPnTCpC($D&RC=c|?7sk=Q^&S^;#?c40
zhLN!`SY@n(a2k6p+t)DtAo*9o0RbRwp8<U%_bfmd<X{3;1{d)`hGQN(Og^xugYd=e
zfGjWdPjca0!fFnQbn5eTOR7lmKCE^mIC37bQd|bWSK&<jc_g8;Pj|xoh=NhwtGq8+
z9*ws4!L$+Qv4+RdE_Nn-X89sx9Bcj#DA~-k_feN7jekXUK>*XuGS5bG8oOkh)6azX
z11Z`H=OmX(3dJS{>lBiyRbit3F(~<%h{d$cO%x|I5p>TIoKpi@)5DC$1MQwfXAX2y
z`rlE_!GZdw960^PQ@_m0+<)^zYnE&+g(CHC8hyJ`-Oq-x-#<oB`fXaNprV`70kexf
zv=}IfcwfU4?4=Kqf|Nw6r$N1H63h+ORL5LH>qbNk<>P?Y{0L20+QO1O3s!Em=#%E-
z|Gq3Mcc2!WSPNyInLoj=HY}0XCn0>417bHfe!3*h_Up@l6ahU_*t)Ubme;jlcNo~+
zz^(XT*r0i?OV*v#mUNkeSyQMS0}2al>B^#xS*@T$yP>#x_x^<1q)DEjtiQ7}Up0Z~
zY=47)0EiV{7x}C^V1bm9hb0=C2GkEvVrTuW!a`aE*610_i7w(UEJ!;^h|m|hi-V1u
z3qYS_)#L-Hounnt`7{10`|FR=nnv&{?Wtt{jmDw?5pd|9EGe}u!n8YSy_QRD6L=>X
zK-W3Y?H!JI2D;wGSZt#Bh1N{%kzpBcdFh@Flu8kd0qV$q<FG1#btC)-0&-9K0n~3I
z9RF;N-u6jwq%;xZBNhCVKD_G5f~n{+-VXIhMrkWu6XHAZKGw=(EUK*kElKf5o%;w$
zsZCNoUC%-suz^56jbHG0;O-}NC$xMXYHE)iGk!RC%UmDxnCoYP`_Mvl9SvY5h2IX_
zJDo6G!A9)g>sp7Q0pbUku2lU!>0_iZKj3kMM5!e33IT8m?b0<|)nHxU3-D_G4R;@8
zbP~Jj5;@Si$x!AX<buGDwQImir#Te=f*!oFIosz!e92QA39LE3@iC$F)vvsNfg`MK
zjzMX^v;j~=831R8@nFYNo0?Dix@j0<ri-I>_I7_&#Ytu)*hhlcA&6N66g`84M`mTg
zzh}K3vna*-3;~cxIrk)2)1lEUm<4w#jB0;C^?u`?$A_%*<_;4N#MUqFh@e-cM?Rvu
z$>b9s0ZRko^uItcb-)Ju3>-BMX|`@R(Y<a=h>O!sK5H%H*4M~1-n~k~_~S?cQd4X8
z$S_S@rblucA9IZfAn4uyf1)x$`sdIM8Sm>5cBu^>V94}-*zelryr?au%Vv4eI$f6U
zB|HEvoP~aycJ?~6hr9agKO_f)c{+2z%+8r);F`>p&k(0RxZ1#8&hwf%XgX*DAFVS+
zYw8Oe4B&ZOou<y&Yzr|}?*HE(HYvMx!`PaQ1DZ=~0!(ujoxkFq%q3O(La{*OUHRN<
zI(vEM#CH&cNc$SS-~6Z(L$A)iDJF-rG2L_$w4<;aU}F+{KOOPElJSAARq*^#XtGtW
zAr#&Q_st`&pM(qmWpN%MPb9p|18joA@sxh+mE-u5`}mfn4W7LDO6I25_`n}*<zu4d
z$H+%QQXyklmF^kj^jjot+s)7aeJb-6tj{mkH7&1kz<s4gW%YvCCU{>4l#Bc6E<Syv
zrdMXnJ&_MG<f>8g>&3>uomTiQ2aV6C%RX?E5zt@R#bRHN&VY<Tr868|`C(n$XY@#1
zs>V)^F*iNb-oFe!N@N*_lG+v!YebL(I;5zA*n|n84-l46-$rx{cG55IrOslJkRGh|
zO-yU?_sSc<LIYexy2@wJ{LnoMs7MwHsIQ^c4$$i)2W9(r869^PGzf#jcny7l5K|UM
z0D@xt*}~jEC_}4`nI*ZjB}3fU$F)-Pn~}a;4Sd`HY6XQ(1c%VLNZt93)MWK!Z$Cjb
zby8f;EF}InX=+c({0F3gLM-;yb@HrA>3k1?$NQKzn-ZHSacqfiux(v4S!MA7=-8Qv
zHSO=`|K{0-Ee+>>M4i!n^(PLnbIu4pKB^{up@|0E3QH|FAaco99r-7F6W#hI)Y&6f
z=D#QKYx*4nw<(EX-2k~=x1xT=94fc+x>I8$Fx@l)LJ7bD4c8FWdqOX<W#j+-EDFAx
z47w#GGv5u+HB=kp2o?uQ<iO7(_GVYjBVehJVNzb#&(4sd|HY^c=O!d*h<ItUW{<6L
z2scJ6w_u6~gv}<(&^#gt2eg?F?gmI5ga4QwFjYSV)`)_-j+)>E@B2?MBDSnCghPNz
z*zF8cK0gQotMZITdB<$$Y1@B4Why$^=$fKq!_Vn7B@J*~Nm;NH{lf&}LsgnUt&e4}
z>;6&kjcg>D@fnt?$L?=~fd3v7ju`z!s&IIWv3e$yaNV2g=fFQLE5{3>KGgUdn^kQs
zMg{5PYwT2^Odsd)``@w?QZAmu`ph3v=%ltO=+0@(nsDwubAy0cN@f%S%0g-4&qRz}
zk}QEow*T9jHhROso}xaT&ezgnurAsFC2H^|T(km^3A!}U{W2Ih<{EG82GmQKY5h|o
zW2*UUKruX4)w%<{y(XiCTRhljv}i0=x-T!tMQN%@eP#(qPL%S{4!tQ2DXXi44ISz}
zs^>u*+Bizbf1t;Ryoat^KP0W5r30W!1|yXkrThqFm0>9sDGqGmbx!zxQAt{0T=8dz
z>OPVz-Yf?J3^2`jSEtpCVKmSXF~Z-CcbOB5rrZ6*$-El!P&X9Jj7=$uUFX2x^GQ)+
zq_&UOVf#YfB(7K+eBB9@uCOm5Wt`_NdV_1;=9~6N)p5IiQpnztn1yu9TmtsrHb7m?
z%$s7?A9q1#Iyf^ZX6BGA0q^ILLUazbLu>&+W)|%1HtEGxzGE79E%K*Zq`;d(_ooYK
zrcDQ9<SkaJclMg}a#I>w?U+@6=%PR4=0|W7jMQ}+S?$(jL2<7M9nH}(uFh*&KZyRU
z(e3Uw8>Gh$kl>!M3?7Yj3j)q=(iojq6fYnq=lKj-9})B%y5<6M4j9!qtVNksS*BEH
z4&*=Dyqiv1dq5XS@ZTgaE3fOv)<35Ke9KNlab>5MuMy)Vx7^4GE~0d&8O;IHxvydJ
zv+7tg=D9F0Aq2M{)GBp(-zvnAyE=;q&fR1k+w4)3Vfi6WF(Hx8{2h?;M)CPzeHejo
za>lbH?H-wt)pg<<3hQ~e|K!D_jUIe(x;W&+@*$~yd3C=;mj71-w!VXaNfug9Zx{qa
zr)AY-dHQsAX;obmTd2}mD}mLQTcAhk?0o5Cfnh!>n%~d?EWvFuVHs~YBG^Ok&Mh$T
zMD<+v>p<)jnThSVe4*AF7T*o|Lpoi=A6caAy0d#|c=6uXaka<#<+Y+SzgEv85&$1H
z@48pH-k_q*x6NN7!!!ag226-!_D%Uz_pPIr_pPZ~bc=hq{dUHuBa=lk!L6ICCy3^I
zj0Z;RtjZXrNj+}Sd6Us)@6`eXrGk>f>Ac8zkV!bAymlBn>pZLS_)*QMsD1Y;p;d;b
zVyGc^-H4#-zFCH1>f9(<-AGL*7(P<-RT^73lREyCE7#*@k$&Lh&$P0SFm3hC;73h|
zx-khRSdZk&X*_Xx^|1AfuH|bfQfsWKKiG?kf{Ccs4NCoqR7sc$3Tl?o28196y(uvc
z)G8N?5;~!uO*=|WkOl2o$?s8{^!!h#rKEHCWgRAiaodW*(41T2um}8|1P9R{#CZXb
zDt%D(qj<__adZWS=V2kE^oFTBwFzzXYa|1Z;XtoRcOKlB5rHaANn5X{3TiSZe9ayL
zz#lQqGwV7`c#mEOtenNpN^P+o!G`e5Hr^h2e!A?p3}V@<e??7Wzl#T&Zs^3W4;ERo
zUCW{YEL{0`w@?Lu?6&L*AixCN{AFT<!jkAQylm1vhvxhy8g~f0;&^6^`Z+J@<H%Oa
z@VnM^NR>~Yvdp;i$iPaeC9?yaQYSviLC9?mt0Z?#7Ww`Lx3%~%M=JmBM3M5W=kuxc
zU&51-efAHwX)-ZW&Qeo0!`8i@93u{0Tf|z|Al^P*LMx{so-<jMj~`=C4?V#BJIcxo
zcYoG}2U*T$PVr#IUJoiWM#?Pr1QONc6=ox!mWYoCGBkTEJ;Pbh$j@+ya5&9G85+5z
zTk?Qx*uYt&lnP>x;=@Nd6JWgoxo6o8t)_A6^;wlxm@HR}jqAK|^Owte_G#MH0c#&I
ztq6$J12<W&27<CoBP>%PU1(#jNoU!X^MrvG&7mRnq&94L$uizIU*P7HbF5$Qf7vWV
z9rU-mhc34xNi|`es*I<(-VP@M(s!O4DM$7jPydd;i*lzv!D{Hw^MIQ1;fRlDjk%}R
zWm}?QO#V?Wv=tKFliJ3<YFV<1Z<7FjD&8tTj#`vjW7LH8<ILQQP%i#tdcmcX*t~Gq
zjZ8B&X(4JIy$UgI+1`62t?*uV9ZduM0=hll;}q`_0{8Em-M4EFrBz3#thz}&f-P)y
zY}0VvM;EHksubc?5A)=n3TeW|@Q-xOKR?W2lXN63S;ao5_0wPAyxMFKGL+_-1Jl%w
z`H3lqMh$Vd%p;iN-7<xMLNI^<6)Oq#BY8X46K+B@Bc$On8g7Yu1}Ivp%*re)<+G%_
zrFB3-?U4lFbR4OI_k14q@XYK6W^^spvaj!|%1bH2^z=$c6DmNa2-I**70TWy@M4}4
z?*FLmbY}mMy?XLNy$3stQFVU<7l6QkzLpf9QS>d&S_(;|=`+l=a-4{8;5QK$Q4OSC
zCC)Fu9HP9dP19mYp2=&toUFN4*0-7XGC;4&?H-Jgy#_Fp!5e@?&dY-VE`Guw1{=Yd
zp)sR7q;r@sj|ZB#J^+=RWT?jOm16tyj5qHa2N;Y_KX^-7hZC1K%^!H<V=Jl5?`1A}
zimBRkjUCgF2<+4jO8LzX2*kT&5*Ta_zjIEp$=p^BgaZn;z>%)?qTikrS|{iV;2QrV
z>H+alPYu`TN%dJnAy%nv8BN#-*KBV`KRY%!tMYwViomW|OE9Hlmxlg>B3O+Qs8$8K
zlvFg_qR$Lw3WAG;BLH7^^^Ba@=fGDBkGgv`+teE97z6`79zeWrOR+;n6)CfvVyvFP
zIu&wHW7DLNK<!QS%7ldkt@>LJT?<)&wNjVN!?7+;!ew%bhDIrg0g=BQ#jJV#!r01K
z<mp*;-Quh(R*0onUEYQPQWz!PtFoQxlu>+9eim9HwT=O76)vN?ZYy(BZxP^+OnanS
z#D|@L_L81`lz0hb#p9<id5=5e*~i7D4FGEmzQ5o8o|yj;GN4B<U=m>n*c<~*gNj7%
zDdy@8Zzd%oq_#MK14kkEI2(`$Jzp`j{01s>1~1sX<J0A-FxV|BsaoMK3JBfv>K)UB
zAT(*KU?K)JUk?F+9Wyf_@`V5~Y5{a5-Pmdx0Zi{OtHnQKR+|x~g3HEqvHUb31u@F}
ztq6O!2Z1GH-M4!aP@cMdE8<8<7eu2rp)h+*ysfyb$d;7}HuU!JL<lJ6)1R3$`;a4y
zLHEtMDC9tc-Ox(cLJUWI3{vS5A4YHHJy|g$Jf>=N5)Ekj%)~IDU_y`jLjwaqU~?5y
zp;lBlKvGxq^$6i@bk@TOBUMlW?+OAMV1f*`VT98!26n1E^++hUgYQQ2j(hBmzyKIq
zXk_xsUh%zXy7w}1%iM<IQdf7s#ULAl3He;7Niy><>txbJU1|rRZWFq&FIjT~`I-m{
zP;1{xJ{)&)T57+hQNSd4lrkW~p=OA34**IM81(>5F)IxZ#}(qP%lki)&N?j0=WF9j
zBOTHyARsK=4POKVBory>T)MjvSh@u15(Jg*?(UAIyPHKq7I+_j@1I^5?z8*MnVB=^
zeC~S~v$n*4iVV}Ly6Dic&Vq8ix?ByNlfuRKL`tqH8XZ3jXC`xk8W)1an%oX}Cm4K%
z`zbiD&@e=LkvP7c2?L{p>*zf?A-?m5OLz5hq@4`Q5{ie;2b>6V(Dq=bXP30*`0x`V
z)Sz0S0n0&3pk!(`xd|7}%z>9FVnpk{hk~adWX#M4?>(m`CL-_{p>CDr(~zJrm0S){
z9P&m8=sh}4T34rO91?nsj@yAr>^|;!2Qw*(C{7iuNG(?dy|k)}t)#TN3)n}^k~r!Y
zjgycV0r{5s#$F(7(Jjp^k&$|X7b4t)6z3EqtD>!}Ax2u^J?5L^nyUxY9ZE|1%tOBi
z)XQsv$c^HO5z~>L0u#I#Kskxi<ty=tS$tfG#2>#s0f2566lxqGmaMGm5x<w<Xd3`a
z?4?6;MD}#e<8=4ZEmCwz(=5^fxrJ%m>lE0C3to1aTB;<?{2_>@{=cd}cHsAW<fb(d
zebll(pNNAUdoiOqnm0aUbsG1OyaSWMJkWxKPkTChJKg$1@JJ;*eZNm6*b6S2M^6BI
zd$!8_qH(XFzu;lb5UKzC>UsS^O<&Mv+)Er$;C%I%wGRex7sDIpApd{Aj|Z5}-59h^
zNe|+#Gda3v-MNXS$UzV6Aknk9{DO7r?U!UC6LL4z$_fN&|E*m{dW!Fp0zVB~3${jx
z9f*;{DFGzT13>ayGssD*YYF5{mhlgGKsE-h0h^c|d0n7Um~xv&bAavYgK)v~6qo6Q
zbc?28YJPisxw;my0-nky%d78TA`CL&x;M_rKz@q#6E-G!bD*K8(T9HA3JC$!C!9d}
zTTBq<(ExK%ARA)=#RQ(7{aHM_ZX5)-@*F^kNa0cSi=`_P(upAnPY?GS0HkORQDgzK
z+$$4RonUO>sKMz`)r%Z`VnzlBSM3C>Tad!~2%>dwowg(7nt@3*?OTgRZo=E!Z5}a3
zY5*Or9>YP|tK@;1CJ|=ZRrf>Yfqp=)j%R^lK+yy`m0hD)e%v3^j5h4|z=Wn7Xd1TQ
zbb)%`RR3y#u%xI6>R2QRt?ay!y8LqMXPIrkFi~`21qj?4EsR6h(cKOJ?yiN$DVROW
zJXp>$^Gs2N*-mTGI7Dq_r(tD_$5GcpY_Y&?i~C@*;5g&hv#OJ~1vWzTpbH#jZmP+W
zEJ)MMR2?1bs51%u!ICvYZ2nrhkg#|^%4IAdsIyf76|HcXGmDCln0Y)<Qy6n@-xOca
zF-<h^A<ZEdgc)b!BYI`euD)oOR*nn$J4x6o5t)ww1bG%5c|5TI4G0Wk{Y^?T;ZbV7
z(F0a(j{c(avo=WpMsrGK@dM_I7W>C>(k>_b&OZlDZ$4AE1>ldIm`EvuYvK*4fjl|7
zyr(1_E$zB0ohrOz?yo;pC32Hf$FT(n6a-RyEAxp&-fht|j!+M5YQke0Iz&oUdX*mE
zx=+mRx51a|HNnhocaa{<PVj!7{B}*T=g+Ov(;g-gGdgJvAfO5OM<?B7NQ_!XOWRf%
zRHTq0dQ}`Qp`L!`gXlfQc+)8yAmOxfA-9EC)<&Q+ut`KFJn+Ht;OG^M4Qf|2Ca4Cq
z7aAwb44WYDSSUj9Xn+~fDc+*HLjd&h0&ZL*LQYJKIDd+d)f&Tt2U-D+$9r6Ft)`oj
z%C0F9f64LmYMVzmoI9lXJCCIAlts!a_1?>cdzA7Tz<A&qyg~^E>iSs#`bt9!PjP?s
z`g0iENdOt-b&2v`D1Sp74z5Yn$l4KyG!4@ViANTRWF_q#BL;z@GmsMma|p8V-k0+&
ziagy*cvMAO+|;B3$ua7HNUsB4ANZD()ZkXFr#pO~KWR7t*oHaPyt<SnFM<UG5BXer
zC>PmSN^E~@L(RL(zHI`xzOR~0NN!}UWLS_XG!CXBzHsU0D-X~-WH47!RF6sgqh2Ol
zwP0@c<prWd7Md)eh%~e9k|gH~0tG<*UGAJgArzNhB$;K*QL?fj2H+Q|e#Ud|$u<+$
zDNwrV=KZB~57)0f`a9%g?t?ZeFZ?z*D;kHe0Clw(5c?rr!lOzvTR}<jA4)?c#sPPB
z>YkHkwna%m{ovTx&815@kTg3RJ{FORpa>kN$$=;0*6Ty&mQcrhP(c_IVtIf_!J{S<
zcvaLLJ47RYG-Z3t0>s9#9@As1T1DOnV_e--riNr~fFUAdny;7(Z}_H?!*2~^yn0;M
zF4BIA@1vdTIGYjTP%VL-Ql2X@3A6+0q<$<@M^kTLLhhkl_hIz`a}j-vPiTSNC^<DU
z>vjBd;@Ass{)LXG^nwIeW$%YL*9=?z-7G<QO`vprM<b-KF+=GOCI0@0>g@0<FzlEt
zP2F<iPHAVtr7`n{{Bve4-ne$2V#e8G;u}0_UgJQ4Yn(JwJxO?j>sjmFj{8&5$LKgJ
zW}ie0JeMq6{cUAVE5c?MyC>Xd76*90%A6SwXd$UU{)h}j?I+Yl3+Pow1Mpf1%Qz25
zwF_NS^#G+x&P7VRUF8@(hsxV+;il<Zrz}SOeeQLaUiahU=BX=z3`>e8=4C=)zZy57
zy$FT0Lc-MSv{^r6qz0O`p69;8IU(=S90U}8^nk8VpnVV99{*Pi?h_Xxw@FU>E4ZXr
zHsFx|H7Mr%+{SU-JJ<qP2$BF1B3a`PPiJg+I>1SpIb3F>mR9!#o%*aOyBJTJr2vUn
z)VBV%cxt-4+L7lUtI67|SIamnfs$8gzT#UzqjC4ITPlk~^hh8KIpKWl#&U}S=tBi%
z9`3T2yH;)*X3IOkr8e7r9eSwQO><f-V^e~}k%N+aYW0EDh}l5s%U>BhS14S6hY3<w
zo*MFVWe4xJX~I<!KIG0tQSWk?YZ2^Ez5f!@*iCZ7GlByjJ(Tsyh_rZ@%kkH)X2|vI
zDk4>U6E{}}VtaD*E&Sq&>n{knKO@_Z7^sOEa}5ahXpY0tAQ@-lzfA`1pLm`NGy6yM
z5F94=j!kHJSV$nJ_+qzC-1+KW-T{#=Yfjf-?9V8lc3w%jh66tjjlFaR;(KB^ozvGb
zf-~|D;%)2|QLTwa+jF0NH}+{Olxb}Tg?(j<0>}gvgxd8oh)vY__+LM#v^WWi&}N%!
z*PQHQLV!TxbpCzlkcDjLaMiK@jDEc$vPio>_A)nDSAja^pKjgvr78ksmNn@X{2I?S
z3$DLMz3;v?f=cV0`2f6;iTj;?=>|RX3!y{q5l*1*;hME4I-p~oZb4f2O`*mN*o`#j
zz5A7E;Xy*Jn;f=wvFr1VjhRD^icOA9sY}hrKGrn*V54Td#tep)t-z7MXktmaFGsaC
z%{~(y$zIQj{HG`h>U`pv(i844#XDb&JBN*AZMx0O*;1Sv2z7{w?{ge)Ck?BJ-iydC
zDnB(x1I2y*{igmmDFDJDiTJ&^d9Axkoa@yMU;xQveok_?Q^FVOZYE^0eUfwUciYLi
z0TNPVT(f;wbYIt|8P1$ScV`42kS4?KQ8^~=>&JNkD#JvxGj877$$Q;dYFFiq^AYIM
zUf(K?U!g%ndPrzSiM&P)0suW_Cjgl47M)nD9^b}%1A2uPYq5Qv!O_&FbPtQ`ZsFGa
z96hGl6MkE`@m@pzhF2-KrPB~Gf-v=7IN}!d^k~hi2bXL1`v4Bm-N0JEVlQ{fJB-Ve
z20tY~f9dG10`+n{OFlJ_gysx$g3`)IKjwlqJVPUsvi(y4ABH$1r$pkcJ*z%X2d>-3
zE~5*Y39pgnmW6ek{60%4nnz81Qr0FDu&+wu@vgf;00bD4iMw_cxi7veg74j@2c!V5
z)Ct0C4C-xz=MhMJqpoSnh$yKYHie9{YIL1_8a1zNX!K1DH~0eoUUauX_UZLARY0$<
zvI2#mR2#c;)^-iX+U3}A*QVBE_coJUWiZll>n8Iv)IVz%YuyFfBgT1mY!)y;2dB!Z
z>7Eznw|*4v@}f@tZg8>*f&e<CIM;}tlZCEqeo70=G!y&_jO+VBcFBv-pTL>Q@xGI7
zc{^dXUBl7;tSzo*DS|`GyG!LMt7E)lg6zb)dD&)*7&v(81#IyM0h{LE;BzvHLM#xe
z9?k%8zijG5)mvLNTBJPPR^lXCocjA-;-@dqP(DD9slSb>09$avJvROZ)Ya~V#P|3z
zze7H1)4zahp7V}?fq6y$Q@97nOQQTw?3<(cGa@ZhdZ^Jih#kGglxZ)%u(WOw(=Fyt
zL<IYqwzlgoI%#$i0@bZ;$#uBr{X<s9Ri#XY*AR99pq}*Vib`OgqZT_m-NfvGI(IvX
zFwPGkOK030K~I?_+2wZ6RIPG674~S5nNbA2CgKsE)LRVe7s{SU8Ef0-YIkG^Vuvdz
zM<iJ16n<TO=6+Z;$cg6^VV1QGFgjgRG?rmgR>csZmL^QQtKjg~o!9Z+<Jdrh8@GPo
zQldDH>Aa8fx)mR=+qsBTK=ev&#p_r#7qD$|On8rX?D_%=yb8E}^?idXFE7vEEv(Gn
zyNfsmfbf5Yh);_22bHM3)yrZXVjUfFoWq(fj59dP$u4-|KEn~#$Lm{k60{i6f{?m<
zzDk?G8Q9YE;2D<!E?Us*5fFDzcPD##q~1h@i1eALI(-U10Z3BIoNa0hXz9flpwSHA
zC1XJRnP;9}4&@fBq6(iu<K}Hq82{od0;B3RCiRlYMMYGQ-EW6a?T+|~CjK6Piwm4z
zW+g5&#^IfZUg{2P5Lkx`aG(cQc6cAB+Rx*+5H-6o?wQrNh*bMg-;bCM3R3xP5C)C|
z)*+Ex_pixx%oF>H*mXZDpI^n_{}eZFQBT7(J1OBp&x*ifRah2UO>V&kyH3vC;k!m|
zi&>tl6<FgN;JGAJELwh35Z?w4%j33dO+SO=ajM9_Ijp*q(qIp`oN${D2H~z<glaye
z5=%`i*#WGh=e=_KHuD4w=dEQW!@`54GYxf@adLB=q)Xst+Et162V4^khDwJ}cAGj;
ziT9NC?B6KuYKD~^E-MxR8vc@G-6<Juk9mdck>Xk4Ip(Js1+NdKEH2Mvua*86u2fOW
z_8cl~J2KzJ2@_S<uh`U^y~&gh{27X-(8rT~y)2re2k{LNHSZzdzzM-#9+Of}QG&F{
zgyVWDUfV@1cQSk44V>&t**0sq%>0}{k8kQSy5yU<>)g9rkz2u`n%%L7+5sJRani?2
zHrvK0<olfXGQXSgI1RF&GqTIpX9@Q6x|<Y%{Y2ry{R{eg_`>q>>5*=__k+*T&(Ls(
z6dtJuZI&8=PRfq<{I1Ex8Qz0QlQ^KCHD(g$`n4u&6P4wsotRufI$oSps1ZnS<zHUe
zZ3d*g&6)SE+^VMfs5}Rio1Y0)^1{0!RL<amyHXj#>+CFHGw49-7BFIF2pl3%gcOWk
z-cujI^1crUYUO7fnzuPS_0}MMkIu;jkv9{UUH&vd0&Idw9h(L!0O%gzDveySWgTo5
zhc*`w4J#0uehitc&LM9>lrJ)`aYQ>~s9GVx64d)(7LkEBs)v&jlw)tX2Za1k?3}|{
zR<>Wn>u%E6+EuF1ji~&WtU$m$p#1IUxlhabcms{#9rhDPU`OW{Efzsp`BFIFIvfSx
zYZxN9GKy18tAxE^X2xSaxSvd{J}<0N+fin`M>_WDEr_vF-pddN9o?gSx1!ihTGNED
z)3_Hs*K6GVDOm!jQ3KPg0w$JXxjb&r4l(e`f<D}78r++cUmr~NnJ4O|h;%CAxhC3D
zZy&r}QsmFb9;Y_CB&i$%M1aW{tsAe;b<L6_Wzl0QdEelfF1?D5Yf(Hv1C~F>JA4H3
z)8qUy$j;6#=gQaNf;irLj8e~`V$gC5{N2aLO-Icc%8x0woVtr)9A`^af77cI2?uUo
zjqW%UEH@|*y@9>sGY`QR-^F+m2p1W&;JgwrYIp)IV+9T?Akw0@uDI}uD%FBgx%tKE
zaXcHxD?1r5ga@t1UA`q{SwI<Ri-E>H?kN1V5wbt6b8ZWu2&%a2WT{_8-He<0oFTdo
zp*25&?B3G_*93{=AO&{ujo0~{!8QatHd$z|Vs1-$2~^ckhnBE1Uy)}1hP=ubySje_
zy`_@QGNo<JJ+HM=E5VoMWn55kO43~89dQ)tG#qyc=DLfjQPJi~p=;WmUst9%<a##o
zi-vOD1$o*PZaV}B>$b<ae68^tLyN1FX4&8Ygb~aX5ZbhDBC<P-Qh0*G%D$kZR}aSg
zqUlCIAvrWIrSCO8x|CQ@VBu*LNbTNCwRRT$B5wVPMhYI$;OElDDF2ph>|`stBGjFv
z{@d6fPUZxDUa0JYCMHO6`iG}F0H9i!%cyeoVOzh*bki|`>H%UYGvN4WbYX$L{bFr5
zY+3Xtnln$Q`C>uL<@9=A-hlYX$tEgUW4CseX)vup+l4K^MpVtgXyqswj_xj}r&p)M
z8vF}~;6V#5@_4BgCaEkR6Y^lH!pN9GLtn?Xlw&sNB9!hfF}HC7L$Z1^=P=bmb1;ta
z=}uDfm^^ac{PJbc-S6+UvB!&^u~lQ;)XSjm!eI{N;IW`)4v@PS-mh>)w-{Z<tlBI(
zuQ7>$5njNx13>+<k2yZSJil<zx4nG6w1@ll{)q0vF(B35BVcJ9<!b78uuPki@dHS^
z{{~jCmnXOux6nMBMhtQ)yL|=8Cp~K-KX1Pt!_!52i`KLF*=_F~HpID!56^8`{Pqqw
z01ObXUFEnh^l{k<{Q(zyb0cS#K=XNw>Wg7!>`FvA4~CU^E<3wuE9fo3re9*;KwE1?
z5y)4yU5UBSw9>1TpMaV(gnFNPziE_2byoe{oYsZC;Lf~p8P%ZKEzKfPPSq);#BWH~
zqvn?Z0{D(fshrp+yW)Z2o~=79z!`J_C|CrwQz;Efp>T0N8<Ky9+<VSq^hj6=?>J+N
zgVtO^GQ~GJ0s4WGs=WXFmArV>O5iDS`<>zM>RpjD(R(3lXM@qf^BT6f6kFWlS&Yun
zHy;-3V3=FyXN|o$I{U;GO=CvY0D-Vc1Q8xd1q*03go}?LGRrdy9CQ2ummwq9Y@pt|
z5O@6ukcKiiKt+#h|1Lwo@Pe;nA8A6z1n?IQj`(7_MM*Uf3lsC-K@6FP_5ssG(=26X
z8L;JQ@EYY?t2wk>i`Kx(_V{7%$n?jk(Y(%M`OP|cmG-_O-OILt#u$f<?JIsav7%bH
zhOjF;)O%SbSZ4yzAcf~ZR*cCoguBo<fu&pDLAw8O@efG7P&QR$57uMI>69q7BaQ(p
z90M3b=C|RiCwqVxwFT(-NV$Y-19dcx_d@#-ULLDeFNA}GvT%`~;kai`Wgf>{%u>#&
z7%Mw30A4aP*mq6RzGRl@Z5l6Y^Orsa`ilZ?Xa`vzbR+i^CI%y@2PHS$^?%#(PSNsz
zH_1x*>V;#1UJPspcy}X4)uTKBPaB=JMIFv&A2LXaf0w-JlSJDh-092-C+XNg4X>RC
zKoFwEK2FuE*Uv!;h)%$QfqgA(B?{LBi6=}=9A4Mw3axtq0vr=N8PA+E2U=<Ajx~(T
z{Ep=T$LVWYi|o9w3$o>s4@1Er>nwjd@8Hd3Xkzr%n(0mLt;zCn^gQ_!=;vPjw+MDT
zmkhZ6KF)xMVNZXjUe45nQ(IR+`6a+~E>QnJ(7@ZWIOg5HiHm=qxb7PNv(>o+dwebC
zcHDk5Q@gGaDPW5NK!Z5Wu9E)=vE2M0YS_~(-V`2cp@yjTi!Jg5dMLrQKk-m!t=tfP
zh;Au_#3(sNElfQ{PG8xot7OV|lIoRS#`z-N_yYBQ;OID$wPU53jo!Mef*#$ElX};J
z@NeH33}um;w&EYF%zf0~UEhASen}ND!AFbIP6R=H+Cwa+d#-DNL9P35)b0}X0BVTt
zu;w&J&r173M5HIpE97uc5TiSs;54-4H3mw{r;>0Mq5ooDYtr>C9p7P)<G^<KxbAWQ
z)oc_{%;5DE(U(CDmYlfz<ySY9ir7cUmM5>f1I(gA)#w7i!>l{SKMOTf>3d3vZ3*tv
zbp&W9vNw!Ttz8AJUl88{%&`CMkN=!~9do=8AA)5IR~eybf>^-)Vj%+*AtLDJWjIsr
zYR+1(K&XXDtn~z=^i5S3^Qs&x|54_=?#Z7JJ@*<ksvJ~Qb^T`Kl-zT|!DDg8a&{?m
ze<X{*zgN?vo>B*hRHBE*Zq6H|X9dC4i4$jLP>(><L-f+XSF|7%Ew2%UGpCS;m3`dI
zn9sl9C2wji&vuPGIw$e`GyM|O89+O_hI4LKf$^-Wf{H1II0)lpIl3Ah8}E>Q57`&G
zI56PIa2Fgn77%wu@;}3{)C9$eJ=|Lz%~l_%(M5x>stATWfJBY=_nSucwC<s@G)m>f
zj!iNLb->$GhK%0i5VDtEKr>giAhZ`Ln&>K?1LWz-IlrkxIoD~n8ObQisR}e$WbYgq
zoROtlQ|wrecT+B?W@rS9D$~Nv=Dhn~pX)$bM0LJevSjlnoF?DhmTg^nh0_AHip!jE
zL<-PnXCu2O*@um}1aG8~0^Wh{eI;sesSUmCQ3U{{_%aqj;o+Px;WwsH-%ksQTjP>P
zIWR^lDRruzl#qg_Yo1*I2v87E42?GF`y23a@rp#D9W7z5PmM;ZAeyj+If^|mv0Qva
z4T<~>vh)qQk1Ug<ZyQJ2SNRS3l#~T}$>|P#5Vx{8al)+pfK;dD+gt%dmrS`EXDDD4
zqb)r6UmP4+umsU-CO6~>b-WX!E^RFXq6cEk8zPtc*t(NIpwLT+(Js(GWS6CT!{<n`
z8znpqi519!YdbJ~!N-A_eo_u<^oss{l(El*lA+dC4<2}E4C-u;%K7Zt1WI7C_TI;Z
z3%rs<&8KN*kW7!yzQ}GxY#oNpUb>velJgiRk<h}aQbhVm+Bfh;hNxZBRfpDgQ>rmK
zo!e(e0HFB|Nzx-u`fgrjDOEXR-ewf&=~b<}7GF6&DNw`jzD2~*c@1Mo@|g!|n%Tj;
zjD$5uLV}YBgacWP>sq`7$tqsf@ppc_>O+b+j@#<;EP62_fN4Lo&j^5C&p9DkyUOib
zyy5AEsSK}|$z!}mL#mEdC?WS+fU+{S$n9p@f^#SAEE1$@_>nk-u(Au|uaa$aACRAW
z4;o$i(q1M{I2is%K6|o}%JI6wufm9fAmIZ&t?j3uLT@%sN&Mb9e+{K%c4m-HX`_;=
zNp8J76u54ES^DmGm(MQ<?)wfSKM}^;btM0JuMx(lEEJ$VVRVH{mR2asvWJ9sP(6%d
z$evSj>J*tI3abDpz#!TdS?nwpWEj$|P-cAVPD~5KVCqjoMtSi)(vD5$_`6PYDjcWj
zTA}Ub+<n%(h<)r72c$vUq#KFt>7(C`DHt_Kq!LcraqCU{;IxkDZULUi`7tL(-Bh!h
zcYy#WYG+oh7=A0hr|={a4$yk#mm~u#L2<@>ZoYZgY2w=~yX2r~YAo`@e_SZFrA{9E
z&J%oJSK*lq(y3|a6e0Is-fpH)=&4_q0Rxc%nB)Oi?vToi7!eV^3iF{isO|V_Y|0Q%
zYOaO#+CrE@z3ENxW3iWmZ#MG7rD4cdJJbO7x22bf-|~B3;1o;jp_Y+XjRBa<h{RK}
zY}N*mk!x5I*krQDvNy;ctaYaxpe2dKJ&}kGC$Ztru<kd{X}Vnhq6h(R@_BVDx102`
zMUS>TA&uYO-bbGQ54i>;a;4ICtwRP+*|@mh+?gxT=vx&x#SE9Wzy018ZS{?e+<iPW
zc&&*3$^3iFbD6e`p3Ht6{1Km4il2lUtFJuiTiPEUx5~$I<yIr2`eS-4ppgntJQ4w8
zQu}~ep{;(OaW<LX9!W{-E(R?t#=O311-&f*(W-cpgBu6ZAMa<0QE<Q}UETwX4lXfh
z^Fe5qRgFFNPf=9=tZ}ao`8useSGW}1i8~`!e`vvx1~WrgytKK(K3wxX)92~`pfsBM
z=JzUz^3(g>A)ZJ1;OCK>o!!E_#3IDxe=#G2j-6^r-R1_`XV%ET>FKaWDK&Lvcj7Lv
zI{vjK%(N5TUr_hM^)G>{G>GS^wJ@N;8qdQRRayvl`g<$2hZ;C6fM;yNyYbrdK2fjL
zGW!(@w2pdoJR}NJeb#f7^Nscwo%pzmbVsy!4OLvg+5RwyHEu66@E(p2j`&(2BUphV
zwfaL=B$90R?l)&~KQPNO$vYXF&j{RjHA|ERNh?zqW7<pqF^c`1q%S#QN)Xxzj&_Sk
zmX%GUhC7K|7@qyh+9ZC$ykVU{U0ce>8djaY<)Q)Y-{}kpiLBPQo?c(!sJ-7lE=*R1
zJzEx}<?RS#?*W(}8HPIoAjvgepok9No2_4R-AB^u0WI#7E15k(<JY~YRufm}8{WNg
z+b7Htg_oW-$U))_PK2{$usdIEcAOoKRW>H%ou54k-fkdc;B#<YuTA5@3c8x(M$?k5
zPM!?zi=lJe{iMzxL?---%c$7+4bOi62TE9FVKZ5z7?EBysKh#o)+afQmFrUYM-mVB
z4pMA*PA7!JRJ1>rh{*1j8STM{$H`0jWO5~(Ph<8_2}X#p@U^7cP5xM=c)akuvayYM
z*5Vo)j9{)zSZ)FMI;*b~ldFWZ@@s!L#is9{e?0QqKL0RqjCnpkMo4$go`+B2V>H9d
zc|u)~L&;)(FiBT~eN8p1w-gy=T0&?VHJUT?VDx%dO&^j}3aoLA6B9j<XRY{25~Wff
zcjze>YAPHKkBT7m+8m1-=6#_z==s{&4R|B-Qs>2Km|r%frCr1|nrU=0W~Px@=-xUh
zUEh8_ff0RO;e7jOm>l_)PPR_+Y0Ug>WpFyOVmQDjGrtfE!RXxC;`pjLzV$Sm<dNF=
zM?*i>g1t)Lt11aKh@Y@CAs{DE8b<EGw^i$PUhH*@lBoL5R&j2&V|SyWqvr%KVN!rn
zg*c|j7+cyRx7|w}aV`3bSX|WFOyP?Cj)&s369U|Ir{7{$eL@jlK!EmqF2s4Ka%B?w
z>l;0|kIB=d8tv6nyKZ1&m}MwFO4|2QKO7*^h<^+u97;hxiPNah)m6W!NDqi;y%3Zh
z{;b_=4R&ypFceOBl+>k-)*Em2Pj<5|KVuA4;p|*>{)z`g>6=tEQR00Ol6u;a1?&%z
zqwD|aEgDEh;|HBATnR$$cRw6^-<3l}o*3Gf<cAw%s>8fK>2_MI>p74Wd3ySHg&>**
zWOUeo*Pg*k(InVEBs0g}k>%=uPV*ie%l6|%qv2G`Uk^9-YZWg!OqM=k)Sx>*Z_6*|
zka;tF?_RX~YRh;tT3c~9Bj5v$()dYaCC&|XPpc1qj`!r#8m|28mb#*Kkacs%T@F7z
zyPNhxTuW4&`7Ux3(?&E_7;z1~fEN6*+g3J4=8I}7{m1!kYouJwn(+Lgq_Xvsa+VlP
zT^na}IvXA23?%2-BdYs)l6-8p`*oO6^2~MRkNsS2X4HSbrmTu`4>dW#r62cHGlM^Z
z%w>r_@N}4F8^VRD+6&uZpT9T0GYs*62>Q%y&c5s0FN3YJsd1mL7x#-k`XTFW3$M<<
z)sF^N7SCsDELfaJF<P1I6Z>j4gEdfgSx-pi_9CyhJ7M=_koGRah|zT1`}xO0Rcp#~
z{)4g4tN<{rnNNhH9oM0Ds?qC~{b|7Rw1!c#Myf9ED%siFr^l%PnaRG)_a{|MqcA8t
zrv2fAt6WZa`eV6F#$eNeVYP$#KRR6yXIEr7K{zk00#hNC<0n+b)VMO4((>KzXmFwp
zhi4@Pn)vbiTMZs3?#nfIgDY`VT~>p--HwnBC%woPT2t?&J>MnN=5XMX=6-=I<9NRY
z6q04Pw+{NMRJ=sDERHa*DkLv8Ec!Hpd=f5u9hvzDT3N=~q(;UP;x9PiA!YnuYZlS1
zx}0twrPyO(G`?my1c(Vr74iBnCHh**KUC_{b-UedLlW|c+L+gjI1Ri8C*>j7^eu1J
z;>DAheh#WKM+M&8GW#L*5@UQZmGKWT|7z`HWy_y&*k{ROQ8ws_BSPNLzC`+|MJ_Kx
z%IT9XsKpCuEZG~&ZD4MES-<I&Uea6rdV=juV4JO9$MXpu@$R{hoUI7%S?Iqh^7@p(
zv#R=-0O>#Hi<b;jmK;VBSH`5HLA-YHW#{xpFG6gy$vOtaj93u;$q4?o7wuHCtwz5Z
zp7W}S&Ds5I;!n{$%B_&*6v(U?puuW-X2d|e9)3^T_8?*lUX5OpsW<%Qtv1&_RK(g(
zSDjiRGM<jjS4*)WB|<fGd|X~T==Smor)lAL=wFhG+ntxX4rWv33H~$rN37mU$bdk*
zD7`w>s)Ii;pn~^<o*(XTV~NjWjlEpN?+}E*q}XSQ+%rx<BeX!VO%&UTEG;T;XW7i8
z5l_QtB2Sh0NiE&Ew_M$$>=^G*065!c9I<NjC0Z1h@J%*1rlmBTX=+RuU#;()gazan
zEPkd^FMt=KXsuRUmSY|D4|S-p*R?W5?G}&$y8_?Xk6j0q&q@VL^)z?oPxkLKU4&?>
znFo|P*;QBTKB|pJN+Jh%%Y5jT2V4M}<$i^+63{#zeLIO-SEdvDw+7G;MHf~W47<!P
zC#rRK*qe^qo6+ajYB;hTSCCXyz5^eAz?Sx*M-lkC)465&qd0YcNX$c6L|_h3n?`xn
zD<ej=G5iZ!PTuRZkq=|se$uNb@|!2F)ajC{pt>KjLbxx|Fg~~%_AU+CHqY?iWzT8>
zf<!HI*D4zB8?k5yIG+}YP0nz)!%r+wU)d}9{0IRL`WRQ_(PaVW4@lJ*xZ~54Rw~(T
zX^2JS3|<8QG9TL^hMe7AKi_1fvbnl`9>b7UdB<u<%q|0R3QKVK4_*^)nZVJn_$Bo7
z!U&#Cs6Teh;BAVN4uhjx@eZYRNeH0V_+he5^-QyVT@QZt_&pMs{)2sEi)5<gw72%p
zc3m6QAkz++eGJzKGsuhf`3c#+|E!u^3A>1gR?ztaDhe)9`9(|7iNeV&>k<2h(IfR%
zRUletR1unm9Lf$&56^~?hmU#HM};i+B---_bJjlvR_3OX*BHocxY_e}Ow2xv9-K$e
zJ1eq+{bU%*+jlW4-Ikc5S?Bblwg^9C0?}~VOFpq<&#-3hxR;?ar#i6s`_d!Z-8I=K
z%(H_~WFZGwQxq2?ss*GB*IYebji%X(3P+b_yKqlMJK7O<SePgilak1+P4A@y0-MF}
zoO-Ks3xeEH&W_<<41&MBuzoBnUir?uBesJSNvySU->>yxn)S^u6pMGeiNRjj12Hi+
zJ@kj&tkr&rHbb8*gQNgePQZw%6TB0dz|}AEag`^kqg*AVT(tI&3?M;QPBd;i%?NMf
zc;T&gHD4#1n7=KmR&?7|Fzb8cuD6sDY8OOnK~Z};J8l=R5%EtgGtBHy@{4SO;e#OK
zt|s4ch7f}-v%JC|)x+B(4p4x*c(|;ir&N>g@LFB2$2DmX@EbC$(;&rSvBs<p;GIjJ
zi1P3p@@;IIZ0Cf+oxG<ah{`Xnz&0ZlXHO&BXN%1&<TU7l1|ZW)9Dh5`T`f>vti^9~
zNZyAKiM+J@Pv{0Y<jTVyVM07+n(RhI-%f2$^KS-<>RJ>XvYGcY9qk)sFX>izG1-QP
z9ojsTqG#*SftJs6MBjO$z6=ZfF;KvP4h*=4RKbhc=i|Qa{!#Cb`R`lbNje|z-p%|1
zE_j%GqoJfE7;|^a8#>u;T504A`(4QHKv&!%`!7)BnVp~5JYOq!WTKT88bY*mSUUPV
znwO2;usf3|i(e#K^@dKqcrcG*kZI&hYD9?Hr_W{pd({|IzUY1mpP1N(r@y}!J~ffT
zzDo6NVS}K5<FSkj)0vP1@pI?0cF=15zAJgeE1taq9_8>}RO9#Huie5A9B)=XepJI}
zGrvBS=Pa+c@hEaM7l~s|Jvv@1yZjU`U$Cf4Zf7YTElF|r0V%4X%%Clat@IvSp2YX{
zWp%=<dySXt-(<A%Zy}73EvVh;uPZ!@Z>#pYl`6mjr1HLiE-7%U%<I@rUP(#Epe?OA
z-*b*@Os4hyZW!x(!8X`;_AlC0-6V6v23SSO{}rZM1WfDwJH(2L3XInO*{U7L+>CBe
zkwek|&Nt}kexN8~L*|*38?Z~lt#S7<(zrzNyidt`%K|V=^)(V<dLWO3byJJq<#M}s
zR4+LTMUm*ovP{`Io@MUAK9uy7I=`?ouA=`9YQ1rdu)AtdI&ku-wBb8XHI4o~|I&mE
zCUHy6cXW}Hi{45;`EM+7wThTd#S;Ib27SB$gNnPn+H8q6aIlyL7_qj*%+j{iPA;EA
zUVFJ$a+@7-&R5fl$$a=aBlPRrKc9{{9(&+kh2M^NH}hDKx)`H%aT0wWIZaZ~l=yec
zlT;zD)qu&Tur^7{RXg>6&q9-x=wX_6Yut%p*%HT=PO;#B{LJ?u$(`Q=pKASS!~aMZ
zDND@T5L9o>NN`MFq4t-=z9&AwiVfn9mC8-Q0j#@8irRW0qTep}=Z&0cCUvm%KmIM=
zFkQ(_Z_Rxa<Bf3b%8%tqCTQjVlfcbbVN3J=(FIYva~)d0W!y>IB<WDT7u#W8EBANO
zUS2M7x_;O=Yd-<El2qc{L0D8`vM8&4^d6Jn{V`*&RdskhSy2ScKq7mjcSUjPitS}O
zy|-Q?1lmPx*wTNe)9uN<v8y#NsBMI+^Zw24PgA5p=2yi<yNRV6OI-pTnSVpvx(y?q
za;e#+)#0ApL}O%ITv;V@%3q?O;DKnig!0vevImF+QbGqlkP9+%efEzUh}SJ}vDdx5
zURaK6Vfzsc+WuBIDlI*f7Ho4rlImFgi%<6Jzi099niP;?bXtBIF7nM9KKPw9b<UBF
z4>FHNA?Sz8ynIclJh>oY6m)lr&cYWIXgF0xa`zhDHf0_1-5}Vd*Q2(?5*QC+=JnvS
z?2uxT1@ebZ3r70~JqyiiH5?cWwtEkXkY&`{-sz~db^Zy26J;zG>CMYMWLEr%ui5Pc
z`+AF84Wnbd=fptF^r4*nefYC!`S<CmJ^lxaGBgR{rJcw<yCemgYvo>E|ChI4!qAex
zez8=#1cO>Wma_|ej&8IR9o#-wsvtlMGL2C5>G|fWPx9pzPRt-z&o{MkCKzDy@-Nef
z<wOBqf2W3JlEg8NrIPzroSve^f?Ph_!wma<;OLdbINsyJ{X&%0Urc0~$qTwxUq5@^
zERRx(y3b+96-(#;!cNM^L5YRqf`%N4uIZ$(q%?NCn95MEK)ZL4tyrFxQ42)yOe)?@
zR_Ze=Fd3mwrk!a`461boY;<bL^d{7Q{}5AJGGq6ojp^*_@N#Bs#x+(hk01nfr&21)
zG1-*oL%EDDN~Ik@j7$vVU!h)s*m}gwvHY8gz%VU^ey@rBk(YBTC}l}Mull{&?OOmd
z8K`^7&rdcREBuxou^w3-H1+XxQa+f_ch}tHCqhDuf=>q6>s6SU9dqm%@8gjE7S|H$
zl5AI~zU3fLuYMuv5GaYz)BBvCCMbMXE>oj4yUN{|L|aF)Q%7iiZ$NcI&;vaOO8-R^
z_DHO%Pg!N{5-VII5Ap~-^ebS^tc=gS&OS$?uc7;)%wyP7@FmnSl_1qGy^MZ+%g+2j
ztIp%o*t<7)-+(CF0i4X_st$Lq3%MD`ufqV}>uDrkl3L`C%JsWLNnX=iH@4J1O)AR3
zJ5GY)jcZYd7^)(5>LE^H=e&%cLDjE+C^qvVvU6Jnvw8(f+w_8sbgOP7u`#Gymx!L|
za6If-$!n@#?+@LAqC$=1stwEpZ2<2F_#|l%|Fk8Xwjc{x+R6P|b?{!vFOL4+{WVIp
zMhJ;0?l9fH5lW3)9hx+-1w*yCzbdX{d4NF{NqlOuLh7L^-pZAUTa9G3!sP#rN{8==
znpc=ykS*3ZXna&^mn0mi<R)%=Q(e`k-jN4<@fiYUY`^zS%#I%mjlW7bMz6T2E$V)c
zX^EOE!>DUxT*s<(W#y~g%c=+cJ0FDn7&}03`#3KwR@uk#B!x2N)_EEBV~9+KMx=Nm
zBX}?{<w3}qYmFh`{`M4Y%#Qfi+6OJMb3WbNJN#)UUskFAWzYO$CfrH}ED+c6>7jd+
zFUO9p22G491)Py-FY)<_9Wg3V`eUtYkY2uc{1p}X@3|RlJWB6P`LahR%{;eAXe^aZ
z`~E8_gdnL;Irgv|_2gV%@wUpXe+_Vq&7=>oRW8MCXPR+fk*V;od3sb0eX9WHIzyRU
zAO!(af$&}ycEaRi_fvn$gn1&sA606)yrbRcIPTnltX)I;ZjeFZS1uB+9@gy4%fB6I
zg6z_Bs0OS+HK9n~j<gOlp&QKi202J3^=ej!q>jggLsJU<;GDw?<L{P(JyGl%f_43g
zXQ|d_`&0%-0fou@MC!qJ;xA0t`&c7Pd8hY)q)daN9*;leiws#(Sg)-Q*rd5cuS#GX
z{+n2NSS#m405wSWMoR4FvzeboWoS0dI#)bxh5Nt%Cg78!Xo*M8WN5;z{PTzAxHhS)
zWa<gBG{3uACDC}bBPMWfjls)g)mHY9*TW3xFOTy@LnF=03{Fj!w*%qt!o+lqf!@y_
z?jfzkqr*yU1<ZG*k*ZA0<ycdtt?h8X71zZ58=8uyOJr$8KFQ-K&bwEJSVlY)@hY<`
zuO{|{(gAXbM}gzoOyBTr-GlA3KJb+|K2IfVmhl>pDjKzrhQ(fkWr8hiUH)d6C@WC}
zS~fomFpzma|1gVBrJZ`<&gz(m1FLKG-mbc8vGVP{^-jE*`%7Pr=ltf|h)qe_J<yP`
z;&-1hqpM7D`R4UQa>UPIT(?U4g+VWO>n1kbro4#ihMBbnR@DJ-z-sLns+d?<@u_t6
zXRlG)aYdf}+5~J=q-BPKmzL{z4?*d($GF<JLY2HQ5StF6if2>gj2e7xdS<srx%F8{
zx38D=%O9&V6%9l7KPA5bj>?i{bXfOte+>-})Rug#vPT}%vnC|!nz_C0Gi770h)3PK
zcqxQJ=|2fueRaTW)k1~5cJA4K#pP%%$s$c7^e-2V^*~PEEVK6&LA5K?Z|iLsoqknO
z*YI}q@`?_3O~Z|l6b<`4RP2l;XD07Efgud@QG?}k#XK;n@Ff`KFKHIyoe0Ht$>~q_
z1N&0JjZ~o6Ei?~Is)wGDj!{MKGL6>2?zJb?1LS3c@v>ys82J!n>D4Xhzpaq@h19_+
z*vLh*>&x<X{9U|Amw0y30{NUUXzdkW&)m_jgAbHmb+8vh`7is05Hi2FB3{!E;ALm9
zU4U0v?v6nxijQ*P&j~;WF_=SJ(ZOm@l?a4TN{@JYT>D6DP%XhDgWzmV+<5(1$B0gF
z3HJBHGPqo}(Lf<vME#(Q{)u+{@n0o}u?OGOh&g9qIpB%#8OgXh?QbUD!W}@E;2MXZ
zOR#@MMv{{qiAao?#v!vjS^VO~Eb$bWbkGMl*;yS8m_yqT98bh(tLx8W>$`X*;@$b{
ztssIjY3|zCR5xjyd*avkdL4&`s7#Dq*RSRWBkb68l(YpRPZBA=k0tOP=7s&6+%)p8
zMMoch*`%LVhI8HLUMZvp)I~pw(2-a7<&pMj+i;w-tuJv->2^&7u;kO6MdcNMfEqm;
zk4`RNM#p9;GVvVq?7X*5voB>Dttt3%0{4@As?*B{VTmQD+m)F*UplF&vW{%yW($g7
z_F1Am<{8@4j!4QS;wcoMHTCiLGx?3VQ$okUx;E@S{%S#YTY~N*BgQ9a4cbODNY$8L
z!zH=PwTXD<@oyX?<>5H*yyF1NDo)v{TvZfl5h;7=e|ZfDB)DTpYRkNQof1J~=#+_n
zo%!3(3#HR^=jqtb7E2pi7nu2BLn+DXy_n;D1M;mg;<vsT&Ec*TUv?4uzl4F-9tqPm
zv7>8fB~hmZfg8}}GHyh*?Y;iKEco^ENxYOi1QqMr^lqpgqqWDU-k3frBMK}^LbtTM
z=%okpA^x|g1S_q~XZM=~^fjDtsdrmHC77waamrC#i}9{ac`$mW)ARX8e7a8gJd~nu
zJ7hti@+Pe_#>JQgNOOjuL%@cFd;$osef3$BBMS#Q1}b3RjvMNoXgL>_Y~-2ndBWo9
znuTa&uYNjN_=|r23Z|ffS^jv?1fKgJw&_AcjM2sIJ<1I!ThGSJ!0;K7Km&DpxF5*Q
zq+<;}(SU3cSTIN0QHAn^@F;Gux}lfJaPuJ!Pz6fdwdqjTg}NBd^{WMukHW;Z@f~9o
zI)Kd{^o;~`!TIqP_x6+Y4kVEYT?VQ1#Z}Ue-Sbw9;<(2eliyR6Kmhkcrcsc-jY$Gz
z-93?#XqVCUI}{G?{OV|$%Ri|SS3hR?<e_|rfAxRMim=$JJbnQpCyJZ==>D^@kb(|p
zpZ^5lha))IP=CO`cYpVw-0=L<m=f*TmC^Jiul}Qy#G8EAI*qmKBxV8<gXV2wmVX%z
z1)!Uh9^p=Z^ZQ3lR-T6M^Ad1($BIKBX{!b(!{_n~r}Ybif5Y+JzX92<O80YbhVEX5
zFxElu4gC5d(XC@$r0tyg7@LdhgT%US#3%O;{w}KpR$S!L+R=u<j>UjeU-#uzWf!Gh
z;aFpAX=px(UP1rkCy(M9jzdiWpJ}MIvy2t0-JzN2|NdC9b|HI|^c)7Z?$54x&1f8Y
zje^tlRz`6Ex$QWUjzNAigu-I3pnVsHPV-Y4_*xN?=&ZcvI!mOTq>n{lkaa}7cze{T
zj>~tIaLt$u6xzex|IO_#uyerk%6s`v&L?ELR7@Rc?*2rNgUXLU1u_Rp7LBchW_^a`
zNjR{A)M%uckh#A8_9t$lu!5LbJ|nCfM?Wi$Ck_sIM~!?+3T{<ZSxQowbW5Vwj1B%@
zVsJF+`aVHq@9^8l=>#D^HiO8T8KIuX3eB6dvQU>+Mk`HD4=DfP_jHC<{v^myO_2_c
z?bP`HCr%@l%7WU<T?v}#g~_#D{%gsGQeyt6JcpAM;ZJqQw9nZv>Yn;u+f}C;r1~+E
zvNs)bi2<6xS^QHKthlMoTFbl7=fy6}?&?b&bA~amDU(4dHD7b=;nTMMX&_bVk@jkQ
z-e(+b`1%`+ZSa!oUto)P&v;yxw!GXeDCDiBq?qe%6il3#-bkB9eu(aCR(hNn6|MYX
ztRcy`x}i`vp5yQ)?A&L8HZZ98@Yt;r7$M%hKL{c~xw*)xAJs)!LQ<+RlxSj)qsvQA
zh;4gvwr_iP4-NX>NM@9B=*N4tRd~<!E9qqc@La1X(;B|3`d{#@bEU<Wz@CTqYp84Q
zb6bn$CyvlM>Oz`8@0+(x{cAeHI_~t)y2pOy5>^tGfsSr%Q}wbEeJDHg^g2V=%jbcJ
zKkRWBENm_-y`rg5X5D{t&Z`4LXm|~k6n|@E(}Af{gW`=jK}|cxE$L6y#A8%xp9Dyz
zxA0(z$C=lv@5tUo(HPEty?2}W83Onpo+MzdbrCM&;>b-cP6?b;N#jozPB0rZQ14$9
zZ!)Ldz<psbol&+GS(c&<$rG(!Z+l|FhI<Jk);7XR#Hi6FZwOi^?X%EGG1l82Tnx0J
z0~PZMr}kF~;$B~5B8th)$65v!d2$P17}(Ul{%hi@^AU;d?)RAK%-m>~f?(C5*|bT-
z5a@ictP2x6BsjBVb;HKSI)^3p^z6WarzZkQkXcZ#QxHA(pfYTTl&}1P$Au$QqP%d;
zEJ@SyfX5V?Gf(*wwWYRFXr@Q(2{$l$By9Lj8$of-$FcLIl&;By9SK@Z9!c^ftTtf@
zfUvH!8)ctpF;^4Vn!lA)JVKE@!dq-7ogYyDs<PZ|&V11v!D3cMN%|AGSO(T_+6zcw
z7cD#4Q0(dt;JI%?iSE}g31{rHc_eeU!CR`n&`weVk4v?W%F7#4?!LXcli_J*56K!g
zm<MK!-Thz`px}_iOyh%?ne{~|KT!Zz`T?@zLmpZD5Ih4*ZtnC#g;c-@igyBM-G;{m
z*=n1537m<@$V5X8dL?v!?j<d?e;&gAZfWL41tpXb)JriC`wsnp7s&mK)SC;z$X?nO
zB?C-p6`$(v8cSnp+&-`Oi`yBq9ncnZ%258Kg91u75SMhVRDeW*cN1dJanZChNK*Fi
z^<uYa5{Env@Xv%-vi0PqlaNlSj|8A6b}jv(Rf=1WP7ZDJ`2T43@6VMT>PqRJ&d;no
z>@b)OrOP>KTJIR+tN>>>-6sm{--S;vmcg5M`RConDV%)ZAH_Tw)s>%(7469c<L`tJ
zDtLQ;>-w0V=>jI?UkH5Am149t7Aj&DJHsd>;uOoI5VIXCa<;~)ci<QJfG_W`=WNzW
zR(6${NDw_eBPE7YdC<7zu!JgTijt}F_nM+|3|;mw&dT!>*T>@v$9t|rv#QuWK^mwq
z<qc+!`@*HFtrzK=Zyb?A!)DrjF**Y;C5<)jGI;_xp_z<5aMO!Y!}{(k{AV=5mIH3!
zUIE}Xx)E?Rc+!Fl?smx2gHr>(TClO&9XI>Dm&!|VF>#N92yY4y+hTl{T6<%VSuaY7
z_2g|5U1N)csY+FJ?ZTwJH;~**^meM5yA8X^W@IVJ{X4jRz+T8;fUhFVb{O&>;7WGL
z<2LqG)B=k;;5H2n>kG2aJLkLtUilOx(_V5060IW1V;t>XuM6oEWt^wrReuSRyh7fe
zJ8I1E3FpL|81Z2Fpf|M^cBKi*EeZT2QaQkJ)0>+I$`h?X^m7dL=7&I34veS2A3JaX
z4&8AgPv8FYt}sZHIkzh@naSK*6q541H*i2Q4hvU03zRQ1_qQPjE{t#`%CXrlvc`;x
zmag|0DjFT{J(*f8hn`;t4`HeatyylU9>$d)++|l(OVzzc$#nNAZ4%pBwwr;x%|!wn
zbc~5J<70Gswuq?!y%iwWt_DnVP@pjfGbYQA3(l3UHl++Mkr0V2m7j#|G-JgG>S4da
z!u_Arec$(&ns63~yD!7I`%Q!S^54t(A|vS1%z^=9lmY5znVIZaAFyRc`G4$H-nsBp
z((^kVC7PJaj$%H*p~t|a>o!p5G2O-AX7yF{wvnhmv`lbHcl+<+^?)<s`}%`P=N{Gg
z75}qWdTxi6F~7;*9x-=p6EE96KQD`&H;P3S$3I)1C$VHRF}-36%~2=vAtNaCd@KFK
zli)1@S|6T=oVqnbR8&;O^ryE-hwskiqLNYnW0CfmfUkHz!&+_~(icVaAm?rS4}SEw
zXXE2p*^4dvqoe73I-znpU*uxHBVNY_`xz55rO23y=r=Sy?LCo5tC`hFm+@$A;QpM;
zl&9QHFB2;BKFZHQBe#6d7emdGRZVTp$y4F-eO6YD@v6C@yr7O+soVPfx$urpTKLEZ
zSuW~pQ+l5&lrB3ROc{Po(IlHt?+RM$Hg!}(mgZ;0_2&ZR4L$htivbc}WGqG<%ozvu
z9)acW_#;)N--m6<aWF>IL!@z)rxreSpm6_kCR3)A{7V$ANJw-xaIX_5IS9o%cZ{K}
zrIucODhO#dZ3mZ;IcTwZ&f}^&B>P0Trk3_REB&Y~>fM5}K$l(f)9e;xjm71S>7n^#
zDBJ`nlbOmJyhT)pT_sU<$~Fk9KTXg0w25PbAR8K5S}H4Y&{=%H)Hzo~52iOK;fdB&
zS%*(p1Ikw&tYDcjZ{tqu802f?Mn|T%#v&>InTn*CydX7uv1iI`xs7V}!u100DAt|8
zJp!5$kJr-BdRWrw7sFljz2SEgS**TzoLB+v%3(Sak$zMkZbOd=c^C;dI=itPPLESe
zxB4tMfdGzG4BMwaslcr_GLYuT+U;_Qv|JlS-{WUa_uTRM*lA(5)PPks5d8SVj=0}y
z_Ku$K$fWkB1c48g&ALAiXL#p3FI#x(fBAISRjAS2RB#@AS8h5wQ^7q`K~ht~E|63B
zJ$w<M=Pk|hdB(8P<VIt8#Z|^imXCrNy56_0VJ35`%X0as_YmN8bK~?o;dBY(^hA+I
zf7dBPS$Kt+yN{QIfow+E&aOyScN{lsR!-=Hl1DonC5WCN2<FzndDIDQj}kqK*aJBP
znt25PuZDKd<P|CKd=pa1UWU<rad5XExQhYYL-Y=ek9vN{zt#io=TCkr9l;9aKVNF!
zjhaVM`6Bvxh9o-3k{_VFD=<*FQ9~*TpUg+g)?&(GwCV#;`)%!CWi<9%XTxg`7MQ5$
zc@>oh4P|1)#n$z-voFIJ=L#MP5_F(B!{cNvw%ZTf*mTB{YrX&ZMch__YAR7{s!*}3
zsFf>m9uE`(d*muaQU3JF=%R>!%~~e^FQb-rB-;>w=(Ur-l74F<3)fcHQRvEAFFSd7
z75NIxZ|rxY$cC{sRod22e^DDb$>G_EBS9hdSN`g$E4f))CsCtAi<udxsE?}|vQDGF
zpSC9@&Gq(mF}Ue8VQ}d&+eVD@E!oz1-L&}ovC2l}500n@?)zsgr;+*B1KP~{mWJR+
z{d%s`UY|h)<Ox=C#lh16{V!eQ!Bgb1FUZ53Vaevru<pyg<6nX@b#_a<oDY~mAj(V5
zB;H9f6503#6?}!QSh_Z=GMveyE851X`J?Z4Dz5@n#4hjAb_m0&4|=wS|AJOx*efxW
zD_{ES#EJf;p9(LwU(%PHd10-^urK)PCs9ik?QrUbwRi}U6E`S?hdiVT8ISR<8CLM~
z|A_kPu&AD>;axhG?(VLoq+0}}Q+{-JgLKEzA>~RV(ybsM&C-Z;NH+*bcYcfS`@G+O
z_qliG%$bvO&Y77D#>sw&SZV+t_hfY#g@8yr6<vuK)&*Dqkvu|DCSD{wsbxNr!v1)<
zhh;+NX`=jPs2XZOsH`OOV#}bhmpqxK*;g<LCI#<g#X!4n%fy%utO?A`Loit-^UGOK
zHtU_!s)zhRVIX?mKzKi2uYsjcWPQdf0Lt3qE5GP$*v^il+m~Z6ES&e>byEY5FZ@}n
zNqA<ok4$#e1=Vo*5pa9|E=F^dW)`l?dt#<p*ocZo9pZdxEqC<e>~abWy#_~}{0Jz)
z>y1K})f995;92xjT>I@|zkeM=7)dDt04a~w=#qP-OTWs-{HrT~nD`=iNSiGCd^jXQ
zU|CNZQ0HNpKc?sFMwEATnU^-(>`%2a%>FwE8!ejbqyJwjLBKS-X!V_IHEWCk-AXUw
zd(py*^mX~Sm6iWNqn>(}0jvF-ZP7xfl9F92fiWV@!@jCgB}AOMt$c{e3H5t_vJ-1u
zRVGX)*Z}vJW~K<Sb7*{=JtCx0^`!Cj&`@`M#3E%r6bJqBepiR%<xkJl1spbD0K}YB
z(#h*X+94jj;A%Tdq2TlJoZ5$^K=qOi3FI;A_+MAE+1@IxoIDfSNe`#VZ?Hzdn996$
zp{imZ*SOlEKHcCRuRH(jq5RoT&)LPt86BaUF!xL{^0qAB`wNcx1_MOkpzxzkNCcY1
zbjA0`NB=q=pekhMg!K+C6}%t@Fb0POQ38yeG}>LiaZSGKd~p_F$JYPQKG|;z2J~B4
zx5+=K-UVHXCvFNkK6pMoacxqqei~;DRFB14sPGUXtrWtXLdQcM`5?8TgRh?;q7Qk{
zL*VRM^o6TQP+NQxFXlHeDkeqiB2RR$$28DMmG$_8)_$pk-_M)j<L-Xn^pvT7=Vkn>
zgYFI_0kYZNBIs0%7#Pq_novlZ_<=N0mltRWrrzW&Oi3)X(VY%NGIKM!Mj1SR_bj2$
z(0!K<7OYYcV1G2WxlRhdKB7m!e(Z)yV$)|;4217H|Bb0x2<Tc(_>1RQ2fE!K{((V1
z9*yIPb>UC)6nA|}w_|}v40l^~lwa{$e=x=Vi9*)-@9+Gsd5(?BH!7vSPRfef%b9hi
zI9E&sBeWB9Ibz;xYl5IIX}E1o=pwC(bf2eK#QOr?%>VQhO4-ukYb3GZ*Ok4}6C4s$
zKFIcH7>KJk&<wh+$EK#c(`&GrE5E5L!A*SBG4vth1q=@?HfS_rxwxfedXrJGn!Fj#
z>_$*N#op;Q{*W~wK1aJ0BgyILdwg)XlZ@x_qw|E^!Ssmk%WrfkmM;#+|AUqycLaq`
z0nJD~DFT8-qGp)Pd~Axgc%Fy*^>mpfz{d6$zf`zkIp$xH=jFZcLrTxsK6MBsjQZ5%
z*2W24i@go|xLrwSPgZ4!)k~NKl)HF%^QCGiRjFC7rZ;tylN`B6VJouu$|u-17QoD%
zt(`MX&TeteZjXyfYHC22^r6L1Ta>4FYSxWRt{eYZW*MVT{9SBkI-H9LLjO8Mt2yAo
z*&P@d^WT>bB2?AaF72nzB6onF72_rpeB-ef2ZUi(Nx^>_6C!~6WNCbUCMtdNZxqC<
z39DOu2+gC~erR-bj~Kk&;2BtT)6|sjg8cEm#0g!>J|3`Wi~ZwEp}YoJnZcPG?Z)(-
zf^O0tS~^86^G-v@q(-XizHhGf6Gqh4@~Yl9{S$f_Ju-3YI!qbJH5l={(e_}pvsgba
zn6sBMP@fl3`cbu@Q7_H{^kt480kMvlZ7(g4O&<%9e=gFX=<e9`eX^Q2qO?F&lCKw?
z3H<i_u=@w|J+-X&oV^FW2t2Q35w71b`|jW1@~i=k;z!(o+>Bd(sl0u>kwz}u^&JZz
zLU1R&<do-YQSb57*<jnvfRF3`;xW4?CU$bdfA|6W`U!r%SYu{thE)hBwZh7x<S8K3
zh<ZJUAOHXcrGe>bEj?n}TdNcVDuy=;XNuErZvbB!>s}8+EOo|1JmTv~af(oBEP@i?
z9{&x_5*RlgjQZ__*`$xd7m=SAHNK9r)KXV2NzDA){2F6gUA|@oj(hfB_A24)_4k&n
z#V&T}FZL?@%nBNn59`KF=+UoAXativnhU?NL<YI`e@p{pn)BLhQi(^CK^IY6?aA)+
zmhhd!s1tgAkY@1azpuw%aZH*kLEl-~-&7EExOsAvOiYac((>!nb6>d=tF)4O@!@wV
zLnCZ?$sEnZ^<HC*)PXQhUYYb}`_i1(A;CTQ`)RsUg}_nhu3!E6r&UHI>W+#Y<>(3-
zs(0?nI-jWzl{HF0=d`@2{JdCj)36S=sQRdtmRMCtVNa0rRg0fJ0nnsfUM`!Sf(pWx
zqOu4eH1v`mdks;W7x*kkW8m^}i0SGlq)g6IxT(vot*(qi-cv$4820w4|IJ^piY_Gr
zhlQ?6ui|ta>3JP4CYa(|UBmkD90qAUwh7~wk9csU$T{zlYI87wcrMKN6V0^i=8|~D
zSRCl@G=8oz+&-|HqRip7qM){u#+d5^IV^A;_M##r(Kz92vIv~I^b|)w!uB^mm#VAH
zL6TuS=34!!nQKlD<t-A8tp-xRb466;N>S{nz7zQ}0IG)*4l?2qP;~IoD(UuK&A<DN
z<vt?2A@{Q<eotQNuI{z_$|lnT!9D4DE7I7ydEaU54W>-iy@!@)E>_cP-F>(r-5y!%
z5C1C%Co}FhS~@VUM2Z{jc!VV9z{apMqD~c%HsKZ%tttjf$xwZOAML=Ba7VyF_zyIS
z#9?(2mG;BwI7Z5zKs0X7jxEa<mB-z$3>1hH|Dp2)mbpBezIJF}Wz2*dP73EM8iF(O
z1jG7(tv%7^Y{KXL`{E_ndl;8y2Heeragp6kBuict(gf+pv_PXppo!PK6qxL#Pe7r%
zY6(hVeS&P8EBIYKZ2HKE7R0>=r(SWTm-r4krGEc~Z1#xWP1I_BzT844OcFuS@zEMM
zv&r6X!MVmeGXOTNy>%LYkR)F1(bms)+lDpwdCNDTFX8K!!!=At4zjPE<0Dm!b7aQK
zY-NP7SC2j0Yqq*4W?VXiRPw3EX!0I_CM=>K^i)l<;r*5Wc&tio-O4SyjDE!;>1-YY
z=R=61>xMk%0Q-DsVBb-*Ad86DA}YWxKXdN^J}((TE3*r<3k#51{}5@Ka<Ehn&k1)X
z!{6yQl^p6y>$hZR6osKv1vG?ghUVVn$!phN1YrO$9s$925Mrkde%Jp{=LO2fUN>n~
zGM>ox_g8v70m#SfmHK9Ty^LxL&puiFOW6Kd90Z2v5AG|seBKT+0<##ewWk-ycUMnm
z(gS=tx<JH7yBttm#STw*hasQIBR6H8;uk%^B3nRicg@gFS=GgofE!j`+R}#-Gkg@A
z`N}%A@u<(AdZvcIlCogPK!a?I&O9qrMgoLeQUcYx4Kt6cme(@N-b&1WEFkA=AlU9u
zq5}2*(C2M>nC)?p<O!w6Wk2t-f2ypN^i)Lun2DU)boVjCQ$i)l?&{(3d)8*FSfNpn
zCM5r$v030+oClV#oYFS+{~^wIg~`o|av$9bG*ee?)8s!xD-cm(yks!X5qI$H0CZ<i
zWE2-SwqGcn;cmIZro(9x%4<E}XxdBFvg0ErX&OGAi}t?)K9kaoJw!D=liT~5SqIgO
z$tk4>2&jsf$+l6qUtZ3%E$B$jEx};JL+m-YmM_~~{I5UO>GeA1My*fzMJB85p(Po1
zFGI`r71~wpc#ZjA<o^R(82Hokx4G(iFs5sycDhuCG?rYQ=<J}bf@+^XsY=$Mn}!^g
znkTG8SRGaFkZc(1i?+0V?V0lQf6UU2pW>HKq`5_w!*c7#ul_dh{+~diES8C;1*>Xa
zUDQQJ$mpYTY-JswRYemiZnj?-dnVFF#d+qOC<tn~4wZGF|2C4MWfL0L(+T*t*)mTw
zXZ36Q-8?3y)9Tyo|J5wG?6BsqWt;XpAnb35<TAgFivW@)Ch~Ibisi)#2Kj5N3qWcN
zzWLUBS~!%lB1(U5%#ktu>+m50McP)=8WEr$Dd+aX;u^s2>4qe!eM+^vfanriF%5Ux
z6?AgHp@i?Vs<+NHpAiHvEGSC~gmwc=a1P9+<ycsz2-pQ_roWIsgn6BpQ{#-uei)U)
z<0r>eEpM&98fa~0PjXQ-N>J7MOU`quP?aq8yCW<q%<wb&i+6Dt)Zp$G3IWeLx}oLN
zFzm_go;E83zPTb0+Q_T)VYK`~HdX<4KH;gAWyOa&0Ho~!Uevm;0Dv|5L&&n5YdFW9
zyWpz<P2aiidsHa@pIzb`tB+3;+h0(my;02Mof5iRR=;(TLqh{UpZ~z5-Rz$ShH03e
z*56DOqhZ?)j*Gkx_A3v%(}=r0+T&N9eyDU>T7oRrp(pjr^wSn4Z;CzuT^EU)E!Y1~
z4dADIR_uynI^O9X2M#ahs$n65QL-&HfIbp<2W#6#%#PDO90&#~{mv+a{f2gQSZv{#
zJP+Bx8ChZ_z5^~S_eGpf);LoU9qArO3Icmtx?$z>)P`nMRk0c1I`>1lwrG1_>g09m
zHdn*08ksr#+O?<}2e?1hh+2(&G+-ruHk=I8*~1WuF#z}EYG4OyuN>(hp;*WtCZ2nm
zAg=MzkgRL{<a9dUjyWo%094yup0a(}VaG$4*KY%+9HWJ%-QhW4T?Qm2>K;7~@FK)7
z{`^#?y`Je-|FWnpgMe-~LX<1stDjUmsC^m}o9i}H>9ut?`sD}^e}cGfhUjOeHOOib
zgfU#)qI{F)yMj)GeiACB8fT1tX`)@U-CON7T0{V2H8UCgTlB%@rvn=Fz;vqL;c5i;
zg^A^(njhQ#qpI8>;vAE=!PC6?VB`#0VEger1_r^vx0*1ss#q+~MP%?#q$*RWdtsMN
zm+=a3ia9C7o`h1E6n?Mx5fImk^HmQt(vS{$8`FiGN0sEItI7->@|&9C$@qzR#>Vhh
z+Az@;E@Z|v(qH}gLaqvB3xtEMJxe(|SW&}FLp$-OEjQ2Br0@l#-F_~$1k-Pu76Av+
zP+i_e4P*)8gCe1*l}bS&DQp++V-_u%KN5>%@TjbWGE%EBBQ}B@Vu`QE)3B65ehNs-
zoJb~2+Lwqi{8%$m(^#{tQ!qSQOYNy<D(O67R_}P2wo{ealE)_mF^8)425HY`JMi4N
zT<Dme81E+*?XMKcH$!o{6sxrBe)AG$TM(`&<6(B05}f)Rzm{Yy$-)lIZ4SeQPtHdh
zIfwy_%VGX@eG{9*JmPErtG53l1Tr*_=q1AyEQ{S5CZKQ}p~NeT%gcMOs*?A^^g~vb
zyp2D77e?|26FOR?^<<puJ0;MS3q)I<WS{SkRJQtO;sNxWUubtaPqX-bJi;8Be$U*c
zsn?~aUr)($>Lrg9u=!sQ*SXP>X0AKJ+-$`xI|_V|tKOiZtksjxbu*TTVB&+1CvQmL
ze_v88$~_p>1-$m9BZt8m(n~iUL8ni(n5nfeJm1kWU8fPjfP+YTz&+ykcd`o7;Uchl
zHhr(f3m?9Z4s((f8)BiFz`0Egu@nPo_nys-l#oY}*!+Emj98$LqrQj&fCJU0mM;ql
zBiHMJFfE6539G0y=;q($CH|;AF9i%AMFeaUiPdz&$4-w3jgW!HjK1Y?XMNQJ@VM5k
zb`DpFFrGqj0ubs_SBAhR0Y6p-t0UIqs&3PqCy&r{bim6fd4(#L88(ef4v72>!Pgwp
zV!9=TxAc}NKrO2G4$B5ak;QTGl1r!-Q`J_!zk7G{>ve0%XMQX|p&+1wo(_)S6u0nR
zU*x1X03dBfucx3swN)nfrr|w@lUB|zZ3@7VI|~nDfdT)@k6T>0KtYtkL*X<cpvW-T
z2UI0@tJ-?Fq8bZ|K2{pyO?YV@zeWt*z<rqyn2<7|=Z;jz;gejw$eTM^@>nRYl)I?9
zGeF=CqUb96i+Y$((t~j~>%51GvHKyUiy(1MI?qJcc_^h@sD}kM{|lEFHDR<>acspO
zTiIv(q(O@Bt0lWS5LuE(L*d;?OQ!Jjfob(`|7>5GA%cKeblX->Nr!)$5N%$Fu%EKq
z??H|2Ur#^V;3m`#cUhk^_meKNnUOCf;D1$ygU^+H8fg!x!<cP!V`-lUZ1NTiZXeVD
zQ-1Xi60~pc$cqg#n{(MnMkdm}h|s{_>m4y{4VXq%(oFTzm|ayO9V3=?hiP$*XD+}m
zjPgZ<knr5V2nQDF8I!1Rj2w{=;YZvFvAB!6BmK!u0I%?HQw+#H_s6oh;}6{n4y3KN
z6n%(;Q=(qA<JczFBmst`Y`G;^m7H<v4WTq3pnoqskyT&&^iP%JrpMz2>+*^x1HeQa
z<{IBt^L{m-)|4xZl9m=eeH;5)Dkq?l!q~L!$E)>@XG?70xF&z=NeWKGU4GI^Gi%3U
z9GF$YU>Ph@&vxfKiS+yW<F!FJ#tjSzuzC!L0Y@i9koRjH*G_SWU0AB$$|ln3_D+3-
zX@@4Z=&G3ooS;TXdR=z$$3d~WU~~yKYacl@rFP=?_@a&5rg-k#HoDI>0p@vn1QY-`
zWtYRdG(cZ>SXeY+`c+vD6rX2bb@5X9uv|^DKB~TFhhIgP?IM+Z_sg{7>F~c7RxqWh
zkqG1JM@G$lF^Mw)b$6*;AJ)`suXGmGJ73&m-%k-rw3@W{dF!S{!|BEQ;d|@88JmqI
z`W@%ca<mEBMG0wucVnqtupXq%vw=h#b5NFy0qsSCd>B$(K+^D~eu0bgp${3#XNb(F
zE5wsPAmN1__ZO=?q6xe7jcI`w1tVpy=H7$hbN1saub95)9MBSGYeI5aZklp~B$Fci
zX~R61XLO>h7JOke7;n-cLG-SUP`R3u86M4Fn9*h02uK+m0O)<prvND(&n(^ifUgt?
zN~$<7lG^H~;poJt!~LiqBY9!&-aq8=P8*{^b}vA&b!6cy)|2h>fcnX2$rmIbqIdO_
zLB#z4lmZgOH8b8!o5^%8Tj}Ef?Q>=-AZydup|mxl?*Z}GAJ&Q{(*tm1>^|s2wo}TA
zOnQDa(ZT~!S4;Ah?$6WybBhjR_E%5Vo6V6bE&yRl)O<MY{$T9uhyI4gGWrm5NVm*F
z3<BYurb5W3t7KkpyDwU;8TB1sKg|B`cZ#e*MF&8Gdj5Z1_6+tfrh1>3<l3B35<<j_
zTSN=Sji{$Y<i$lmc#JJgwcbmMY&CNwBVMEW*&E=Cc)WqtmJE-Tl*jXxlA{#H<-upk
zbxXO)IJ1>`2nE{*1-U<oUg#1hOd8P$rY-^_Nsxw8gCeD|1TUmN&r+Hk$FeSN10L8-
z;h7=YI!Xk1wEdW(A8xH5TC5*gtRGVhuN>(o_31;bTX;VBT(4Zl>wgBWEhu#lMhtzv
zj4xqfcwtj|7=S5V<APK5+t9rF?=Rj|fc6QuF@Rmte}t_du!Sq2tdPczv(oIvUN|sJ
zxYXMkV8?&OLla(b&+JPEAO+lD7hczpv!JaI{*TE>AfI@c!$M#T{1x&(gq_9fQ-neP
z%xUAGbc_ZeRdj36i%ErnhhklVx4e4~!WhEvLT8`4|NBT8i5$xw+#Zmh76F1c0KsBP
z)LiT>Y9qK{l7QbtwE}_Hm?fgwucX2M0B}9*uc|YMnyK$;;KjXjNFG5d|7Qe(>~FW@
z5rTf}ocbFM81N0ApaD2c;dF!y(S*1fAtf<Pc=*0m>fS?qI`ST&12Yr4-9ev6tFU^0
z&zpRJH#2uCJjx}B20b2-Q6w_3BT8E>*v&2a=(~>fuGX-7zj!Q|PP|pvq1CrdL!2tl
z^MU;_)bd--hhds=o~Dr>w*@~c40hA7d`|3u@V455sr$_8$H*TyiHe?zlz|axKszo(
zol!EYN?fu*1*EuHtcbFa1Wc^n7pkbF>}W|f2sl~=E@va4{aV_cdA`0E|8f4bE+714
z*9ZS)U5E<9%Vf+q?Crfm=0rcsO+_M<B;(xtO`LU#HO&yiO*975e<O&4|IS$Q1ywIh
zdN9x|p(2fWt42|fWmW4)ZOzURetN1XT>;XMGMVvjiI%J4MnG$6E7Ca{sv~!CO8qz_
z&RX8W_kvLqp3W2F*`il;)A7r=q+&7sb}c$dsdG9Xw@Sa?6AkPq=KVk;JbKQt5$^o;
z7*cZZrw?tBUPl(?-i-@9Q$Ss*nxTDos|xI0ukd?Td#yPqO~gggy~QM|LBRx?$^*f$
z=P@WO`1Jar{pvwvD+8dmNS0IDJl1u;+Hla-x`A0m+?2jEi=b`K)b7^=DLSe@0-ZB~
zwhseSPa=~aKBwRBt#s;cBYT7;Y%V2z?1BT_azFEKQRzP~Y|}c@n&&CR;G1{FtU-QK
zK6}TZ%I}vYP=zHAUrKh2jdoV`#f6H_p)+}CUbq+60X3FZ3H^#sGu|D>_je#&S&{OD
zu<w$OIG;-SB^>^dCOd3Go<n$MdgPb_XgL0d2gahGvpxm7MO<Gv5+4KQf6a;=dg)^<
zuD=nFF5)eSXR2d?Ne5!pu3_rabqgMB`1lgHdZ&Ye4;$cMv~|Ue%WyJw{WfNFNe~66
z2Wxzjc=$}g1<4AdP*W_GOT2lK>rKhSsXqMq408hUq+?6PIF7l#>SjtgvDYX#0nXix
zT{;9!1lY~F&YiQDKf`Aw5r=;@Pc^6S+s(1d%A$1mO<SIOuHn8xPQ5%jpd@9r^>-J@
zgGtpnlPH@RLM%^kOKh5-7{y}*#iUV4vR~kRVaml6Bf|T0IbuVyjEQh4RoW#pnS1*{
zHf#e5AroF$@Rz3gJ(e(pgf?vCB<Mo|JCRp`W$1Upr^*BKIS~W>gbqM_aVfsHfI|O%
zUo$Y9v^3-qDf#7&!<El0qkDitIextdvoF`BPbfm-+o4Fy%y1J`>l>`eEWqG<K(pOV
z9TQ%P%{^KDp3xm__#!}W1fF=ZSHlhFq_q&G^9!d4W$4>bHI?-j>>^qej{EQj`NF$z
z{-dzn&<E{1z(ZS@5IjW&0HZwj&-xZ|S=X%+8)2#l+DARS@01ssbhO{p|9Us6Y-(z3
zw|O_zuMgDK{U*!vanw!Fq?e7@l>cA2)FpG{QgfR)u!@gkzWA{a<ApMe3N(waB=?=Q
zq+U%-mrXVun7Z-h)w#N8A$H|z<97TGstxsrp_B_z;#mz+e|U4rgCL2hcK8t0)CG=3
zWGLDh^QA;JG|o1EiIL$s3=YpRPfw$98$O*vu4ZDWKpFfL$<KaF%Q#`LEJ0tR;sg0i
zywH=zb(xp~{N1p-3cmU80HPFl!scR4y@i|XT$o6#DFbx1815Lx`{DWfg_1{l334#)
zpQSG-p>t!dqY^i$Pf<J>b`TcatRWztC<|g(M6;_YG0tz|0)&_B8GoI;jEJf1)m1rM
z%l?5WoON(0b|il;Nl3mQ!7RZ!Fcp0NS{0-u2<Z7QASu|qKKvb$_8%9v5al?f@JEtF
zcp`xohLoeMCWhFwsn;g0)=91ALh(O3l9t)Le&b6(n<s3{Mow^UBSEet#}Cj!R$kQ)
zbu>hZreC5CTvDA23fVb>e)gTdTd{@{J{+`*i<<k4Lt%k+7`M!eOmKq8$z*)#tVO!W
zK4{kYLMM8q(nay;&b^sS2ypGsI+6w!zz#*sU}MiC6~0M=u@ym>@}ToI@y73(k6j(0
z%5{C&iaudL^gUw`s_B5ump*Hbjo$Amz`A9)RDh807#q<d$JKWa-$hHIbyk2rMz%~%
zJ5f0xa|cyO{4&Tu7ed}wkTUFKIxBDnveSk+ll@|JI-E>?JZ&1B*sYha!G9~fEPQW-
zOlIWt9j?-8EEN-;#*s_H+s3Y2gi;yfGy$*p7N}hTF+22x?fHez34RO(ZDprtP|DbB
z=k#V2L+>yoZ)?)1G_>*#h+)Qn>A-qq<vUnd#>Z}$$&2{=ZE(jXClQqi)Y@M!iB9i#
zqP)E@O7wLfjC^!!+BJb3OD5xP#U9CjqwMVSzY(B5KtMknc4MWRAJOKm9CRI^K`*8>
z_9GKNY<#geDCN_QHj{;`cA|E%<bVn?2zic<giGF#D~?G|)nI*JGj5ujxXC{L3k*uS
z(RY@KE62Dh8^*jP8+^X=j&K`VVyAUA8&6wRFr$oh7p5a|H0_P9&5n<Q+A-F5T~Ge2
z>%f>XOqHy}!qYO#)?NAV_T7n(CAEZb*(6^>-OP(Bc1$x+>@{8uR|C|}S7(>nUr*!Y
zR}4BPa=h;VtO$o&UJ$d6WQPJDA`*``D)q5eyHJf;!X(HfWfadjEaN!PTMiBF$sXqI
z;mAPZ(kAmwKd+3}I1tbV=Y~e)?O=!IB_&bVlbk{zyNL#_WjmQHpH<#_J|;fi?k}91
z`0eCC&)iG}_}!?3qx+26;efCBN>ZBpp*yS4<aLMujT}#=t{#e%_X1q8*rL7eX5w4q
zuD|iWCUyD`bwxVL31sl)Z_s_T_?{#Hq0s>p>&1q%DMFd3bQ9G$mk@;RG*m|~X`yls
zSm7`EFKIEs9^x=u5e|}Zda?L&ERxuvO4sP4NPcbzEA~&wBUmNpffx^!CqGY7C@-WN
zW{Xf<`*KkR-@15XXoEfLW#*L4lp)D@!S+6>9zQ5hNv94&1K8Q+a4B9a(pD_Nw?Gpb
z;biL3v8k+X)v&TGozFC16~uB<1bo#mb_^GBG(6s>W}1seSEJh>F>Sv_rz|oNGeIUh
zgu#19HDRi`g;16jzKd9xNo?TAwmjitqMjc8{DB>6@-d6v{17bjUDEHsyX>}k1|F{<
z%l{RBJN$<%eD^1FMn<<JoR=nw)}|)x8I2_CI3GN}-tLy1haY1?FTRN&hthwfAMEvx
z73kO7Q4NQx!RVaC#SlFe{kUKw{Q{NjdIj%f{w)x0#~0RCI<0HPn7K3lw66!8KQ(_X
zTsY_myv)8NE6?1_{m<$Z0Q$>95X4{NmzP6fZMbmB&K40QT2DORG>pQINUP>^%YtN=
zyR<hg?SL3cgA1u2u#(OCv$e!ZXE9sx1#~skL~PSw&jtRi$+kLs<E`^wlmGb%*3G?p
zgH2ertK&>wT2<N-44#Y7x1y5Gnj37<)Os_cMr2i|-qEO01H?VF=kxx+s}SW4zsqx@
z^evuHDUaMP<=LCQQEBPdAAtuA5eXnUTW8s<rlFQkb7hE*I$9|A4X#{+P}hW@@XE!W
z{wz=sM&32?9r`LBSu^(!LU8w6(N3VoqeAKa8Lx^~Kfz?1`maQMR`24s!)7#aEhByH
zsTt^XwNg6>b2&#)^AuD9^CkNj`xep>TK8_?Af*Qp(kjKsLd>PlkV*$ao>Nk6yqK)(
z)F&EosY=F7FdsUcQB^*?k7C|WI`KnQ1iTlf!vU5<*%dETgu{O793d)wzo?$gLV%P@
zZlc-mq<9t~B_vkl!maGf=&WAmmrHdW6L#V&Z=}|95f4UzA<N*99;`TnY~ZOs0K%4E
zA1M$&*ix)5rkm0&X=!n9&*#q7+pfOs$+6I3U4p-tN2oqTQkG4X?_5aGBWAhK@$qYf
zDc8kvn>7&T#TS8YpPA};!0;vZX{CZTA_#8S15c8(v|nKn<I??Q&-R}?y~Qc30Xa@T
zS@p{%AM>LonnAw~`7AgA=~TUn7GCgtPI0`RMbMUfjPXu<By5&aQxE@n&!00>Y*7^P
z$A$H+8MlbgaIHwiQRV**Q06F!ihgx?kM1Y`;dOguG0WmM2u6s#te7`9!MDX?$ucYJ
zdro#_!29Om73<glze<4Ir-37sf6CIUJ?3oJnfate9ce+Dt+5j~nmz3cV*C<|ZK-WV
zY5?DLkk)`|<jpmR6pwM~ha{AM6=Dn3r+oeH4)cN)3z3?}4BA%sbDc;+Q{jWTH2V7w
zQHSic1P)>LJgKjLPsmXyX=E0&n~*ew&Pc(wMgwKZ@07#&^l*(w;L4gxFBkILe!##C
zs<J|TG)eM%Z+XNfhmJ?G{yD5xXsQucJhlr=231x3h9J^J7b)=VMLo`HknL|OZMeX<
z^a!W#<@Z`i#!TNEuVm@kGY6oAf~v!@qG>OZ<fAs+fe<Ae>p9^cH~@K>cEcZ_iQv1|
zt)=0jhs=WX!3H7vNo#C!fR-g->o~tu0N|g+a!_c^ctj0b_u~!8p#z@JBD%MNCcSB$
zl7leFn5okLTE9v4EON3VSS~3EB-_j0PmeZbUcQHzV5XZ5q&ufg5-b~K)?)?jN_HM`
zX`tTuAnFhibL%vHDx{uM8TTX7aEZGnwGt(HYwBz5;X>HR|1FhoK3WSi9V=p?6)q<q
z(DnxznL`x{QKaj}@~cR*&J#gD!x%g9^qy6A`EpYr9j*_NI!u{7uuAweBIvbE8rPD(
zYwhR05k|w+CVFr%DjiZWUJ4X6lSaLcv`}EuekQ}@sUn1@qD`2;{1=h4=nyGTo6a23
z(R7Z%Tg&Gcds0(4*HaN^x&H8NE}W6t(uu*s%XG9ZO1%(H$sG2(^@-gv#77k&S<Mdk
zW+g)j-PjkUAbg+W%B3>_vWSzdU7dV`bRl{yFj_7k?T;WwSk35HVHsl5Z8T%euL9qy
zpbQ>Nu`%{=IiS$K;6TYc&oGzRJZ_d6=ypv$JjQ;@Rh4GRb+K)P`EXUm=U$!m3xMlK
z3P@tMH#t}0+d#q-AHd<7TE19Uvdp?1R~~l6EsVZ1<*bC8KDJikylN{hu<jS|Gd2&Q
zo0~SR@$;&x5<&lncIqL;Z;)g!c)8EApHN~Rnm*MZ*$7M4(SulR(V&l;V(xcITo}xk
zeK9awh;lOg`-lE&*0PBZBlAx&$Y}jW61i`L7!rzlK?doEMG7o_@L0%9c~k8@oUyK{
zrM4}nIh20ycx+(y0}Yico^~GdBXG0JzU0frG%OnwJ@)+x=^>jihLeJVPsPv!hi+8u
zOOE6lMbD4~&}pHg593gsoCDe6dH(!qWSiqUaItA5UGY1w%kUfB@?lQq)J_$_c{*Pv
zz*JOQtZkybH`D8Rni%5*dz-b8j0`%dNj3Dg*xdwsZ@QVDUqofd5Z(<k!24Ac>Cbq2
zp9QsXrKWJ@@6O`y0MkJs_~To-V{c+X+ClKURd~_v$)^t0=BuCb7x<e<Gi<2&6bDJk
z&KPsirR`&b;1C%adOJNjmA%Vde0oG{Bk|nF(Cc)+*j=nn)u>vLGLt>iei0dhZjj1y
z3ptK0DK_7|wu~#{A4=h|pEmbvbW>Jp>;m&fa$!?MoIG73ykEt8B?CQLlWcQQ`9|<6
zUP21}o-O(QK8j}Jd${%dTr=`fbhE@q(enU~?I!xQU|Fui7}dl^Gx}PCnAx{@l?+f1
zwB)D}9na_PMt}P8?&O5ZfC`}z{HUt3P5p0owm+goYv{j-@?0GXp~Iry^;L<N4xMby
ze_N#;JSkn$>m(`M*uT-<F}U$BhvP+datQpr_t^BLTRb|Tcv6LXIjo4PCYy{1vG)m9
zSNz7GG?jNxngn`ufbDC_Zur#SKFhdsR#~X>L0kC795_Oy@Fx!=EgN^eyYS+&a5^>5
zE0A?f^9KM6u@6DZ;f|M9(%E-Xn8LVu>?Ka<y{)ReD!gs4JrY}y3^|h3drd8BJwqn0
z*Z)vjHS2T0p7Cm44VmSCR6Oz{G3VGm)eYQa^+yhr${SKO(YyGYEI+#6^<03_dz-pL
zQd!%$D(%KWuTK6-5bCly5GfGh&f%R*X^iS)xxJIOez$szlW-f524XMXpdw2Mu@s5|
z`B+%@P(k5NvyONg)Xx=X08J1JY%I8rV67pZ$F;+GaDOP~yXa8l<x5d<eXFRL0W9dG
zt<9d>p5_D0Bboh(zjvddo55&CerFM}b6tN!oY%8ZsKYLJ0`5LGVv%zT^%HjKKStmS
zBv5~CrEv;2|CAeaG>62FQE|F{!x9`(-eGWqLY=$}>}vg5W?;6xDjA6dAX35te9(7&
zTflN7xP$lh`+3SLIl8H)D>V)|WpKU%Hq%cpc&JOajnll%cn~Z~uCS@v7PGC7Opy|D
zwwt1r8-=PQLLF5E-xk#4p)x+W=JWUR&4V4^{4S?>fj%Bl5Dir<!znTRV^w(hmd|X<
zch}^4wG$D|#Oi@+fX0D^53p0G<dWw71GTqASg(6>Ex4q>r0^V!rjAwz?D8Ub+33*t
z@UqcCPGKX2OK5Et-zsL8hBqF!vajey&W@{dh0QM`veC_QaT-CJl6guiWLn<Y2}5fk
z)czp!$E~Y}LRvHYs>Sx7YVhlW&xn4;QKo%3<~v)yaQqZM_QCq5LKel}&;MfsBOGVP
zQ3LRt%lxKf4P<9SV6mxRpE()brTkF8GGFvr6Bza*<ST7CQ2O1-=}I~MmK!VK9G{BM
zDYY7QVDf4v<cZ^!bLA~9j4f(uu^ip1ZY<!2b04`aN;101d6nEUV~hV%bGkD~35+S;
zzL?(Q*~*b!7R?I-&uvWhvt-}|i*m#A35HMNk;*q`bDEN#ChIhKanAm}GKwDY7`yZ^
zGWLbrRhF^RX)84}`8iQqId>H4HnXREqFPI9(qx{EB%||IDqF^m9hId|l^~xr%$A)}
zS@I5+UFDX!9unoUsDj^vI*H=%bHStl`c!(08j_|>YMyON=oTj|%$G4baEa!I;f67@
zG-bU20=k<&^ZNFvNtq&xvOu+8v|=4H$_*<$wR4%2jElf1M}DLlsNJ{t5v8ws_!@tg
z=;R~pmQRIz$3jRvMOn?qjD%B#4Mr_8<i_Hy$|fhyEYvH$V&Pd&LjALx*qi4IF;tB~
z$<FLI+P$MFO;Kz-1<;I?naZ=CqedykWSQhi@Txx?#CMpdh$7h8FG*&l=rJ}?<Oe1R
z*!c0Y#VG9YZCTU_Z^<L8#FOegAVmb_Vdmo>LgBM6@ZT|d%D6F0rTv55HN~79_kk99
zVUVp=>N;!A<W=hmSI_#5Y>9y|dA{?#f!X0&iULv&l0D)_UXZo~BX@sETmkPX|Efz|
zB{-u&F!?`-a-CmA?g3Lx4@wJs2^gzfFCS-+Qnsl+&$><yg0Owa1Zr?pqf+N(xHU<z
z25*I#FT|77i+K;Uqu1;W2+rdxY%Wt;&m#t;T(O}IyQw6>g^cMisvUo}r*R%-z*~n4
zEI&maM&h;xwK)lzHa~0CPQtkmQ2%;o4c&LAaDg!kW1yOUUKhF(t{I@gL>KTBa~bG|
zzaxjONNPesSMHAMij<+cAkRkiwc2Kk<9TAJz2Rh4q4KsD4@NwynYV43du_h?ph}<j
zJVIJMvtCbEe?87Ab;&xiIOKWl5#I_L{<mIawwoM-jG9LY<zA)Rd!90_j=BHN!JN5d
z6InbdpcT%oHZ(_Byx(LB$zuL_S)W0nZe^y%<X3vuP=SOli-Q{LmjwtsK6@380x;(B
z-$W821&HRPBggFQMB=XyBkc<~{j2UR#|;)d!Te{GO0+lifN0ZNt6IW@3PvUff+mSw
zFUeyf!RfVpcAr5EBi8peSc=~ZB!iKp0c8Gvf_VVP-w4j0KPE2je0bU2T#}6zFwBIG
zv{m6}FHW2v%UeCDEBI}b=3lxTa6T?(Y^<Hhy+u%z{gOo%&2JMZ@!0Lk6A)o@CyzQI
zmVU|jr%|E$+3QZ+gwWQC=N_}3--yrs%T5cNO+ttN7LG~+?D53OUl0RlNUx8*n?4hp
z(3g=`ekt&PRoriiums$)P|x1=rlxSXBK~}NyFIZ)T4oK{s*JH_z^3i1GeZo08UJFd
zoaG?T=IS00*+eu*4h;QD^DnUvKK14GN=3rt+lcIFtO9kf`@Pf@`bCpmO>-$(4!>0)
zXx!h5F|LLrp}kZF!2%d$Kn)5&I#b|2FxY3hOZ+hZ`U(dB0D>_}OZ?=C<+v#d3pxm`
zb*-hTSW6832aR5-1n>a6QiI8Z)e^rE(EcM)`UX7^L1awt-&E$L&&!H5<vJ@ug^?US
z#ci#?i<EGP12TE_{>AJ(18(RF=eF=^K)-6btfrA$8__%xhPr&nU#!GI#d;}3k}`8?
zR%Z#4=JVE4JA062W8wV$S1dNUX>@qPzSt*vMpwp7`~Z9f_}4h(t)a}v=|1VNmjC!g
z7)N4VIzD=qN(xYev1?vG`|ZB47^0-k;hT5T_rwFzTYQ<LHdAUsqb(RW^&W77^pAe&
zVM@DkoMD$~NdQ7o%70aE6@oMel0h*1;0d8yV2UX<%fCv}#!!Ll)E%HV8A(`N?H@;@
z(h6IR4{iPl0&HG}YN83f7U5r8@7Dz=19kTKY5O{FC|_~^!<aX`Op56aIP<1c(&7!^
zEFYmv5CPfRAm<+_<Jeuxchiu7B$Dw?VH&^+&%aW7swK2Fxv$Wt{rCTr)<qG0_CxIu
z2ps|G-%Igc2<#=$&=C}l2SAm^YNVX~d+>nEq<~}fLT44>g1(LFsn(?<mG)bNZwjAX
zI>L>CFWh9Nz+dt8pH+L$uS4UE(WU$RepRR<KsIpD?1f_HtZ4anW0UpXZ3pF!SdR|k
zO5IEM|2TIzIQTp@aR}AU1xz^!(c<O;*6@HYUFsFI^R<gEi?tVI-6N?G{z(k6YS4<d
zKHk1!=${CR7YPBSQONfnyc>P~rv5(#sZgh|(6;qJPiFD!e=0*nKY|t-iYSvcLsI=d
z`kz3~v#bDO-W`3#lP<#^+cXWS-fDTN=t9bo5a?F`xNabna3^+emeg5SK;7Lx94lxw
zB4VzAxNh(~rpe6);@8xd*QEC;7S~^V5D4AKk@tu?h0a&mBNLHcAhF@2V(;4oWy7;v
zub21ccZtT<LtZ+RaH8$g;7$s7nIc-00{2cBUkYQeEp;q>`XRk80NTj;ndTD!=lP$A
z;$0x_sgpai7}C<dz%*Zg$G^arFCcAAaTaM*%F>q-t@#2LYN#T=@o^$R@oMTHw%-{u
zl8r}DLkV9==SEwknclsU`8RJ3bk~}>yQ7;oXA!yn<%2L1RND9o;w;Omf13uF)q55i
zi{YQ#3l#~37YPPAX^Q_kgBY_B>gfInli&E{T(|4z7D3YkUngpK+_hdEytH8~vqU+i
z&hw8KQ}n`v$8#$(sxAV+@Reu#IpE;9P^Z#b5~3S;?N<Q_gHwDL0N`IA?u<tYn6Zmx
zAM8p`E<KXirYRjN5^d&1rj`4>&7gCF7J$^i0jop&-V1?7x|2@%#$>Js{p=d?#m8BX
zrL>gia|glTZbO?FeG~lS)Y1fkb0TWeJ>^TP?yj8PtKk$q3MO*2ES6So3ww70qVAhw
zYJk6uALV6YghgYKQFrq{2zZH`U($$EGw%zt#w8=M2Ev}501YHCH!yY|HYwoQO=~_b
zCn{uved#~n1GU~i!gz8-wr#1M(Z|HxFneJWwupi2({_YmDhT3<y;C$WOUx%^;hQ`B
z-&?K9H@T|tO=aQ`B&!pK6S;>1GcvtyTlcD3uFoD1Xi~%N(}g#Tl2OhKT<agD&0e{5
z&oq}7WRk``y5oND3)RP|{N0Q^w<h&4`xp1ZS@rUpb~WW-9R)3x4}vs1F$SNmjrgyg
zQ+*lUWJbBX;vzT3q~3U8oDf-4naQf;Z*DPX#fH=eoAEad$Ygr`WWp#ggn=F@@9TS3
z$|Tq+A9t52h9kO}L{3-))}@A*V*TZbUtq<F&pT*_yJ%9^Nk7$(GUiuIZ#Hl#!#|#S
z8l`zEC!7!AK2Op_$+@$dut}rzqxcU<?z^hq&aP>6sX)VS$W405NNfBWbZW2PpHhe?
z8e^o`7(QUBZw^9+Kg4xz+@jSC5D3dwUd5%_&~`*VZ#0zLm2OFrb@mp`m#6s8qs*=0
zQQ8PZ#5tuopOA=0%2DihR_zrdx-;kX+VWEF+k%Aw2T!U!Ouhh`F--{1271n<&NJaz
zX4oI_Jisj6DO};ycpL0fw@ahzbFe{dL@Xwq2MTL<$2sa>A$F8Ab6tuOtN$4FRjB7t
zm?T2(Ac&3K72l;xK9TOOZQopdDao)tS{<X2v#;DLOyb0KX)=Y*KG(`zZYj~#EM>=K
z6EvxG!x5aRtn3uidV&Q~bGHuW17DRD<#|<_BCF|dk~jm<@&I-mN!^Ih{rkL&8Grht
zfh>{1iFk%n!l$@os}!bIkir_eQMB`0u9;1=rKn2+(-|$9fep2)JZ%ZeBn5Y@@3ZN8
z{k|$Z*nM(0@v@K`gTV-x8^!GTc20VcyW>u#FsRAFs^F8E-(Z&)Z67%xoB_~4wA$~=
z3$~=DSd(;0VT(2wM&#KL8YRiYf~<RqCz~3kt!KlpfqP@J9n8d$xbMS$1S0jcCyg6h
zw>N^kPmfsI1{0QUu)&{|%Fi<oDw~no$&P(7T>8>g_>3r1yH__VY-#VTs**!&Q^U$J
zOn6MXPA~Ty<I)k-29=AckK#W5RfOq$q}dp0X%in<_dX1_)i!R$SL<UVwQr>E-_XgS
zjPuc`A-ksv<h>Ht&B{38IZWKunu84qm;Z<34Z5wr0ja5w2GEZsj{fT2)izy>i^NFi
z!@5DrQ_mP{;u~DE<$Owd)E@5gVujCmg&dFvD3dfD_$X+b8t^HpUv(bal`-9nD-ft)
zu0dP+b>^4BO`se~K+a$7=U}E(X02Vj2P(0R(O$l)*eSQjT56}VXTehuN;Q{wdSZ%v
zdA;^^T_B%Fpg_$4w=YLM$ad$;6VObc23EsnWmfT;>N8%~Sna#^GMsAOph>9igd~6u
zbpW}<7rWQTW7Ji=Mp@uf9orMm*gC(S?lE&S#@O1I7|`||^<gsnHq+JNo6g87QHssC
z;$Z~jCHkKt9)rn(qX*mq56{icBnH_pgKrE9ICXDz7#aK5lVe%tANaOp$jPAC{b4=)
z<GzV(?P6lx-64xn?@z>5n*_LxCmOQX#m{Emt(#LK4OEohpo+&J67kz#oF<DCZZjHD
zvx!xvEtkZGpFI#?Z=@xv%Ci-JBJL|*7ivb$2Q@}9J~d9-SUNxSfNPJWh%>c}wJBIY
zx{a^6M}0{&Q-`~BP~r6t>z{F<{^!XTm}}OdDmYK`Mr|K$U5^RR94-Xnv(Mhl%yG6J
zFGj5HG$(xRQ$p7Z$6>$C)78j}wkSUAuEqFI*hk!Z@IQ#JHftqFC3;hOoy@K)XNBtK
zx{c6}vtS{R+K|?{maQY&i*90Ii;e^KQ-(Tri9q$UIO>pkUr7shx#PB%<nP7Z38ZTS
zok|Id!)21khMWXd4E9ZN4`uiRf=?B>eM}l}PRZrtz~RF(M7Un!*$a&txaZBhM(MFY
z){NM+9yPA{=xAr0^LqGtUBxFQxhIfObDuta{08Z~y>^p(DU2jG72#k_*y2|*{v=^_
zC=EwT8<=C$$zwst4d<vwdFvw0T?K_~T2SUgcL<d(O37Qo$wcmc0B#~0Kt3AP{Oh?Y
zh^`@}_u1UCDsj1<<yCLR4P9o+UHB@!v-X{^`|j7hZ|ST2SHgEOw@CLo{=ZYtbT<ml
z1?S1N>uIhAh@lDR^#WQ1Pl6jOEwu!4gOXvv&Rms_bRl_m-{qTEl^Glj13%5<&zT1}
zg(JG*N`|xDkY%P0OJq;uoA#TH1|cOICnsBIQ^u&98>;k;)v0LHbRXF9fpvQh?lHfz
znW?eGlLJq@SuHM2o%I+lk%>38g@>E+9;gBd3{x|2t7A6N%ZW=&D)VSCxoT5Ph!k+O
zxcbe7S6KeE-n{zG!gWp|e|X8|kZ>~pFvA^}z~={zZu`cM7mWvRrg@W~{_FZg;!x4R
zLI^_v-%1#Mo)MptDs}zdfGk{4?n4;-S~8~MTQUFy5AeY^D3qn*UV$W|9!7$8zj(O`
zc#!b8Kn?^Q<GsD1wC^~jlg-*Qvgz2dUV0sA-~Hc}?q2B!gAI)(Qjt5U!?;hwKhQle
z+;@bGaO}n9zRG@zvCAON`}3>6JT4P$cOjbLv{tc#q+UppRy>=9%y8oyuX@BspB&JW
z7rPW74x}Q;E4AJ;2b?R#4fVsI%>|CLi<YBzrw_5_C@NlJEtQBrp(HVjCsb~vMe=Rf
ztTENVzB5g~X#>q|7G?4KL1`J>Iq7Cvn&tc+RC5YGj6VAj9V(=5PwWs?ggtkf4^SS>
z^;!-Wt!P}W)_blg<|Xt_MCz=<jE6T}H~8^li%<?;A7)2@R#}D%Z0N6sT6Ulw1*CwI
z^wF9YC5btL%Z;K+M8-l;KXEiJ!m)T_zQfpZm=xaILeQ&y|J4z9rdPe|zHN~U<79x5
z(*UQqqLbHQ)**4@_+x7pe_L8lNMza43!QV%kTW;gonkFdt->zX@C0PT`JAFQG1Awi
zWeakiH%Jyduh+;|g_aE<>H|9=0RKduTiYSNJz>V<3QG*R$fraFhcjHwsV-it^ihBr
zPN+lC@%!&4?@Z(0kKa>w2f30Y@Rs<IeWM>BUbm=99$VW^c`bj+XQSX?hR5BFB3w)-
z*X(kZ)^EkAq?kisI432WubD-~n?*aq5$5mqU%07-b|7|b@8Cz<b`|YmH<9mMf1o=Y
zydl`{R<uv<eJl+(SRkvBk-Y<T7AkQtf%p5JwrQXsGHbJnND{*MlEj(LggPKC@a?hq
z-?4<<=gMD%PBtp%oKI8%!Q@ZoKZ{V|mEghgs$-)Ev^2NOv5C5y++7&oPne%RiK$v!
zsf@?$KuN#A*yh#z`4rK4_xgS1I>8g%M)-4T6=Nm=f5L8|akaQUgoCBJR(3yaskyu0
zt~bsYE47~b)vJ|0%&b__<ah3A6QKRrPf4d%<8z6<n9WnPu+c(}&u?DixWA35SC=U0
zkciy*M&7h6_vdF4?eA%+>*q>kX)-&5eGE(P5b&>4<-<f%vU5MuRw2pucx5+{oxZJi
zggBOS{iWA#Y{5~t=)=G0XI3J`gGnS$_)M?@SO2Ql^LPmzOSn8bAB^XfZMM#{r+PIF
z1YVvf8@W4{QG1`8Fv`0uT#$O(Z;29o+!TuY&KfSkaLp*Y8YV^RdCPAe9OPqEF7hq<
z4MGT&w$;4YPF41tivbzbLDSW1=J8E&>+}kYH>vNfu=E=FiFeoX&%Ay@{5i6zrMTNs
z!9E$xZ<hr@gzdwZL%~Kop>yuQ;N-qchpi6~kQ9tYIm6t?5+k-VisWq|*A^o4aTfw;
z%II(Xqf0yeIDSQL^cOMwGZgM#U5i*|u~_}aT7%ho)l|__t7g)Wo>WE>8;g&MiSn*b
z$Nfe}liy#*J2!U58k@^*K*Fuf7O-4*mxcEy@SZ<|0Itp5z+?oSG$O=f%l8x#iu!v^
zls;x5rqt`f1OQOqtD9uHe1%g=?yea~%ZP;^A<tTA^BazcFO;T{bNED})`Z`6)Z7|y
zef56|Y%^qzv<6D3>vrOihI6@hYJM3wLE!FvPj4@Aa}%>M-^u&Igd=$q*(mZL|Ck~o
z<6`Kux?!eftmb^re1Gyrkfr2^yN}Z|1unezNvIZNl!1e%r;{ZM1TWEr>Y<eQH#{8V
z^f#>$YE$iN0(>|-sE3MWP8k4IPnAR1k<0Lt+S^_}c6`8??{`;k5Y4!|84B%o%;R7G
zA-cR~e#&w~^l53IAW+z#*3!Ga0|AT|U2I<gdc}*MekJ%7zy`#fc7ufhB<yOADzQ$k
z+0H~<c)w0fwA8LCGI&n#iq9Tn&g{`#@+6`F0PSF<*D^Y9H5))Gb1CowSt6PAzBil7
z<^0<z?kACwdqojV`db$5s?4$hVfdkD#hJY~F}i6a%H<Rbj#*#x!-DuZ=tBBTi4>R!
zAGgMLMMe?j&^0pwP9+{`7~6NWN_zun_OCRlmvh{hn4B_AA!e$#$F2lgYAP8g{-+4^
z(?!Rq8ko)`R^yX>NdP3OC@6b<25%H&dw=NjXQ>9Cfb>Kqkqqgj^j+=w1r55V5RW2j
zz}^fF7fQEhWad2B_K!22V17`7L-3tol2*wcRxlR3X=BSZq0*0CEG{~rQ-Qb~@Aw`c
z^bNr)+U;I1P8-CoZ1)qnzxOPQHc&R4=<zAv<+-RhOEQ!09}oco-V(e50SVDdC@bg~
zN}9|^@x8)}y!N5F)mQFk@fK6&kiGsuiXD-NL7@K6>So!3s<`Qv9Cl%{d|k@FeSy!2
z+pMG0W*x5K)A;(3KTxNX0HP|=*x+^6yRG$I$yiVt$ex+i%4`9#k@%_&(DwHRbiy8b
zWHl2SU3bS@=$dpc^>R=zdjgQcyDCdr6>AJC_%dUK4vi@+x$k}+Y-#@@2ryt$d83Ee
zRh#-{!^jU;`QTm62LtMuNd5pKkl>Ee@6g}d#W6r!s&7!rPm+ena_QUm$xMFaDk!0E
zQA*%frU1H40(~K2_Ug>=-4kyWH_v|XM)i^-9ea{5?2cuJ<o{N4%${X_$TMNs-9Z`F
zOw4FVs+P%-`+pprV|ZOn7lu#J*tXHwwsm4Pwyid{&Bkuj*tTu7vH8Z%N%Eb3f4A12
znP+CMz2{!fa4$YO1@nEd*r79Lh|P3hH^>?(RLZ0}sj{Ew<RS;ghw{qLQUW%kwgGcO
zU+-~|sSmT-$B5rlaEWPZ(13oNQT9ye)%9GiN$V}Qv%R2ZcpJlfg6CINkXrgJa&Tzn
z=vcv{XrgHFSSl92mV&w_uq<&2Q1JAr*#iaC{Kl}d{pZlZ)p3ODOt$1Zj%nG^ar}R!
zDoDjY#@oYIBPs_1ZW)ZG3BVRBUyg@MWxi8)U{h|OR{ymAZ=Zyw!#tEi;<ZfdiwN>&
zESNiAYkAA`#Y62|%1T|0P;mZklzaY7okk=&^jp5N?y7WK3WeNGc7eIYz~)>xtuPWF
z=7gyKW$#gSX2Yt~&3`7$<P}K!oO<QYcZkhH$zzxugjxW=298H{%n^x0R2tkY=4MF9
z-j?>pVqX))4UDL3!q$n>P#0ERw95Ce$tNkyKVJ6!)*J%@kufOzNC65b(iX`rlAx=&
zr$F`Mnsj3Wg8chZF;+bnj||l$%G8!Zpa0a=;wgTa{6%b@(fn_QGKLKh>@uK;9-VoM
zkLxyLSIu{@fg@8BcZBcNj6C}A=W1{zCC#Ya4Bk)pZvzY98!(aajiHw#&Sw!XP4be-
zMf`4Gi#Lh_3S(SU=Z2qMhnmeHFcN<fAvcN#kj&tM-%*odh?Wa&vEzhJ9*1bLpEH&*
zXa$e!0g+md_c|h(>fq)HEgIKB9eh>mt7p38ltua(jtil$vawhYV>+%Zaa?E!QLr?`
z2_>57;OE*Os|oWatPsaR=Es!l4@IiD{<M#zZ`p~mkoegsn2~5n2j)$*<d1R(Q%t_o
zI-tU!FC5%tTklpj>pas1B1Zod`!1=#c9Rj@^;W<KfiRZA1~8CCEA4=m2(|PJW1*7V
zC)|2{M)40;SV*^A+*Q7s&()$|lolQThDX^sI!AOaA@o-}JQ@DUx-tE~W=Y{$Tni9m
zhe7S!<I*BX9+&=-+IOhQf>oW`HD76#5=C?lu!H~k-I$jg*{>$4VPmoEByVswx~=Td
z_wp;tj#nrrGrS%JPeV=ESNUWrBuae)cZG~Rm`qt1c>}B)PFAU;&Q;{<m%*R@&sCpY
z*E$u!usQUx_Mk7lB{~yawV6;+Q9Tdu@W0|ZVO{^=+W|EldrD;7eg@}sX4Fp8ZhL=i
zT(L<$NJ$Tp1oxMclOK0}7B2=f2?rTFhM5RO3k{hC1c2o0x{hawFZB>Anzw!sDo6Ex
zRS~^^dOjb?RTbnWh+JEZHHWe1Fvb;g#d;VrmHH4bsBagly^sMnP%DOvWWNe$Q6345
z*cL<z>ySQyl#NxsEHrVFh-rRZeLv*#n@MF=Fz?9^%zqfh{ge}-shi75Cla5j)=pA?
z_GzNVp|644Mt!$A(Tt~p{yf3-1H!6Z7y^h8+J4_-E@0i;Gxl@w@+-h-s=xh-w1dA=
zTDKUDzty9e#h~krg7~tHDiy994BC6Ny{Ot&<w+_I%5{e>7zueLhOmGR{IDNNz-~*h
z8)WdN`$(30Ki6veON>0mj@sS#L%T!pgbDqE`1fH^EoIqeb8g3MuYT<laXQEQe>|yk
zZ}Bx)-_TP2QvSDCKvP>5WTTK1D0Et<Y@N=UofzJr))&Uk%1;RRxsO^1=yOok;^GwG
zoU5Ej*uuEk!gIX5S82HM@*rrWMDh9P^!Q9}3a#PN`;X`ydq%Yl*)l1}brp!a4=oJN
z@0$<LO-52;<1W0|mU)6u=}iu<ZTJBZWz-3wyr{wzmZH7=!xC7#zz`&SE+ELwQadDg
z*?kx3=#R}czR(ovFC^V0IRT^ZC5SvOZ_fXdWV=e8I54mn<n<Ksp(&BsZ~7Zx5zw9l
z#_)o|tRO^2(;LSaF-cgGK@*_F#8o&~$5iK*mso&C+Pzryz(bKYYK<rufiva#`&Qbd
zIM2>%AgTLA0c(QWOHldAy(cv75+K;@GSpSXLXal!^Qrgj|Gie_^St|=2NJS~2|do5
zwjP786}uUu#WudD-PtFp*<kN=z;G*d+FSpt9<!8QFgt&WRCu}9QiU><1cg071@@`P
z$yMv~zajTQuP7>(tQ+WI&>1c(EUs13A0pur>*%juFolfX3bBjypDVq!*v`1BnK88G
zQw?vez0z&*>??=jZ283wpZvSO-Pund;it)thTW<DYv_v{PuGUC(V{(Wp(meiQhnxz
z*#k9UXnU>j#n>;xd8wbRT9``aoj5;Nwr{moYl{8$lW80mufX+Is1ldG)1}9!DNPjn
z4DFE~i?C5H+P_C%1Dq%o!H9BZy=5J2XsI8d&Aek9WA#LnfW{uXab*aO+fIYdm(AIR
zi@dU=1InL%r?>mkis8RSjkphBSAzYM%1_HX@|6;^KRBzz+loO`Vx_id{t&}VZ~Lr$
znnxZ3{)Z{!?bTMm`Kw1xt)cWAzx5|Wrma4V{peu1gN+ro(vw+}xpa)_9&3%fhyFD$
zIj@+y|8D;tY-sf66?Fan`PDF-3@ikoCOHV90S|CPpNAYszZg*l5Pd;-=&2?|u=;I=
zwxUAvbo`Lh8uRkicj>WP8(}`eDmIEnK}}&S=$qnO@ssYpm)N%Q);BW117s_E<j)K_
z6!0Z+Q8aRDjG}yKl_R0IF4TTvjM`(@MrKELnEU7`v9a2ccE<tVlqO<MRTc;V9mw!R
zS|Eph%zs2vV(MaeXxT~q%4nzntcS2NzWTi}JzW_x9FvLT)8(O!8G@|>ki2O~eWKXX
ztqxW_l09R4NIA37gdd;wkdGr5pYfNQCl&Wb`J{|2pMx1M3%MRlUo6NEFmWExa#lg|
zJUOx-4H{%>;G!#IO5=mJJ02%G5AyDUE4smKOn)=CPuP544^G9TUIs@{g<@ii8~Q1U
zzx1%zJ6I;m$3`5ZG>&MdY{<?1fqbm;^v;=ic1tRrm5}0E6niRi@^OctH2NU5ne_g0
z;=Z9QE0N9f=V#(kQUiSnvKN^56i`#5DaHekXp;CvI#ZYAzO$boYx)y(<WzP0mKt~=
z&f+g#03&Zj&;$q;yW-OUJBB%t0azX)4sVRntvA6pGs4Vq9JCF%q#QVprJjEt-?eaW
zPz*U~{st{!Scd$kSg0S(u+@(^QeQ$0cW2#=piT`U^jd6#OFI<|{WQvj*twdAv!E$T
zif;uuXgh}3U_X&vSWH=@i`u&`1AY%pUq-av>bcvGK2(*nUrB-@GbLHR^Bgs#s4~fd
zI<NU{oi4#??#)l47q(M}`-+1)z0AAc|66_vrHYhaj4_C1_eGMxI)o|Xb>ul3a3|SX
z>j}i<f!wM1UI-i%{`hZJ1l}f|qm(x}akBbSBx1+bUVo~)$>Ea};EYH<tvZ4gVLjWl
zw3gfA)V#MLFYDIEHryWy{_e_aXTrr7PLqQvbxWF_5g?mV2b>W@>J6&f!!<FW?mVoq
zGGkznj?&b7RmF8@+juydH0s(~G3d*=7i%5;A~2|{2PiV>d6NtfvUzp-YB*vs3}j`o
zLH3$AN(gQEUansN{|XC6x0+tz09sP&E6olF)~HJ@&G&f<pZaem3o6$g>cuYns?hN$
zRaz(PH|!dJ<J)-}_`qj!p(TE0O+`~@^Z@Dj)I4-VCam9K58%uN1UVhP(6lj&g%)0l
zF1auP@H9^O>N9iXtfS5)%W7U{#zANvptQt`^Li_hZEN^ma^j!2wXZ+H2d6!2Y4DX~
z6!l0I!3!dy+G<W840K9?s@hmT!UCUGdsc+qu*s+6d3Aj*i+LFz)6Pjg&8~O6+nB^y
z8)f4)&uw6gu54Zqch86qOmxXxkdXw=ZDpOV5A{ebnt&TeB0A=6D|JXJ;-&&GHr3zO
zcSOZcSBLVtm3(NKicQxuqQV`V3rc4|Uc-}p?ifmUEUpxEmlwT(5^yj3*UzFQUidud
zYVR72m!8<5Jm-gy`8CVReU_FhK~h(BchjuzkAG@C{i%4=X)*(i&=I`8Wvu$mU9I=L
zXh!0HEgkI`@uK$EcKj_UM3Rp2%U@E^DYaj4`N80;MW3g>c-y=TvYm3qj97sMD2&t9
z^~-;jl=BJxW_YO=Vrm(t?SMcVfCsCih9|M|2os)F#wm2*-2m?6zLqIf3gD*pwE;`b
zWgit+Y}pO<CmY=A#8{C+JNHL;{a-s>zK^b*zt-ap>zrdFELcyt4pAcG|4!r7*w}9p
zeP**VoJ_*Gq6}z8hvnPt+8#d6@6!G>rDDwu>a;6c_dvBd;1qKIgY<}5I^y@iy$`XW
z>}gONNO;X)1Xy5urY9NF4F!=Rzi}#T$bXyHQbo|P-`iDz!)uOWBhsFXv2eSi=F`m!
z>&)_D8_J|sjs$4|P9nwx05|3A@|GDU&&6P?_*NZ=;=^MXH#3&-XKzon4aLM=RdoWu
z;5Dp%U?~z_-0Z&Pf@6^K(FMwc2BCv_ly584rPagsci%5hL%_qP@4g~L5&KMCv4<I=
z(d?JE-Pb{tE_gR;?2pSz`a?+k$2*qdC>XH&#xLBZCVV4iLav#|=!?|t+e(L>ZDOjm
z^PR$IuoFL6i6`sXSEyTul;tXVB6{Ck?cY%bF^D6fZcs{#QTGYhpAWI3830ZP38&w4
ze31bK@w$U-a}b`81<0OA+W0HCt%hGKjngE(J~4lUq7ugzuCb7gSC)l0com3{*Tx%6
zURgoX4E;h+vU6m6;&=NE;WO6Py}CF_k(a!hyfP2f=NYS<`cfT?5lXm6=Vc%Z(~FMQ
z#nX*+#@`l)3uxi<vRR#)1Qg%%knrbyI^p(2{Ruk|KsAab=|ZJl@7X@PHE>YKNXwkD
z0E(M3_n5w|Ac!AwC5@U7C9syE=^XE7!<%PR>wignxICgw462~9X}0sMU?oRGTRfc_
zvPm*~#f|f})HuAn_v#|<dDbE#5z0V$)B8NQMEbfln$AgWQ5jbo`GaX$(?xdBh-L`(
zS@%*6vTwD5$%WwnHoW=6=7pdC%Es7wY>vt=*A!5fG<OQZPKWKG_3`^{)T+%Hy#CyV
zp5LGSr=<DVQOmPpkMz0viuvIODR=kMslGqU9@ON4wm|Ly!ZQnqT%EYwc8^|c1MwW^
z0s-Pz3VB{-^m;-}g<w*fkmcdbSuY{)IxeoD<EQi4<U6x3pYO>PFXfx1Xv=bpjRuv#
z_CPlqA2lJ;&%|ft2$biMh_mrxrk;>D3hEODj&v{5nG$SYGrQcWA9C4Ji{#+`PW5mA
z6L?_#Y0$?`6g`@l9_&XH5jq%a7}3bujrT{Od>cN}f)_`b{)%PhdG3ZPo{1GytMuX_
zX%~6Oi?1AU$@1R#$f<<kml~>VmcN3l9nQOSTdsFxlLMWM1pFe`1Cc*h18F1923X6i
zCCrHMyEZ;3=X+MV2W_qq#so*yjHEX>3gsP0X*0UK_Yj$*-8t7eVe>M{cpz`YC`U>C
zI$vB4R+P7PVI!5<xzTUvAdOJfHKpFbiN6*AAE_ULDX?|l6DEo-%7ZDjmgGoH;M2VJ
zVN8YiK&d;zhrFv}shQ20ymBVPfkAyoDzhX7T~Q1P`XccB>R570)ejpS9?)o4k*|RH
zlI?FQ98czuO-xIA9l#sDg5gKc;UyeDB*KM>QXOXy9H9CUYo_!51I>2%k^r0%m7OGL
z`Rparr(}X2Kce#uBb%nCR|uDO$Nh6FfcZ#~@-OtFr>tY-@H0|RICa$B{a;IFC2XU!
zweC-iCj&H7Hl@M#Z&~~yUc3^%aepxyo!NVcx-*A)iML18LVX^W>i>8>L-vgLd^U4A
z`uHS-FRI*&C&>@^9Ad=o`)dBU)j=rLmDLB2+*Y#Vi#SE^_}Tlm%N4WxYE_x7IW0%;
z787pp=xQJsfnAdSaz~L7j3S7kE%fxl0~7b;FEYv8<5!{5%lB*7q(DMCUbVkb<Uu4p
z`#o!j9?FB;b%+??1-C@4bAIp+3UEUSoIObk1b}|ivuQJX$R-gMGoy<LSaF$s4M&lh
zQ5hGEtwjqj)|o+#^{3_Ukv4ma;Pf^}64uXxw;R+8W+hw>he<<-Th7ta7)lo^5}Ttc
zj(**lV83VDM{KL;r<7C<BBSBv4($_nqOf9FA860}{rojlD~co}AhnIn%Fh`TVZWM3
z#S`>2Fqp)9)bs;bzmRAnaXFN`1{bl9IkMBMym$4?vBhTLiDuZ>dYi=5!K3$*s@2m5
z`!t5^%=*X`p5q6@v!{DQLbvW~+jnB7pG9@XqgE5?<5HUw98yO+f^Y7H!?WvTqifn`
zQx*%xg-dq;7h!40Izlno*F32Y;IC{-G8LzqadkS+C!i1w>@XL_>Ne8o=at~fs7xI`
zjfqF>Fc=Wj$p9N6qATwR`-)DVAovO-u!<VQ=;P}BTZvm{h3Sq9X}l3O9G>(fK#fLq
zP*`Ic8(+g9G*zsMo<DKu`ewBcHPy%P%tC_G$bP7#fRoza?X08#V-8;4CR395?;L0V
zi$Nj%xq|g(#`{750G2gE{*=rGmFp)g-XTD5Jd9!2wZ-Is=wpfEsb89h;$@rd?wlD-
zXnUDQa|y~v^HB4rIU&hR|3eOsa;A(whL;OhRU4G?gW$ubAy<+h6_}t4CU`B@{>1~3
zbSs1yOl-%7HLGzT$18QcH;y>D{DZWwW`}g0{ZK7{A-Xgr2-%l96;Rhnz62O_C*-;a
z*0V?K*T9$AeYiT?cHZ79{4o`C3$b$pAw3DTHq!!!q)zuZgXNrfYOEpgRBaLDVeZ;<
zjOPzLwa0{K?_=GZW?GwWfdg`#KH1nnjN%@mPQwXqZS>;PW=z<8=uL8kD$D#gH*ydY
zQtdbI0QP>6VO!^BB^G1o=nYV?tzF&T2AZ)$<VY9n$c}j2A6M1rymROh*+)fy--;DG
z7}gA*sp0f**;VNxErc&!jQ<(5?XDPXI0SUd2-1>$4EUNt9v>WF*<OWTl(!jmpnPM;
z2jIr+MQqfs%zBxT0lh7)g6z(jf`!5)114dgqeaU2w;b{ON4IX{3cAQ62|R3$19o8R
zOW>PM*@@Q=fONmli1QKBqQOO2z#p8T3JP1|-?5jZl@5beQZ49!UWp)oQc<nX*x;n+
zI52NiD!$}g=YXDJOEE5EQRHj>$P36*RE>#J8zK+EqvqLBVQgW79@GeY0I${<>%o;q
zx2=ODBOdkgAoy)d*Me+Xp&ZGxKV6mc<;IX&5b<FEbxU1k+>6zbYy14u3V7SIJ_5%6
z`5cls`;fkiEoeyU_}<QJO5kUzOSuaJD83^acN-Zpz!L&uiMNJ5*C|+m!#gG#;j!ZY
zvcxNP(KIrO5uwCW)9_tre^$IwIpi{MnQUa(t=EdUp%7w5D4~F%qxIM#ct}tHywDWq
zLI?7U-;@*rkR9_73~l&{)*WB3_42^7YuSMfF#!N1T-YlEMu2s#S0m6<bN$SY&;=zQ
zUb->x_0T_zN!P_$fl_$kDb7Lv9<%SUO2@DH6&FQ11>61~@`fcCH0==6$BJ$8RcScE
z0jxSw*f~k)NO4X;bT*{5gI*siIgCl_zgopW8aM^>W5iqGA}B;lP!jJH-?N3}7JH-w
zAlPG*f7H?Z{EHK8!nhbxySv^JX8bz_$|+sMsdW2|s$u%06WkL#BlE|HfU%8Ckb~cj
z-k#}M!Yzv6cu#0c++`rnMmRm*hmq9z8B9vS!A97jz?yqWluy6I0+=QJVC@Hs-YjXC
z7uE_K#D+A~36ZS#_Hij-fDVEL!kCergvAXt^3?Qbzw<c>T+o`540J$*9~2(_tg#(q
zJ-E5QnNcYXKY<184ux(M2<9i-)JGHlz<usY1p#q6U{Tj_f=<=IL-Wl#>Qdu{3OMCJ
zZ;y0s4BWhCQPtO&;8xreGdJ(SgAx@1&B6eRjeV+2^q|A*2OgiPM~BTP$a$bd#Y_K&
zCbl#row73zV1h-Bhv-X$YoZQr0s{pcT2YAp^>(&D?O0Z>8lt6$V6)rd5pX?qWPr2R
z19(h%FbbH70fz8>8SO;0>o`FsjCDLSgIM63HGgrwXD$Iw#6(<ZDV|`!c^IZI_&wJD
zkKVnu1@7qBH}_WX`{x>@0H>B-k`(dKBCPsbt60!v3jqB3b~i2mdV^Zl$1egvwP?tz
zSOEITOCx+AS{rf1zerWi=siKL|Aw3djAmL7gg!PDnP0I|Q>+oY{EV&tDsKl4l<@?1
zG)rQ_a(1s7;DTzqnx)#4)t@{EWYioO>qn-6rQ=TLMF^;Y?}GuPBo@1HWdnfPx9}hw
z25^g=$`8N<299a^#f+GWal_$3jqZKcP5rCfpza%7q(&y_#i%xdZvt$yg<hG_*8)Ug
zS>VBP1oCqL;^NETw}OoS0{5fr<;GY6a|s;IQU5;&NjjSQul`WL0-%>bhWaOCt;DvN
zCun2&va(dQ;5#%hcbb|L!~kXyS$}@R<pGzqLYU8I`34T4j$dk0_)lmEg!|lvNMor=
zd@zBM-SbyJ2m+8Wcg21G{u5kKwKK6+Gx+6D+B!ISR)w^NffnBoG5<v>X(aYfkoy-u
zxd9olMHv{i>j(CW1CC!L7?}$FYqg=?ZbLC}0*OZC?A|_D4H;^GNC?3)tDvFA12nri
zY*P(#W=1OBup2fr!3?I3FvbpO{F6#_oTw-g=3wJ9q~pK3PaQFQP6xLi^KcEOasMD8
zP@n;Vd0-11IU{)ua`gWXd{KswbZxW&q_Ph7H&LGNXa5VA%nP00zyztTc)OaY#4FNC
z2@w43`|63i`WM{f@_WL9U{8Y5tb;377D5=&#X4hBK&fe0jN3H>_$7c~(2>EDoJ<{N
zOWGHOU^ny+z?gp6=NaY-uFoA`Z&#TJA(D;+oTN;D2Qf25`fpw+X=HOeFzy4M{ws1g
zAMcld|93kRArP$DKXKr@L-l#!9(?r&iZS*jJ$L?VLjt=!x~hLea0gaF$iEN+A8r5d
z>1k1(*h1hU{*Km!A~Weh^NN{p=l0`GrUlDQ+8A=H3EU=sJmUkWS&-Bryq&+qw=hYr
zlfjPdwpbVgL{Sn4T_+KpO4c!a0In%Pr!;Hui4|yW*VKm4<zguPKiAOCjXh%f%caQ@
z4l}}9ZwL(g)IAOF*MHUvBudoLargcGhFr|n@CT#uhS_pQN-*Rz%KIlsdl1R3h<ptT
z%%WDpm}i9ixb9$pVju5wC*u0Lg$hnCz@piqA_^n#q1=T%hRn&A5hL9r(*MoNOuOSr
z6i+@kngD8l)~Qb;8{Pj#6y4t+66Ay%6NB*e2i)V3@R~TE&<1?~^W{LCXZdq}lRm!8
zo;n^8NB@t^wkl_QltHn22bcCX!6&r{W890N=_bsF8t6M`7RQ0&Q$14ykaEC6nu+>7
zr~F-TCyYXNgpUgc$)Vi0QZeI`?GPa)Jk0YQw`VGtq0;f`bu-QxDP%DwdfI)g3#TWY
zv=nEIM+PGpKAh2g(FMR2+(p7Wn}J~vVGJQ+qTT+ti!hRJNC!--18i%Je{iVB$wzm-
z`a(*;%W3xsufcL0q_xo*D0D@_djjkvm1FzS*Ydv(Zmkh=T>ESwk>HyK@)PlzU<M)s
zXyU7#3BGF*rDx6ZvBGSNqWYg%^n6hoo*8K{|8RX~-zLiMR|>ifE5&h56MNkImJ=&B
z()rX#)02RC@H8CqWeIFeibATMJJ!osjg-Cf?Lx)ghXK4}COYrTDn_b+5%KYk^$X^W
za~8(zaK?3^AyK>;+gCN)E~M>&d0x^Ab7Ouac=SBD0z$x9P^oE+=>=sSgVNwn?r4&j
zT8SOspj;PvZYPqKYb3cKVi$Jqn7prr7Z2Ad&^IRU7}Y^WlXfn7-*U`^E&})K;VbTg
z&twpMu|`ez*EYZ_hF)o1C_NF)u}@X}t^CYM0mHK?EkkLlKh`|1iNlbvv_^-Y3H{?Y
zz#mqMsu|OA$bknU_DN^-BQ#LgayjASaZVUFwHk{rSXI0`Amtq_VDM!c$wd@yFj1i2
z4Sv<;S7lALAhj{&J)--ORO44gKZNYD*{D|6iimD!q7{u)qbx5LSYuQo%p@^Q+V)9`
zr+)4Ebx+75GhvErA$>~7KHB<1L4__wmYdu1*KJs<x4dxY3e^GEiv(mB91JjLN|jU=
z<_P#jxW{O0oC=1Gcro((JrCPm|GIod8HC4ErmrT8IskLR`*rN~8=$lq8(wNRnv|P>
zTj(3t5pP~N8Pl9A;rCKmI{zbAIF!C!MSR)x=a2m6``MjPl^Gg07F#OdfYage5JM9N
z%YfXj1nn;Go`Fw;l%6G%e$XN-Qv$z9)eaWAHf;q&B9Yd|e}i~Afo5#tF4Eke$UPrt
zg?Bpmab_;D6ePBpciqJ<oM3)=Zu2KyKQ5F!t>0<!jh>gjE~aQr<lxPzv`~}uEdr67
zD%cYQCA>Kj_Lh@q`Bl7K^u_@24ZSz93@-Rp2(>H>H8;B0)$3JjsDw97F|cKrZXh!y
z7l5D6<;;#UENa%FwN2rqS;wz5)Q<<Z8S4rUHRH-fln~;}9*Ugz+;Dg5mPe%e`2pGo
zC&PXH@2fsDD&`f<PZLd|IA!AkmfpGwnM{aTEmTYwD&ZhQi!EDq$)h*m#D3auo^Ra$
z8B$B{P<Z8dvM{S6AMYvbhKzD4qIsOt;>Qp~A-V{fS{T#Ecy~<;a<S~q;8+0K3IqAD
zq<regl?J!Usk`WvrMe)5V}y_}ur^@R)o<`GNRkQ<&>7nam6SCQX`}>ka3?5-8=x_&
z687s9ib*7kZf`5Y9-JA!qYTl-{q{|x;*+QSF=Az^ol9kb<WHeI*E(dJ6Xz6)dKsFM
z%HX)Lb&LnXqc!#NZyrjO&VeWhpnxV?BJ3rR%GyH$e2u{pq*meck9toVeeaf=onb6}
zVD9%nby!QRqD#Uxy}HLe)<kzj2C=5rPQ0sr7HhWymHKs_A#{RC%@QPM+`j-3$4E_|
z=7`grBCErllCF%5pu{RxhmUVCJ;1qf6f^Lo`pDZ;$Cl#k2N(@8bokBOX=rhu?l#?x
z6Rp;&J`hXUS`ly{-W=CsG<?VqtWiNt7Q%e<J9RdUav!&36=tTi%%H*zjhFLZQ}8;2
zUU*paiX&scQdk%l3ti8l9||T`IUmH76;jBv-0t->f;SSme0i`eRDO&eWnBk|sL<oC
z#1ExAJ3bpDZ;u$0E!;*qO1caOtx@!5naWdC$r%{X6ENwomZp{S%&Y{-l7u<JP?7J1
zYV;iZ7ePO|pS7==rjDg-K11HA^P({#FjedyKd_`fX`lPq@k{AiFy)20;SSgjQwH|H
z^gsBPlPQt@RAsFYJCv?r@Geo8Hyb&Y(ukq_#MXii_uFZnx5x<Yw>K@n$@{wcNrCSg
zbJ7L2ikLoB-_a7#8;VS%BA@CQ_c%CRjHDeyi8}p}+p-`&jjPb4sBy$@#~74JHNx>X
zCwWP(<@*cE`1HIxb2E}FqY~A@v3~%rQ$f7T@3wAvtx<@!l>lStnGx-x(~%ud#nbsW
zdFDY{7lXflP2>m9cRQhTMX6uO2{=GvIY$`|sbl=Xd8RnHWVYFn1M;Q~H(0NXPjGo+
z0kXjZ#~^I>6Fc&10^o>McF4@l3kXr$Q{n9ZJm(ct=G{(g9LAYKkZ-z`(~^`-c5>yl
zG7iEg$<cXSevXiKmH4?Lp$zPX6LaV*rSe3DZKaz$)68g0vSuXWIy3kuoW{+XIisNz
zj|XPgCnm<%M+8EhE@pMqcrQVt1<g{_tQ+LKqR#5bTF9X&!+*0%GCi-q29?D7TKePe
zQkxp8y``hq<8?gTHoaWM(#yt=(wf1hZ}w6@cky;MHyCxXFc0*5MyTL2>;PPaRP34y
zg1qbTstfpDzt5~*6{P()v6g-9&NQq&#8;j6z6W)qK(wrHN^ABJzK^-333UV2{7PEp
zEEjjw1Z~vMr}%*C8)&p=-38twFU_R4OD}F5Kgxe8TemUZdvJ5M7rMDd<?^8vHZPq9
z=Iu<|0&>YS{<j8+vWI3~twA)jfAKH4yroq66vj&6=(E<riEHJ)yNk?oK}L8nTa3zp
ziKGai5m)qv<KCMkkoT$6mls&iO`qdKY=rY80y9ec27ii1*0pXO1BE#{{9TS>@J}0U
z@<bXrO6#NW@YNbO)df5N@W9BVlL|owr4^aS|B8hpFQSZ-I<YV8!?tmk)Q0XORWtVX
z@F{6u`<cJSQp)o)o!^_DMms9orC`rqDO#l_FoaVmKm<1$Rzo}H2Ug11yy5o5S{T(7
z2b<TD3j<0*Z<@aCK`$8GUN7#y#l9^SM|on3UiP{B6z?9*_vC5vR1qp|#P|*!$RNH5
zQUupx78~<tZ~89!;qn#N3g$=xL{(^ll_PbjzB@lxNDCt^2ARXhcJ7@qPyekK(OI4&
zY0Y3s5BbQRr<z+AYQV6CXLG8q=fu+=BSOD6h+d3Zy5C<#D6Lt<kw!ju<u~bW61&jf
zqz@2A<JWONX~u4irf-D7@{GnWd5#e#q#Pt2IuB%|XT5QRPKZvw3FuJYQ}yC_<UFdQ
zb?n86IO}liOg5hr@DPsHtBYU*&%F_B$m(3?gIuhnIp8c@%7?X>?q+{pgmm!#(^4~T
z>F{`_e$8j>uFZq5jr}^F*lrYH7twqdDK}USgSqT3DuCgjek|N!C-myh4+{DarK~1)
z-(=^*FpA4`7rsZw=T8{w`_IleBDy2I$;`s?h>|uEZ7FetbF&)@hnQ71mL|&3AvF;4
z=W41LMqVW6g+$vWZaveD-USZ64)Sq(2~oX!jn?G3g?00hMP#~(cCky-7inY1-~6T%
zrAOzYKL0s7Us0+)k!X}r9Xe&XmSZlkdQnOs-W=^y*hje~4q7&t!{;H$Im5RM|Cre5
z(~uPe)8FjA`o1D{Np|Fo+pZX;c(yWo*e*s@_qF@+eUkCf1Qr;gV<UjBQAiMsPxPG`
zn793duRJz~*9Qqgd5g}c*<L2YcV()w0&*G%VlljBKPxvXxi8ffe;>0_tg`zFfjXKO
zpuS67kVtOl$5t}8FjHO5UqdUZqP;><0jJY>&=m(W2M2k;nFG?*ijfcBad56HxV6Ct
zaNJ1PN0Fv%Ox)(cIw?X<4JF*5=hV7eEWnzMhtOvGqh5jk*64%up)Dd~v@^bJ#;oN(
zHIL{!Mm{7vzu?K`tx)wvwBh+gD@g3awAc2lOza%KLog5b>@`Fpsme9nsZRU7CV)0G
zCVNx;p~U1`6OzP6^pB5TP>Ydx&@aDt64}PmK`GOE&x*2&2g=wDGH*JGp~H=J{wjwD
z{3xv<$)@0~?C%er9OVLR4Y4?L{iJGR?zI|8+hGD>tkNWtDdTUT2e#hWfi$U7$O%cg
zN)to>yusF?Ngy{jwiA&}>Gik4^a(r*Iie|~Enp=GKwdL{L=vX4V-2=s3EXD`jxz5e
z>ft1^R?ELTqOD;;ac1B84rTNX<&JPB7^8>dEu4T!YpHAe+ZBlNNBEo1N*dPjEzEXa
z<)mUgG*2l3VTR$W(xL1xe|F)!B8_&gPB=>K9sHA>X0PbFA}3u!R&+E*NTy|y%Wl|f
z`r-yI>duzMbF=~Ie2|0;uBabv`52^Gx9EPi<QMjdR;=6<jO`$n(%q-FOcm5&e5hFy
zf|`L|Irh-j1G!E}<1aw2S5`sFSTnOCW#K(SJJke2<e{axru0dK`rU#}+I^jYXMIu<
zw)m$LaDI-|5)qdZByg%aLlcnaoj&b3ygTsDvvc)k^~271ft6H%x<}epxGc^1DOCG_
zG|*D`QO?7JTdw6=ap=@DG<DHT7)q4()Y1}4l(DajeNz=B@(XWlBI9;cfg*fLLQ@95
z^2k>s<q5^qi659|w6c5kQ|wLhJ`*|UW|=2<D$0K}<DnTDMgZ2+${81@E4*SGBQUWJ
zw~uYJ+IhF~ahJ0B2FY=zS99;_EqVis;ddCaZJUY0q<}(y**E1)#VEn!c^~%WdIeAX
z;@*_~?yIHC@bgh&)f&Mj<m^241FRm>#!hl|Mc0#es8b|BN6|{z{mNUbA^C@xMejP9
z`j=pdsx!*N3DZ{Q+pafcc$+-xUl4{`LvyIgv{+9Qtxu8%n!>}p-a)C0oc}q(R6qSS
zKYV$9Ak(pc`}|Im;%fR^{8Ihk<z>AR=JjC-o6ezk4WD1rrgAT2VI=K1VJKG(<J4IG
z;BUtjDqsu!j?OFUFr!e1a-N@CDSoP*d(XC<*Of(zKU&yp4e^tBAzU79@<#d>_Fz>g
zdXgE63I1Lu*?8cg=c0-ah8Z?HD>qtrBgM6o<1aRVhDg`WipW+p<b?84zBFg;@kfAW
z6mtwXf4kj6-CSXEg51bq*`P;!#-W2dAII+C`|P70SqB_zH*g>B?W$XPhABghx@71q
zsZxu5jEo#}X!w_Gr|!gG)7yfQwf&V#AH8$FdcI+!YVuliz%tDjERYDiA%u!Ymv%-Z
z5tDlGb+1&7^lDn|&#!UNm6(@7B#EcFqQbW74yL<Y8Z&nV%(U-!tZWP03GskAy<m(6
z>tJyhj;llq&xAxvNOEL#EG8(jtvgDhCA~ChBk@>E?iYYcT7$s)FP!<Di2b+z=x{o+
zxvWLA!2<a;`#4)Ae2XOWhq>k7`Se00MZy-9shS8K;2p}v<qkON>B*6WFberfhMqOp
z=a2*4*;x-&oj&X?qbp^Gg@kmJU6_C{00&IcPbSH<Zm)Albd_7B!N2Hn$p-kp?;5VO
ze$PSjRdvi3f_&5S!rpv;gDjKX5NlAiBO1q_(nuXs8gc-4+vz6Q1K6aAZrNa8tOjwI
zO@q=Tlb^fsRKLW*shl?m`rEx_)+ZTV`^bPy>*D?nS4vWKCsDGtToVzZvC>zofIwSg
z?<B0+<hwuSrEA`@gLvXLSQdNi5s8+=`nF=vJ%4l%lb_ahPGtS(-zHkArRglJHw#}m
zsIAi5LtpVTe??~`yKvcVJ_&Vkea{KUIog)(aRKPMd`Oz(C^=L<kHU6gRqvv~4!n|t
z#YWLLDeE-O+#HtRzmk-UQBM)MI=XS*?fKu{ygiQ6)v>Xq^orqCr(0j%Z{8iD+nR@s
zC81|oO?_rELk$CVGy%)QVyw=!{#gbI{jD__qM{FyC_&YF$#Lrsub&%Fwfq(xpQkVb
z6P%*=YQLy!L@wVw<zfI300qCJrW(uVv|3B7UAZErKB%sra3g$Tci9R{06ctlfJU`!
zx(Pn{G<eHL;LQ@2!RB>_w-7s|D7jV)jv3&Y=UMei4~q(vL7VAmY;Wv_vQ>km(pA(r
zR;(>hy?-AU^^?8^<v8O#jRjsNnih|NZC@A=Ns9EO%P*&Jf<x2NgPfqx6?`3A=0$K1
zw%+|hH0`Fh>RT2zp?<zepo{o`NdQ1O8O(VYOQUaQCM<<qWY#e06QNJpr2VRp3pQUX
zyg$&N%I5PBAKNmWYn41Vklq%U^;^#r5Z1ugrAi|w@h7lH%R{Rz{&~WbY+)~Wt)YS(
zNYK!A6pX5~ra8w2xq$$ejeG&6f^0tFW-+FA$r*b2O_xrCW#_(<7-w|i+@B|+b6kt^
zu)qhQp$dyFVR%jlcrq!|dcN#%ofSVEdVc3ifJZ;?_3|MbT|S$04wYCY?OqNe8lWEd
z%hS*Ib4SX(Iq+|Gk{=+0%%%3^krOKdV`0w9Z@D+ac=`bMW8FXQm@deOI6@oBa~pS|
z;g#*bO>C}@aI_kViNGdy)?v!H-hrRe?vV44$>jlel43%CutYgI{_+p4GzIa@?JClg
z3qji&iv*rwUbv-UMks$)Z}>1vBWPYiq8+dgiQ8~!s7>y-#dZUtr&KvsB<!N{_au!~
z`-oHMg{T8wb6F<3<1>5{Aq;e5RL}cS8e7Bi0?xbI)M8aV8~7n6Lc86cq=^Tsn4UnH
zUppY4XX3CkJ@q9}nv5gA%(`1DQ0-Xp!b{vYzF4dzeAt|9Yy&%YYTvytSmdp@eQDsT
zbNsLa`6lx36#<^_P=!E5DNvxZqdkd6P!-4ask}x4VC@cKZc@^!@cUZp3;1s%bTi9p
zWm@M$OtJD;s#?rtL-gSS?+9}r44lm4!9y~W>;7IqSzAW{K<xL4@rUU^4rnK_EFur0
zr$G-9Ly?`;!tAzAE!U~K9`S8jZZLbEP}!L*Sqb7-JJ&K<sQruuw39NKusy_j6_9J}
zN^U8$(VwHu^6fk3Lf$?gH9l<D&kI60zq<Y_`!5Ev+Q4z(pK?7VYhcI@jIqm$9DrRU
zf{fS$Y|CC#uLkssc=T;{NBG_vxGc10aS4ORsN6e{t<(lfgUw>;o#5?EM*83wxb$J>
zi(GD7d{F>Q_DvOcPnDAXFxA_Wc{WuLIQPEwKP@VTPfg0>REA1bt_%gDX$DrHuydAP
zikS7Rq(|5Rc*9Wss#>vzYCa4M?K@?5Sg7~qk(aaZR7>9ZuKIXAKlLUi{z`*n4xx|%
zc`d8T2#J0D!+RFjyTe9Ueo$Wajgc$i8aUcC)augmX*UNeYQZXR)VA{z$zz}N-6k@|
zerI`2P*)3RwO7NaQTfS^8yR`j0RaEVK1=?*dnqKhf|t`JIuch!AqA_}cHpB{Q-mOe
zXhK@#FaB%oj$S`h|4)?!-05g@4h6O|w4TB8q_U9Pjk#7HQ+_ljC5G31xdv=!;WhtE
zRvPo*;+J#>7Jy3K5M!Zb(G>h4E@$Va+u(S6ob^QsI<4NLaDH!Z?urB-!%J%z4?9Ns
zBJ0C0$MxWKA^J2OdO!@!U3^QZjl1-jg$ir13WFfz-12>&UV_m@!pfx4ag1#*OTR|8
zlArLvyGxqWl(nfL*tznibb-;-@IR@?<B$bhEyqoF0)HH#wdnd<r#S1V3JVpCxI5D7
z625WzD7v^Vj|L-H9=Go@fattVOlhdV3T{oOde_|9+k<MAnXTEyPak}#8HXxW*Pzyz
z+9C|rtIx!y+^ul$R+#`{%0XP@zNj|Yv~}yl2eB=3qA2#{#F1eqdgxZ5E%AS`Wrfjm
zrc5VGU2LJs2wqtHypGs`vF3?5r!nRls~LnvFSQj!TY}}jzg*$AwixRcdfyA67mMi>
zrt?>uw_d9;MpN7f%M$r`Ll|$QgC5i$ZIQZ>#!EaEyg1j`3ttV;^9M`LHbyYaJ!71y
zCV0gO($kun7lV-lP0`{+)ai3!ln6{`W5LDC4}7)=RNC=PviqW|d5C9@F@goem&6TD
z({8Z;AbbWX#M0gMEUQr;K8T{6W$B0ItUs$L(P!SW0g9L%JS5tslF})6vUOWKS2k;i
zy3FZk<`21<wJ4t2{sQ1cR!vThcI5wh+Ypy!5CL67uRdKW7!#_`G;Nk3Pg#K9K1;up
zs!_dq<pa*wT*qR3*i4bO7|ZUPjy1bNN}|7*`VUjq6Y#Yz$FbiZ&mALX8-JG$zGZ$A
zV$|Hwtc%qQN#BS;_8`#MwyYk`n}_&(^3@YLFJb~xZO_|ELlr1xxf>^|KfQ}Eryb7Q
z%eef~a@G%IrO+@WZf=S3TRA;3jI@Z@rfUU8bK+BDynD`P3=+5ks9FBR!0XxwmBPRJ
z-!|zcB4}y~wx^T7-nbsrP=L)Hhar8TviIJtExSYgUn@^yh|WhDdIU5wbuciaAT~nS
z%dcdpp;Az*#~oq0s->GZGUEsU4-11{viD&V2g1UbQr$m0KwDOA0eK#DfA8P~kiv|X
zxPUZ=oH{o?D3wXaZoh-*Gfceh)GiXcLnV>zB9yxm6pKz*!N{G*$k1mhb@y7=L_l>u
z!3xFZv~H;5Mog%0M%9vP?eF6(TZBFXoRdCsLa5W@gYFmKAOc&#RwJAH!EOuKAct{v
z<ObwW5j##hDsGCyCKHZs!-->rj;G&=CDcpwd}|o$gJrapG<l`gqtd#gOC|5Mnc`26
z)n*8%j-{bBx1V0%2^pnEX*nA(&jy)fjnxH1yIJ0@dpLpT<mW+RquHt*Ezmgo25LqW
zlPS41>#GcxnWWcYQuKz;Q`yqFemnY=!|hPITABZOq=9<YQO_fX$>Xeih;Px;-?>iZ
z>Fp<2;a%%wo+#}U?ZrOSjmQHLhMY>jJ-PWlxlUy6K6I6=qy0;n9bqdWH3fd-*m8lw
z@2oU-A^20v44MpfQDSO{b8u7Eo;r?!=n!C!pTt<@zlF^qU!KICIMO>5`E-+YGsB(I
z1NTO_Z>V{H2(hM-8Dc~{yHqvu3|NfItyMHD0%e<Db2Ro*7XmY$wWiNZ^BeARA|O<h
zjRY5I%Dq{uXD#H=E;j#Ggi#1?lSb=^ANyYoKaS|P+=PkE(G9`6)*^a%4X0%PMZGR(
z>ov6B_uIhWsR-e8EJTu3MfLSpVHn&Ga-SC|z||wXGQV3Zz`N`g%BgS3XpwOMoD5*{
zI;S!~cgYC+VGIq)gN{ds6cRL4MYs3fU%z@do(+Jr5jFwV(~5l&PR*WL&Ul+$Kd`Q_
zXtp6IuTRf5_R%laaSt+prxq#|lCUZ6j-|V2Z?ZjSGh+ruqyS5@{H@1FAk2$Q63i<y
zP3zg#37?8s)bT5PB6X-d39f8ioetZ=^m(+(qt=95j_JwSU=wgupe&x=-`NkQ8#Dfl
z8O+kSV$^Z?$8aqj(;C|;&UOzA<{!&s922lZUvZwq)S=T1Z;e9RJJ^@-;%6`inF5*?
z+E5dOhfEqs%@;`P-alZVoCOZz%lC1_8)k>|gi2oomRo15`9=WO<paE;j&M-|aN|mA
zQ0ZsdmL$@im0S3YABKA~BfYAajl(YWFQoE`yUg(reJ5HFvJP3EPST|u@Q);t2m1IJ
zLz5bYOreuA#jw69j~?6nEnyon3~MxN66zcuzD^VMBzqGL^Az+t3(nbB6CFoR``JGh
zQAX_}bDLdTJ{)7xcE5`wJH>7`tvW^KA}N=L4pmF>pcEIF-T?0P(3?(BODcaPPtQ_G
z3-wKzi+07onJM|yUUD329G<3K=Ze~L%|>eX;h{Mt>+dUt{e{E}sl}-AM_DwR?G2NG
zqnV=9#h;-WzqUnL9#**?nfl@qQ?OTJBc2JFs1gUsx*1xXxy7q9Fgn2~VwlAVQdJda
zkPlzKyBMA|ANtg*iH^bc8IqAf`%rOKOpO`eChs=a#xyOs--C@_L#o^v#RDrnCws^!
zmR%q5E@e69%7h~fNrb|I)X(GW)g+k`^0Orq0zl<*Rk;L!RYz-y1L!qiY5nvhP{vF~
z9#%f&G3UUlBBDzePRlS(lo#LQ>yPP?jXZ|ib)kaU_u*YUhUJBf*j*Sy0sKBb9PSer
z;ljcXB!6b^iCp#rgPbvPonJl@$e>c7v$h)l1l>|0r7Ev$QA9zgm^t~CN>*K!r4i!p
zYX2e`$Xk<`86rFx%#iN-!Q)&db8id3!_(qaD|+j{4I&Vs?7sQl&-@H<Dj+Sc?`T-o
zNH&m4-bK(C^=|kv6c0XLh+16lZEUp63wC(WkhJDO)kIj&E!7=7<skdA42ax{zx<xU
z_@$|bkUa&m_P>(a_X*E7i>Z3{L3CU$nCq^t_WB+Hq6b#qLjZumg!(^&N^#Cj+FKof
zbxlx1PH4%I8%iYZ;eUl5_peq??ryJPG{X`@!#`MdQ7($Ar;T;YSZU^wg=1;&s@X=K
zv+EMnILeT#i+`Axr#P+l2tcPGcdp<46v@zXw@EiK+_?mOh9^+BKZQN($UQ9nB`)fI
zVLD3kH7u{*Icx-^CtI{(+(E4#9fmZbrKhQcY=%{6+CO~+<sb*%@*rDYVBmg~UVQX2
zSxFjX@{Lnk?$S<!_RQe|Rs;sx18^fz5vouhC>r;oVAkegx8x!-LSi^J!<2N4qEW}a
zrus|RVqSvVY1z>HlSE-k2jy@Oc#X`1=OIg@*W9e<VP)%eF#jk93b+W})SUhZ2q}PW
z9pC>5$+u6DLvSJez;Ew$7rN0p3)sz*6yJylpzg6s0rDh4DsxDY?_gCKctE_REjYXT
z(GXkop8RJoRMmO4_fyJ{D0<HE^1Y%ITGxhTP%3O0;=z;eK#1nWPH?%4MO`st#F&aI
zZ>Sby(pgFZ=1kqnn<9Up)~$xRwAv*wQEIO*$R3n&-y)B$1-xlNPr;EB)T%<N?goU&
zOlk^9{SJsceCE%CHOL%M9_tFMjR8UR;OIh0p7khiB?i<iL<)ldEXgoC#myLp)V?B8
zC!4|`G#1;dNK1sK4?`e$Mo#4wqCw0T{t<vYWCX#WPXo_w^pXet{i@e_2+|k*Q}gj`
zdg06ZF}$xTBi%2YXcE|QncuOIVb3smPno&k%xad1{IVO5Uv^Pa&p3v%zN7Ry`2##^
z6Ma-=LY$S(D(buo&>|5$FCIIRRd}=!TR#5^fqXYv``nOpr63%J6h?`&gV@I4zTIJH
z*c9H?OL${Z-?sFsI;m++cScLz`W*xD26-df7(vv5W+T{*qkIb-=yKZL`JHgv<iQA|
zhQtmQvmlQf1u*EDdfi||%puRnG@qLd8Td<_G3j^@KPT9*fk+HzN8H6nj%x?AGZaIQ
z8g_MT(o`N-;n2&IWR%JpzE(-!3un)DBUd%DgqM_M=Ohv7;|=vEzGHgWv!?iyM5)4w
zST9>#deKUTj>^MA<Ku?Z7Yb@NmyF;UtPxk>$a!h<gbPY)eZH%dtUe3rF#Z~aG>T>c
zndlz3KC>mZA>q7Fde;7-tct$E#@GD5@wHGDX-}d(M-WM)Tl;Llo?K3-BGS|E*RZXW
z6eJ)<gN-DMxY91=9vJXcsl$775UqSN(j0iN%|WZ(k8wpL3W>wAINfvJ3K5A(chHtC
zyV=nreWBs*C(po0`MO5oAsBd$-1$Mh&y*9QczyZ}KX~Z|@R9Y;a%UcD)Y`(6?kv&S
z_uU;LDLZVS`_tC!>;`AeJNukMdfnT!VKhu3&=V<PTy71DbaYMhbUxW|V6#m#75$(j
z)SpK+T<dhc|7wHE2S5rDSayxIGNiPIQjClX9DHv>l#1>5WVc^W6x+sFyarq{OTv_T
z7CB+axCtT%Q3J?NVFKUU@xZ>4so>2S9AZ?^53;~ejVZ;585Rtuf7l%>p_2)W;n1RK
zyaT*Iia@>D^PKHB(iAp`eO5>)g3%*0?ydf8&o8qkj_{_{;SX$dWFbSoQ~d&-n2Xm{
zEajYw@K~0BA*V4)Kz`QKqhRtx<L<dW8y*eyWId{5Gn1rLl0<z|Aod3^GQiYHJ(>KQ
zrJsi%wz=`Z!6_Nz&UQFc<f_z<+0Kqt{Te_ZiNwGTQ|K|T#ngA<Fi#nd%|TzH{xhSP
zZ`OLjGo$^>mJg_m4NO*2|8B2<vY?dFj1aO0%qd_cmNrN4USm{$`gFdGXPko_$kc8j
z;)g~4QG{#~*RVw9V00;W-mcI6ZKtF2Sn}?|DUZiSAN?CIgAI)6wVqI-!A39^*rQ#3
zYk;o4bB`5RA3I>dyU~IM^hs%j*g2{Y`8fpunDgo;&FL?_@^tNGJl&bO9&`CZto{K*
zbEYG^WxNyMt2>Le?^-%WlU(0n0_WiL?LHXxILtCGfTQWo)nM9@*%Hz}(hU4oO(G7)
zfcsFT%JPVhk}W|nm>HEB&az+o4^zvCdS<Q+ph5jB`WaQUXGQZUYmNsT#c!JjKOdI^
zU1SLT|47+Cr#A~v<ow~@f6x{iri-w!gC1NsU0jhg0FQ>;X*Y6ey_5~;tu<n?whadO
zibvyyDoKr$vA&>zeMT$bNR34Vt-;k2ql2z(q6|jKVoAVz9tNI@9+}Y!TK+qMAKh!B
z{qF>d_Df7?(npsjoGz?C*p>7A-b6vr;@>5w{SMD<U_eYdq1Cw88LAJ$qd(u9r;h*@
z)-<^uBJWrxynf7YjoZVTyL7U^Zmdh5BRyTRR8-gSOW!w3gpbj){Q9wwwd7@y#Y<kB
zDGabtsDN+5M1wwJ<f(P(&KEGuX)ryw23g9a3MNhIpM;$vd*gp<JxcF<nKtUXKe%HF
zp-YVW_RgW@1<<=uhzFZ<H^hZ6f%h-}^KRb#t`UL;Y;E8osb_**T;7QJ4~zr4<D8C;
z+W38Ui{0G$7SxZPXbQ@@fS;cVqg}vb7if63s&XZ)3@Dvc6@ZxNqZO-@*Khlr1@Bw;
z&UZ#?mPS|~0|xwND0yY_%_Yd><eB_Faf8f$V~r4bfMZUU)Elu>gs~w3rUv_o?(*wp
z|JTu($3xYHaeNj_7+Z{eExV!Yqht*!TaAz<W{`?(mB=t-X(Eh}H4^noDNEV1GX^0N
zF)GUpA%uh(OXI!M{rBE;&VA13cb;?Zx!?0VyyO44-oiv&i1BcsQQ5AJN1S6pPWoDY
zvnmSoDyF5)6)dyw-`kuv8_{FZeZ(SE(U{e*e};!fmGyWxck25Du7&A|gBs0Xz}AOT
zbJ7s?E(<*zQ1R%LWNQ04)`0OPydXgxOF3v!<a&|(y2N0Y-ai$EA^~3lXfr&+PWVtp
z*!WK>W%;ue<Wc?*?3tg$;QW+{Px{4mPpJSvG&b{UW#QY&{Uf*=fy@(7(*!J+xYE&)
z5D{k3KZU@jN#|LjlUqI8g!KI8He595C}6`2s#KBr>K}$V(b`^tOR-d<StD7fsE}0&
zyjfZEo-Prd*bY}HLxJX9L9k~(ZWqM4|I=zY4J#GMYSuxXxE)tE9<W#+ePG+P!N)gS
zWs-8SqHCB1nkV8c3b$XtQ>J-rUQdr!=B1#y=b%#UfMf=iUA+OQRy9Angl@zGV_1U{
zB@b!C3hz<C4uHw%bw#Wwl+}{Zd}{358`24s@)qH@?`w-nnrr$&;sjHZI?@PWj~K|r
zOm=WV-l5cey&Ht-0RvPxArDF@u9AN;E3a63WHf|Z6TrnsPCZ|nUidHeUM0N}o{r{5
zs{s-*-<%ysPO!*Wr8dV74xzY4Zan(1Hv2IE^hBG(I?Wi*fDwQFLRM|iZcNk2`ez<1
zwvfZA!fdM<)}UN-%EK=vD6{MtD4_8#|6Oqhby@D;l$eFs&kosnT3k4FIUw~I0B8!g
z>qm?MgzK|8c`R_Az*g_2%lBowlBvW`?!nj%W98wwHvt{xpj-%ri=RaZ>kf2Of;}+q
zu+qCu(Z(JG<`yn<?rKY{6ELyO^<h?0n^*{_7J_svgaEwWs#RsAAML79oW!=ZBJjs(
zi1U0^Y`X$lpRdD?)j`n1qBL7TaFY*AHJslmNhkGIVeoLHOvyFc>3tGlyanwA;}tL_
zg3Q^%mw74;LTaviTs0=;Jif{_k*~cu`zH0((1YVyRJ(%MWme0+tMTz^ESJgW5gfgR
zXpM4S+gba#nw-l3L0*<{0{IX#c`B*49{*I?Wr!RCY_1nDdFPe(-u|y)fx#E9;~-85
zCd^x+wX+3Rs<9(}l1;l1#6tKlcU%IPQ~_9KM$xSB=0C(;&KLPwj--G&Ved19D}D1`
zKp9g7c&pM|3AaeHV-sxNpVv<idw#K`ow6^b>|MsX=^Md~|IprqWTUgR6gC6F66`=q
z(iJaaF8Ap+iaWmj6_X)M2H5HB35p~?tDP{K5tgV7$<>{^20HyGY<vlhfvjtrDk&yc
z=>STJX8<8SwOPGrdF#MToa-mb+H9!^5W%A}fhh<7Dwuai8l3aJSlSdCzd+9%IjLe>
zE5v>Uink#N@2CB>$|FAG^y=hiO=tYIZ1d(9O6Dz}>jEA@*p|%mnwdxR6|g7ou*_H~
zYvF<@f%ibilO{kzK$3+Mj}#kVUMvh(CNb9z`#?R@4WrxX5OEs}B*e6tNL*m%@%gI|
z$z-7PD~HzpgEGbZZFpkSiCfaZ14)cSfC00Y5~pWwvK~lAmCVC(9+AH%dh~OEEUYm8
zM!?icP>m%s^!^>Jxa~{*i{nIV6fQr40-0pfEh(aRSQehehz9{~7#00MhM99H_)tOl
za0gHUMxWT;#?pnNw&-*Xi-GQYOiz2Y=h1&f*_6<J63ILMja7Q#8zY-_w1E{|G^LsN
zjy0PCNVrLN4h!*S2deU!xmfUVspuz0v-28@=$AM$!N%%_YFkoH^pY1q8V8>10^wKE
zEdu*LX%rCqSp|hp`xroW*@3aKm`AAP^g-EnxVgfgX_cV8G<yP@lMU9jpOBL~m#&CR
z#!Dq^0X#9<$hm#p3i;4@fW#TWSxNP4?$bCg<uc>CssRM6*!(qVtsDDT4v-_UgCgGK
zBeZE+D@OK_S?y{29Wl(GA(afR;^)xo+aBvYJAF`j7>95rXi@l^d>r2mJQc=weW4v=
ze{}MYY{z!)XCR{*YO_P+5?(n(_K7-ES;M7kl_Cf|TA4RSm+YG6$w7;*;4g34fZ9#S
zsgc<XNhv`@kZ^dnwbt<~2K6|2YseMh@UHEAw~+T-25<xv#W9*2Z(ni|Qqr>>t(D~q
z<LhY^TSDz$_|qs$JXOVcrPqY&eEw6bbJ%UEl)@RDGw>mb?!6caG9Gj4h#@_5RGm{<
zxnFo(z|`qCXTKCdx(Yg#ZZN|vaf3V*suDGhlj!r{hG(OV!h4+UNHq$?`(0GtW&YV}
zo;q`0)5))OV(LCFfz)pfPxitJQ}AkaxJP$w`Gx}kocsu^9gXac8WFt2>qVw+EYPZ(
z@1>(cRqD<gZ!?V}ihH+!IJ}4hc6Cl~St)$%nYaFoh=LS{UUf^b;Nu^@EAgrQ755&(
zGOIZC-#%NhH<h;bUjItrm2BvAEhp6GYajoj&<GFKU*g)^R!b_Gi~~ZH*gpJ#6b%5c
zw@qydftbPN)E67F4W|(wtOZo7^!PfQy0+?DaLX!lw-M}h?PjhHs!(0)4Yep<ET2#o
z{fgR6Kdj|cQhC>Bsb#d!O1w?N+uK`@?!zQ8{I5NI#jUvX+k;$_J;DVKbK8=GTv6#w
zjk+?Ti^6a7g$~>6@&juqlc?E17-;LqVLvb1EH9xoU%17#w=!0ueBw3tM7(r}oRXW`
zUmqkGs_k1Pq}0#TwfBCMq)*`yS{b!K5j3h#cDrYJ^Q=6`x-ka1PJuKf_<FMseG*6&
z#OLD_0EoMkoP^{XX2yIs5Z}3Dw{QMLwe*FkIbZh_666Ej*_HNgMjvGBEtds;L-d+a
zq>I|G{))DGDLJUDe&CHgOw|&z)SmnS!Y3hJm}i>PZHTc9WO$DXt?)zha<M$gx|+vI
zu-{<ZUV^KRWG|K{H?;p{!!$5i8m<lO&Dy=HKhlHRi%kdq*NCMJ(ayxVKi;{g!)=o3
zb;cjko6b<!w$L3jZT8qvI{@;CMxn26@YvK^d{}f`5xrTjB<_~dK0e3)IUf|pzVe{(
zA>ym)VC5-8sgu-MF27#)xHKP5Se-H$Po;omYZ1^9@dT_8;1@iI<n&YrHOqO!?=LT}
zGdF`81sO?3mIJm*_yT-<Rg{lS<~8mTxjnavl)u$Fcg@!Pzoe>W^sRp=-A(Hs@qP8a
zhd>RCBr=Xy!_?9IfwFmVPb1_OT=;#e)$0^{KZUWqk-VUk<qZq(*0<wQ+1dG9^9P9P
z#Bma{EGBN-#wH{0?RMHj2v9S~+q&SYm}6<%Cj~tGx95&wb%9%RL5f9Hi~i@cRo@%u
z1G`-cJtR53za_#(i`NPsy3fw+he3}+igKm}qq!7ZrK8Y17e*g<5)6M_r$|2*Jh~=K
z%T;wDS5Oo}S7e982K{gMonDDcg=$CW4QeIjdI0NourtX(_s_@1ON$}-i|Tizu_B_M
zALMwEh*XPI+@wqvuFk7aGb(ru5h#0;Znl)KJMo`bTBdx~(oxr==k<<0_MZ&axHQ&Y
zEO-A*hO$q<FX^AQl_Ezj+|74Gg5A|_3Z7M^&Dp4TXi=n?yLQ?wnd3T<!umI+f*J2C
zr(ilG*;R@kMng0?^tKD_cbBsJm^piNuJ__vIk8`j{7nBsZ%@}_p~IUQsIh2z?lP$S
zHPs2W`D3+G=)f~-!Re=yb$B|8yNvUP#@q!#wD^+UxcN)RXv-Qh-f?hq_?Rc<bq%nE
z{B-bo(FeSCHsD_eUQ}0L22Yh?oYX779J4-H81ds3zMNR5C$!VH;g#||xPiX>*T(P0
z5BcFIsfS=p>}=n|{I<osqe&Xz=EDsYGK`VwfbTam3Vs$#&~d2A8?M}I?sqSbjNRBT
zQobhBEV9G<%I&fPSV?W98(4;^h{ez99ZOp5pFL$nu+BfGw51p0OlnmSznrM5qn5d3
znOi98v!*cpcC=ofo0D*MBxe`=gpB)LH;;Ad{+(_kA}uZw!ZA14dCN}IW|ungJVN8o
zDPMoW_TXq~&XfZBgzUR<8>Da*9yr`H-|z{96{c6ehvI}Q_4!h|!AP-F#fBHYSVW{W
zUqop4tshzX82#F#InrVB6|@+c{mYMj7DbS&VDl5}<K%EN|L^l;Qw-=pAXuL-txJ=_
zqnGd(9H(&<guO6zOho8;#6=W;C<AUMvl^^Zqh0p3Au;5W8dv8KW_YM;d69qR&cl7<
zo9?-NPEuwRWx2+HdozOgAb+WCZmbLaWDZS|cJj$CXV-n&I8smtZb7B4k*ex19jZP(
zG5e|qvHZaPyf1b*Ninzh*X^^LJq7)i5JL`Go;h&@$wxd!Glu#SXF4D_PJNsUPcN0}
zwKm6`If_G_LXh2yJMKhlEED}sBgo(KPdGal77u<t10+M2?0*x$Y`%Hv65$TKE%v$4
zVcU9dZGkM!+Cb1PgZnDm6rQ#dON_<_18i{w?+dhj;8c)tk-|q~6aFFcxwc*hkrlSB
z5}IpdkV{nY6(`AP#<g2bioZo#??<xP+)1zT+N+_w+e(adWE*+i)Y6h|cz<P&t+o4l
zfjm_L3xU|T3kZBPu@1G9?s9>Q<iUEBL5m(tqZmb*i=K!pw5aN1D)fP~3>C8s(MNsL
z{R<|@mV~eCFg&w#<0m~&mVYL2PKWfSkz7p4d-$i8cIgZHw|tC^imz^+9M_+-1y3Vj
zCMqQy=C)~`D|EI&b&t4lOaN7Ne>B%396Gb*7}N3Ng#&fr-Z%i5L~!6`se33-@HTi6
zQ;PoOiRG!dMJlhHx$enF3yqWv=jHuqJ;8fN@?K;Iec~YBop>_zO+<NKX!_scoTo(J
z>9nZzJHPA93H#3{>UPeJE*L@$mhF=k=Aab)kTY3B;SmXP{kJ}j+MCF9YS2!3jgf1+
z1M>G4dyY2P4Zx(v*dcvO9A)}uyT8R&1=gT%89)kW-cJEZJ)xpgL)bK1f5H0X<arx3
z^y#@gg3fPx^rIJX_Tf3n4QPsq_X6db0++Xrq4|Jb;vbQDOvEBZ`+GuL_lkcGy?^Zn
zBJp&g7vWpTGX_4_V%NCnZj5p6H@#|&P-vZ2U6+%gE#i3JhKz_+xVbCwU`Ag{{l}!D
zzmkaMSB&9mk2I!^D)WaH{T~}YZPk@)!%~A}(a>{zr~8(&QW1jvfd8>lP@|jtb^{2w
NY%J|hSD1Up{SQx{v}6DP

literal 0
HcmV?d00001

diff --git a/README.md b/README.md
index f0f3fac..bee4bfe 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,10 @@
 <div align="center">
 
-<img src="frontend/public/scholar_logo.png" alt="Scholarr" width="120" />
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset=".github/logo-dark.png" />
+  <source media="(prefers-color-scheme: light)" srcset="frontend/public/scholar_logo.png" />
+  <img src="frontend/public/scholar_logo.png" alt="Scholarr" width="120" />
+</picture>
 
 # Scholarr
 
@@ -92,13 +96,15 @@ BOOTSTRAP_ADMIN_PASSWORD=<secure-password>
 
 ```mermaid
 graph LR
-    Scholar[Google Scholar] -->|Scrape HTML| Parser[Parser & Fingerprinting]
-    Parser -->|Deduplicate| DB[(PostgreSQL)]
-    Parser -.->|Identify| APIs[arXiv / Crossref / OpenAlex]
-    APIs --> DB
+    UI[Vue 3 Dashboard] <-->|REST + SSE| API[FastAPI]
+    API --> Scheduler[Scheduler]
+    Scheduler -->|Scrape HTML| Scholar[Google Scholar]
+    Scholar -->|Parse & Deduplicate| DB[(PostgreSQL)]
+    Scholar -.->|Identify| Ext[arXiv / Crossref / OpenAlex]
+    Ext --> DB
     DB -->|DOIs| PDF[PDF Resolution]
     PDF -->|Unpaywall / arXiv| DB
-    DB --> UI[Vue 3 Dashboard]
+    API <--> DB
 ```
 
 ## Tech Stack
-- 
2.49.1


From 804b98423cfe7a446dd183e47cfc1024aa6fc6b1 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 11:02:59 +0100
Subject: [PATCH 19/38] docs: rewrite agents.md with complete, accurate agent
 instructions

- Add file length target (400 lines) and ceiling (600 lines)
- Fix testing command (was missing python -m pytest)
- Add conventional commits, ruff/mypy, structured_log, uv rules
- Remove duplication with contributing.md
- Tighten UI section with concrete references

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 agents.md | 106 +++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 77 insertions(+), 29 deletions(-)

diff --git a/agents.md b/agents.md
index f2f16bf..7200d7a 100644
--- a/agents.md
+++ b/agents.md
@@ -1,47 +1,95 @@
 # AI Agent Instructions: Scholarr
 
-Adhere strictly to these constraints.
+Adhere strictly to these constraints when working on this codebase.
 
-## 1. Coding Standards (Strict Enforcement)
+## 1. Code Quality
 
-- **Function Length:** Maximum 50 lines of code per function. Break down complex logic into small, testable, single-responsibility functions.
-- **DRY (Don't Repeat Yourself):** Abstract repetitive logic immediately. No duplicate boilerplate for database queries, API responses, or error handling.
-- **Negative Space Programming:** Utilize explicit assertions and constraints to define invalid states. Fail fast and early. Do not allow silent failures or cascading malformed data, especially in DOM parsing.
-- **Cyclomatic Complexity:** Flatten logic. Use early returns and guard clauses instead of deep nesting.
-  no magic numbers
+- **Function length:** 50 lines max. Extract helpers ruthlessly.
+- **File length:** 400 lines target, 600 lines hard ceiling. Files above this must be decomposed before adding more code.
+- **DRY:** Abstract repeated logic immediately. No duplicate boilerplate for queries, responses, or error handling.
+- **Negative space programming:** Fail fast with explicit assertions and guard clauses. No silent failures, especially in DOM parsing.
+- **Cyclomatic complexity:** Flatten with early returns. No deep nesting. No magic numbers.
+- **No dead code:** Do not leave commented-out code, unused imports, or backward-compatibility shims. Delete cleanly.
 
-## 2. Domain Architecture & Data Model
+## 2. Architecture
 
-- **Data Isolation:** Scholar tracking is **user-scoped**. Validate mapping/join tables; never assume global links between users and Scholar IDs.
-- **Data Deduplication:** Publications are **global records**. Deduplicate via Scholar cluster ID and normalized fingerprinting prior to database insertion.
-- **State Management:** Visibility and "read/unread" states exist exclusively on the scholar-publication link table, not the global publication table.
-- **API Contract:** Exact envelope format required:
-  - Success: `{"data": ..., "meta": {"request_id": "..."}}`
-  - Error: `{"error": {"code": "...", "message": "...", "details": ...}, "meta": {"request_id": "..."}}`
+### Data Model
 
-## 3. Scrape Safety & Rate Limiting (Immutable)
+- Scholar tracking is **user-scoped**. Never assume global links between users and Scholar IDs.
+- Publications are **global, deduplicated records**. Deduplicate via cluster ID and normalized fingerprinting.
+- Read/unread, favorites, and visibility state live on the **scholar-publication link**, not the publication.
 
-These limits prevent IP bans and are not to be optimized away.
+### Service Boundaries
 
-- **Minimum Delay:** Enforce `INGESTION_MIN_REQUEST_DELAY_SECONDS` (default 2s) between all external requests.
-- **Anti-Detection:** Default to direct ID or profile URL ingestion. Name searches trigger CAPTCHAs.
-- **Cooldowns:** Respect `INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS` (1800s) and `INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS` (900s) upon threshold breaches.
+All business logic lives in `app/services/<domain>/`. No flat files in `app/services/` root. Each domain owns its application service, types, and helpers.
 
-## 4. Current Environment & Stack
+### API Envelope
 
-- **Backend:** Python 3.12+, FastAPI, SQLAlchemy (Async/asyncpg), Alembic.
-- **Frontend:** TypeScript, Vue 3, Vite.
-- **Infrastructure:** Multi-stage Docker.
+All `/api/v1` responses use this exact envelope:
 
-## 5. Domain Service Boundaries
+```
+Success: {"data": ..., "meta": {"request_id": "..."}}
+Error:   {"error": {"code": "...", "message": "...", "details": ...}, "meta": {"request_id": "..."}}
+```
 
-- **Strict Modularity:** Flat files in the `app/services/` root are strictly prohibited. All business logic and routing must reside exclusively within `app/services/<domain>/`.
+Use the Pydantic envelope schemas in `app/api/schemas.py`. Do not construct raw dicts.
 
-## 6. UI rules
+## 3. Scrape Safety (Immutable)
 
-Make sure to properly integrate tailwind in combination with the preset theming
-Clarity through both styling and language are a priority. all UI elements need to have a proper reason for existing.
+These constraints prevent IP bans. They are not tunable to zero and must not be optimized away.
+
+- Enforce `INGESTION_MIN_REQUEST_DELAY_SECONDS` (default 2s) between all external requests.
+- Default to direct ID or profile URL ingestion. Name searches trigger CAPTCHAs.
+- Respect `INGESTION_SAFETY_COOLDOWN_BLOCKED_SECONDS` (1800s) and `INGESTION_SAFETY_COOLDOWN_NETWORK_SECONDS` (900s) upon threshold breaches.
+
+## 4. Logging
+
+Use `structured_log()` from `app/logging_utils.py` for all domain logging. Do not use raw `logger.info()` / `logger.warning()` calls.
+
+```python
+from app.logging_utils import structured_log
+
+structured_log(logger, "info", "ingestion.run_started", user_id=user_id, scholar_count=count)
+```
+
+Every event name should be dot-namespaced to its domain (e.g., `arxiv.cache_hit`, `ingestion.safety_cooldown_entered`).
+
+## 5. Stack & Tooling
+
+- **Backend:** Python 3.12+, FastAPI, SQLAlchemy 2.0 (async/asyncpg), Alembic
+- **Frontend:** TypeScript, Vue 3, Vite, Tailwind CSS
+- **Infrastructure:** Multi-stage Docker, Docker Compose
+- **Package manager:** `uv` (used in Dockerfile and CI; `uv run` prefix for all commands)
+- **Linting:** `ruff check .` and `ruff format --check .` (config in `pyproject.toml`)
+- **Type checking:** `mypy app/`
+- **Versioning:** python-semantic-release with conventional commits
+
+## 6. Commits
+
+Follow [Conventional Commits](https://www.conventionalcommits.org/):
+
+```
+<type>(<scope>): <description>
+```
+
+Types: `feat`, `fix`, `docs`, `ci`, `refactor`, `test`, `chore`, `perf`.
 
 ## 7. Testing
 
-All tests need to be ran using containers. `docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app`
+All tests run inside containers:
+
+```bash
+# Unit tests (default, excludes integration)
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app python -m pytest
+
+# Integration tests
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app python -m pytest -m integration
+```
+
+Markers: `integration`, `db`, `migrations`, `schema`, `smoke`.
+
+## 8. Frontend
+
+- Use the tokenized theme system (`frontend/src/theme/presets/`). Do not hardcode colors.
+- Integrate Tailwind with preset theme tokens. Reference `frontend/scripts/check_theme_tokens.mjs` for enforcement.
+- Every UI element must have a clear purpose. Clarity through styling and language.
-- 
2.49.1


From 8407ab6be04e9a2180c5c99b942581cab10358b8 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 11:06:38 +0100
Subject: [PATCH 20/38] docs(agents): expand testing section with ruff, mypy,
 and frontend gates

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 agents.md | 34 +++++++++++++++++++++++++++++++---
 1 file changed, 31 insertions(+), 3 deletions(-)

diff --git a/agents.md b/agents.md
index 7200d7a..9f81a20 100644
--- a/agents.md
+++ b/agents.md
@@ -10,6 +10,7 @@ Adhere strictly to these constraints when working on this codebase.
 - **Negative space programming:** Fail fast with explicit assertions and guard clauses. No silent failures, especially in DOM parsing.
 - **Cyclomatic complexity:** Flatten with early returns. No deep nesting. No magic numbers.
 - **No dead code:** Do not leave commented-out code, unused imports, or backward-compatibility shims. Delete cleanly.
+- **Variable naming:** Any variable outside of a lambda functions or iterators should be descriptive. Code should be readable for maintainers.
 
 ## 2. Architecture
 
@@ -74,9 +75,11 @@ Follow [Conventional Commits](https://www.conventionalcommits.org/):
 
 Types: `feat`, `fix`, `docs`, `ci`, `refactor`, `test`, `chore`, `perf`.
 
-## 7. Testing
+## 7. Testing & Quality Gates
 
-All tests run inside containers:
+All commands run inside containers. Do not run bare `npm`, `pytest`, or `ruff` on the host.
+
+### Backend
 
 ```bash
 # Unit tests (default, excludes integration)
@@ -84,9 +87,34 @@ docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app pyth
 
 # Integration tests
 docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app python -m pytest -m integration
+
+# Linting
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app ruff check .
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app ruff format --check .
+
+# Type checking
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app mypy app/
 ```
 
-Markers: `integration`, `db`, `migrations`, `schema`, `smoke`.
+Pytest markers: `integration`, `db`, `migrations`, `schema`, `smoke`.
+
+### Frontend
+
+```bash
+# Type checking
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm run typecheck
+
+# Unit tests
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm run test:run
+
+# Lint
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm run lint
+
+# Production build
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm frontend npm run build
+```
+
+All four gates must pass before a PR is considered ready.
 
 ## 8. Frontend
 
-- 
2.49.1


From 19ca690d8449732ae09dd9f5dfa158cafd90824a Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 11:10:56 +0100
Subject: [PATCH 21/38] docs: add CodeQL, release, Python version, and license
 badges to README

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index bee4bfe..e2bf4f6 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,11 @@ Track Google Scholar profiles, discover new papers automatically,
 resolve open-access PDFs, and stay on top of the literature you care about.
 
 [![CI](https://img.shields.io/github/actions/workflow/status/justinzeus/scholarr/ci.yml?style=for-the-badge)](https://github.com/JustinZeus/scholarr/actions/workflows/ci.yml)
+[![CodeQL](https://img.shields.io/github/actions/workflow/status/justinzeus/scholarr/codeql.yml?style=for-the-badge&label=CodeQL)](https://github.com/JustinZeus/scholarr/actions/workflows/codeql.yml)
+[![Release](https://img.shields.io/github/v/release/justinzeus/scholarr?style=for-the-badge)](https://github.com/JustinZeus/scholarr/releases)
 [![Docker Pulls](https://img.shields.io/docker/pulls/justinzeus/scholarr?style=for-the-badge&logo=docker)](https://hub.docker.com/r/justinzeus/scholarr)
+[![Python](https://img.shields.io/badge/python-3.12+-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)
+[![License](https://img.shields.io/github/license/justinzeus/scholarr?style=for-the-badge)](LICENSE)
 [![Docs](https://img.shields.io/badge/docs-scholarr-2e8555?style=for-the-badge)](https://justinzeus.github.io/scholarr/)
 
 </div>
-- 
2.49.1


From 73c42a384b862f9e22f942e60f50fd2d21c7383a Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 11:25:13 +0100
Subject: [PATCH 22/38] chore: add MIT license and Buy Me a Coffee funding link

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/FUNDING.yml |  1 +
 LICENSE             | 21 +++++++++++++++++++++
 2 files changed, 22 insertions(+)
 create mode 100644 .github/FUNDING.yml
 create mode 100644 LICENSE

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..f5f3785
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+buy_me_a_coffee: justinzeus
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..6d0fc52
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JustinZeus
+
+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.
-- 
2.49.1


From 4741a2da508574686e2a3fee9052f274dfc403b1 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 11:41:19 +0100
Subject: [PATCH 23/38] updated uv

---
 uv.lock | 1730 +++++++++++++++++++++++++++++++------------------------
 1 file changed, 987 insertions(+), 743 deletions(-)

diff --git a/uv.lock b/uv.lock
index c151172..cc622b5 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 1
 requires-python = ">=3.12"
 resolution-markers = [
     "python_full_version >= '3.14'",
@@ -15,18 +15,18 @@ dependencies = [
     { name = "sqlalchemy" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/94/13/8b084e0f2efb0275a1d534838844926f798bd766566b1375174e2448cd31/alembic-1.18.4.tar.gz", hash = "sha256:cb6e1fd84b6174ab8dbb2329f86d631ba9559dd78df550b57804d607672cedbc", size = 2056725, upload-time = "2026-02-10T16:00:47.195Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/13/8b084e0f2efb0275a1d534838844926f798bd766566b1375174e2448cd31/alembic-1.18.4.tar.gz", hash = "sha256:cb6e1fd84b6174ab8dbb2329f86d631ba9559dd78df550b57804d607672cedbc", size = 2056725 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/29/6533c317b74f707ea28f8d633734dbda2119bbadfc61b2f3640ba835d0f7/alembic-1.18.4-py3-none-any.whl", hash = "sha256:a5ed4adcf6d8a4cb575f3d759f071b03cd6e5c7618eb796cb52497be25bfe19a", size = 263893, upload-time = "2026-02-10T16:00:49.997Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/29/6533c317b74f707ea28f8d633734dbda2119bbadfc61b2f3640ba835d0f7/alembic-1.18.4-py3-none-any.whl", hash = "sha256:a5ed4adcf6d8a4cb575f3d759f071b03cd6e5c7618eb796cb52497be25bfe19a", size = 263893 },
 ]
 
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 },
 ]
 
 [[package]]
@@ -37,9 +37,9 @@ dependencies = [
     { name = "idna" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592 },
 ]
 
 [[package]]
@@ -49,9 +49,9 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "argon2-cffi-bindings" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657 },
 ]
 
 [[package]]
@@ -61,70 +61,70 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cffi" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393, upload-time = "2025-07-30T10:01:40.97Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328, upload-time = "2025-07-30T10:01:41.916Z" },
-    { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269, upload-time = "2025-07-30T10:01:42.716Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558, upload-time = "2025-07-30T10:01:43.943Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364, upload-time = "2025-07-30T10:01:44.887Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637, upload-time = "2025-07-30T10:01:46.225Z" },
-    { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934, upload-time = "2025-07-30T10:01:47.203Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158, upload-time = "2025-07-30T10:01:48.341Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597, upload-time = "2025-07-30T10:01:49.112Z" },
-    { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231, upload-time = "2025-07-30T10:01:49.92Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121, upload-time = "2025-07-30T10:01:50.815Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177, upload-time = "2025-07-30T10:01:51.681Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090, upload-time = "2025-07-30T10:01:53.184Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246, upload-time = "2025-07-30T10:01:54.145Z" },
-    { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126, upload-time = "2025-07-30T10:01:55.074Z" },
-    { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343, upload-time = "2025-07-30T10:01:56.007Z" },
-    { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777, upload-time = "2025-07-30T10:01:56.943Z" },
-    { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180, upload-time = "2025-07-30T10:01:57.759Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715, upload-time = "2025-07-30T10:01:58.56Z" },
-    { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" },
+    { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393 },
+    { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328 },
+    { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269 },
+    { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558 },
+    { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364 },
+    { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637 },
+    { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934 },
+    { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158 },
+    { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597 },
+    { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231 },
+    { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121 },
+    { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177 },
+    { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090 },
+    { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246 },
+    { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126 },
+    { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343 },
+    { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777 },
+    { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180 },
+    { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715 },
+    { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149 },
 ]
 
 [[package]]
 name = "asttokens"
 version = "3.0.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047 },
 ]
 
 [[package]]
 name = "asyncpg"
 version = "0.30.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2f/4c/7c991e080e106d854809030d8584e15b2e996e26f16aee6d757e387bc17d/asyncpg-0.30.0.tar.gz", hash = "sha256:c551e9928ab6707602f44811817f82ba3c446e018bfe1d3abecc8ba5f3eac851", size = 957746, upload-time = "2024-10-20T00:30:41.127Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2f/4c/7c991e080e106d854809030d8584e15b2e996e26f16aee6d757e387bc17d/asyncpg-0.30.0.tar.gz", hash = "sha256:c551e9928ab6707602f44811817f82ba3c446e018bfe1d3abecc8ba5f3eac851", size = 957746 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4b/64/9d3e887bb7b01535fdbc45fbd5f0a8447539833b97ee69ecdbb7a79d0cb4/asyncpg-0.30.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c902a60b52e506d38d7e80e0dd5399f657220f24635fee368117b8b5fce1142e", size = 673162, upload-time = "2024-10-20T00:29:41.88Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/eb/8b236663f06984f212a087b3e849731f917ab80f84450e943900e8ca4052/asyncpg-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aca1548e43bbb9f0f627a04666fedaca23db0a31a84136ad1f868cb15deb6e3a", size = 637025, upload-time = "2024-10-20T00:29:43.352Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/57/2dc240bb263d58786cfaa60920779af6e8d32da63ab9ffc09f8312bd7a14/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c2a2ef565400234a633da0eafdce27e843836256d40705d83ab7ec42074efb3", size = 3496243, upload-time = "2024-10-20T00:29:44.922Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/40/0ae9d061d278b10713ea9021ef6b703ec44698fe32178715a501ac696c6b/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1292b84ee06ac8a2ad8e51c7475aa309245874b61333d97411aab835c4a2f737", size = 3575059, upload-time = "2024-10-20T00:29:46.891Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/75/d6b895a35a2c6506952247640178e5f768eeb28b2e20299b6a6f1d743ba0/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0f5712350388d0cd0615caec629ad53c81e506b1abaaf8d14c93f54b35e3595a", size = 3473596, upload-time = "2024-10-20T00:29:49.201Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/e7/3693392d3e168ab0aebb2d361431375bd22ffc7b4a586a0fc060d519fae7/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:db9891e2d76e6f425746c5d2da01921e9a16b5a71a1c905b13f30e12a257c4af", size = 3641632, upload-time = "2024-10-20T00:29:50.768Z" },
-    { url = "https://files.pythonhosted.org/packages/32/ea/15670cea95745bba3f0352341db55f506a820b21c619ee66b7d12ea7867d/asyncpg-0.30.0-cp312-cp312-win32.whl", hash = "sha256:68d71a1be3d83d0570049cd1654a9bdfe506e794ecc98ad0873304a9f35e411e", size = 560186, upload-time = "2024-10-20T00:29:52.394Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/6b/fe1fad5cee79ca5f5c27aed7bd95baee529c1bf8a387435c8ba4fe53d5c1/asyncpg-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:9a0292c6af5c500523949155ec17b7fe01a00ace33b68a476d6b5059f9630305", size = 621064, upload-time = "2024-10-20T00:29:53.757Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/22/e20602e1218dc07692acf70d5b902be820168d6282e69ef0d3cb920dc36f/asyncpg-0.30.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05b185ebb8083c8568ea8a40e896d5f7af4b8554b64d7719c0eaa1eb5a5c3a70", size = 670373, upload-time = "2024-10-20T00:29:55.165Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/b3/0cf269a9d647852a95c06eb00b815d0b95a4eb4b55aa2d6ba680971733b9/asyncpg-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c47806b1a8cbb0a0db896f4cd34d89942effe353a5035c62734ab13b9f938da3", size = 634745, upload-time = "2024-10-20T00:29:57.14Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/6d/a4f31bf358ce8491d2a31bfe0d7bcf25269e80481e49de4d8616c4295a34/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b6fde867a74e8c76c71e2f64f80c64c0f3163e687f1763cfaf21633ec24ec33", size = 3512103, upload-time = "2024-10-20T00:29:58.499Z" },
-    { url = "https://files.pythonhosted.org/packages/96/19/139227a6e67f407b9c386cb594d9628c6c78c9024f26df87c912fabd4368/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46973045b567972128a27d40001124fbc821c87a6cade040cfcd4fa8a30bcdc4", size = 3592471, upload-time = "2024-10-20T00:30:00.354Z" },
-    { url = "https://files.pythonhosted.org/packages/67/e4/ab3ca38f628f53f0fd28d3ff20edff1c975dd1cb22482e0061916b4b9a74/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9110df111cabc2ed81aad2f35394a00cadf4f2e0635603db6ebbd0fc896f46a4", size = 3496253, upload-time = "2024-10-20T00:30:02.794Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/5f/0bf65511d4eeac3a1f41c54034a492515a707c6edbc642174ae79034d3ba/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04ff0785ae7eed6cc138e73fc67b8e51d54ee7a3ce9b63666ce55a0bf095f7ba", size = 3662720, upload-time = "2024-10-20T00:30:04.501Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/31/1513d5a6412b98052c3ed9158d783b1e09d0910f51fbe0e05f56cc370bc4/asyncpg-0.30.0-cp313-cp313-win32.whl", hash = "sha256:ae374585f51c2b444510cdf3595b97ece4f233fde739aa14b50e0d64e8a7a590", size = 560404, upload-time = "2024-10-20T00:30:06.537Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/a4/cec76b3389c4c5ff66301cd100fe88c318563ec8a520e0b2e792b5b84972/asyncpg-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:f59b430b8e27557c3fb9869222559f7417ced18688375825f8f12302c34e915e", size = 621623, upload-time = "2024-10-20T00:30:09.024Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/64/9d3e887bb7b01535fdbc45fbd5f0a8447539833b97ee69ecdbb7a79d0cb4/asyncpg-0.30.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c902a60b52e506d38d7e80e0dd5399f657220f24635fee368117b8b5fce1142e", size = 673162 },
+    { url = "https://files.pythonhosted.org/packages/6e/eb/8b236663f06984f212a087b3e849731f917ab80f84450e943900e8ca4052/asyncpg-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aca1548e43bbb9f0f627a04666fedaca23db0a31a84136ad1f868cb15deb6e3a", size = 637025 },
+    { url = "https://files.pythonhosted.org/packages/cc/57/2dc240bb263d58786cfaa60920779af6e8d32da63ab9ffc09f8312bd7a14/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c2a2ef565400234a633da0eafdce27e843836256d40705d83ab7ec42074efb3", size = 3496243 },
+    { url = "https://files.pythonhosted.org/packages/f4/40/0ae9d061d278b10713ea9021ef6b703ec44698fe32178715a501ac696c6b/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1292b84ee06ac8a2ad8e51c7475aa309245874b61333d97411aab835c4a2f737", size = 3575059 },
+    { url = "https://files.pythonhosted.org/packages/c3/75/d6b895a35a2c6506952247640178e5f768eeb28b2e20299b6a6f1d743ba0/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0f5712350388d0cd0615caec629ad53c81e506b1abaaf8d14c93f54b35e3595a", size = 3473596 },
+    { url = "https://files.pythonhosted.org/packages/c8/e7/3693392d3e168ab0aebb2d361431375bd22ffc7b4a586a0fc060d519fae7/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:db9891e2d76e6f425746c5d2da01921e9a16b5a71a1c905b13f30e12a257c4af", size = 3641632 },
+    { url = "https://files.pythonhosted.org/packages/32/ea/15670cea95745bba3f0352341db55f506a820b21c619ee66b7d12ea7867d/asyncpg-0.30.0-cp312-cp312-win32.whl", hash = "sha256:68d71a1be3d83d0570049cd1654a9bdfe506e794ecc98ad0873304a9f35e411e", size = 560186 },
+    { url = "https://files.pythonhosted.org/packages/7e/6b/fe1fad5cee79ca5f5c27aed7bd95baee529c1bf8a387435c8ba4fe53d5c1/asyncpg-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:9a0292c6af5c500523949155ec17b7fe01a00ace33b68a476d6b5059f9630305", size = 621064 },
+    { url = "https://files.pythonhosted.org/packages/3a/22/e20602e1218dc07692acf70d5b902be820168d6282e69ef0d3cb920dc36f/asyncpg-0.30.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05b185ebb8083c8568ea8a40e896d5f7af4b8554b64d7719c0eaa1eb5a5c3a70", size = 670373 },
+    { url = "https://files.pythonhosted.org/packages/3d/b3/0cf269a9d647852a95c06eb00b815d0b95a4eb4b55aa2d6ba680971733b9/asyncpg-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c47806b1a8cbb0a0db896f4cd34d89942effe353a5035c62734ab13b9f938da3", size = 634745 },
+    { url = "https://files.pythonhosted.org/packages/8e/6d/a4f31bf358ce8491d2a31bfe0d7bcf25269e80481e49de4d8616c4295a34/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b6fde867a74e8c76c71e2f64f80c64c0f3163e687f1763cfaf21633ec24ec33", size = 3512103 },
+    { url = "https://files.pythonhosted.org/packages/96/19/139227a6e67f407b9c386cb594d9628c6c78c9024f26df87c912fabd4368/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46973045b567972128a27d40001124fbc821c87a6cade040cfcd4fa8a30bcdc4", size = 3592471 },
+    { url = "https://files.pythonhosted.org/packages/67/e4/ab3ca38f628f53f0fd28d3ff20edff1c975dd1cb22482e0061916b4b9a74/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9110df111cabc2ed81aad2f35394a00cadf4f2e0635603db6ebbd0fc896f46a4", size = 3496253 },
+    { url = "https://files.pythonhosted.org/packages/ef/5f/0bf65511d4eeac3a1f41c54034a492515a707c6edbc642174ae79034d3ba/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04ff0785ae7eed6cc138e73fc67b8e51d54ee7a3ce9b63666ce55a0bf095f7ba", size = 3662720 },
+    { url = "https://files.pythonhosted.org/packages/e7/31/1513d5a6412b98052c3ed9158d783b1e09d0910f51fbe0e05f56cc370bc4/asyncpg-0.30.0-cp313-cp313-win32.whl", hash = "sha256:ae374585f51c2b444510cdf3595b97ece4f233fde739aa14b50e0d64e8a7a590", size = 560404 },
+    { url = "https://files.pythonhosted.org/packages/c8/a4/cec76b3389c4c5ff66301cd100fe88c318563ec8a520e0b2e792b5b84972/asyncpg-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:f59b430b8e27557c3fb9869222559f7417ced18688375825f8f12302c34e915e", size = 621623 },
 ]
 
 [[package]]
 name = "certifi"
 version = "2026.1.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900 },
 ]
 
 [[package]]
@@ -134,111 +134,111 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pycparser", marker = "implementation_name != 'PyPy'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },
-    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
-    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
-    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
-    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
-    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
-    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
-    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
-    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
-    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
-    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
-    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
-    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
-    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271 },
+    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048 },
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529 },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097 },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983 },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519 },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572 },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963 },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361 },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932 },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557 },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762 },
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230 },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043 },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446 },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101 },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948 },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422 },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499 },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928 },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302 },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909 },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402 },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780 },
+    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320 },
+    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487 },
+    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049 },
+    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793 },
+    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300 },
+    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244 },
+    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828 },
+    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926 },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328 },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650 },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687 },
+    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773 },
+    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013 },
+    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593 },
+    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354 },
+    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480 },
+    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584 },
+    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443 },
+    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437 },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487 },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726 },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195 },
 ]
 
 [[package]]
 name = "charset-normalizer"
 version = "3.4.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" },
-    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" },
-    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" },
-    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" },
-    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" },
-    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" },
-    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" },
-    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
-    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
-    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
-    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
-    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
-    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
-    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
-    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
-    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
-    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
-    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
-    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
-    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
-    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
-    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425 },
+    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162 },
+    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558 },
+    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497 },
+    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240 },
+    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471 },
+    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864 },
+    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647 },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110 },
+    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839 },
+    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667 },
+    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535 },
+    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816 },
+    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694 },
+    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131 },
+    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390 },
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091 },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936 },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180 },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346 },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874 },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076 },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601 },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376 },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825 },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583 },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366 },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300 },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465 },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404 },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092 },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408 },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746 },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889 },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641 },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779 },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035 },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542 },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524 },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395 },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680 },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045 },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687 },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014 },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044 },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940 },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104 },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743 },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402 },
 ]
 
 [[package]]
@@ -248,18 +248,30 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274 },
+]
+
+[[package]]
+name = "click-option-group"
+version = "0.5.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ef/ff/d291d66595b30b83d1cb9e314b2c9be7cfc7327d4a0d40a15da2416ea97b/click_option_group-0.5.9.tar.gz", hash = "sha256:f94ed2bc4cf69052e0f29592bd1e771a1789bd7bfc482dd0bc482134aff95823", size = 22222 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/45/54bb2d8d4138964a94bef6e9afe48b0be4705ba66ac442ae7d8a8dc4ffef/click_option_group-0.5.9-py3-none-any.whl", hash = "sha256:ad2599248bd373e2e19bec5407967c3eec1d0d4fc4a5e77b08a0481e75991080", size = 11553 },
 ]
 
 [[package]]
 name = "colorama"
 version = "0.4.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
 ]
 
 [[package]]
@@ -271,27 +283,48 @@ dependencies = [
     { name = "requests" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f7/c7/bd020af76301bfede41869b3c18f3efb6fac7dd064371d2a9956bc3306c4/crossrefapi-1.7.0.tar.gz", hash = "sha256:598f27a3cc1bd8d29770de284b0b1315c820de1d70894084945d5265e6fe2dae", size = 13444, upload-time = "2025-07-03T20:39:49.223Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/c7/bd020af76301bfede41869b3c18f3efb6fac7dd064371d2a9956bc3306c4/crossrefapi-1.7.0.tar.gz", hash = "sha256:598f27a3cc1bd8d29770de284b0b1315c820de1d70894084945d5265e6fe2dae", size = 13444 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ab/de/58f53b61330e74b8d1401abb448c27027fb66ca14556a120248fc3ff84b0/crossrefapi-1.7.0-py3-none-any.whl", hash = "sha256:577919e26727651a546dfb94781fc0f24b05fe0d05a62f8e49dba87c4bb7f87e", size = 14652, upload-time = "2025-07-03T20:39:48.059Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/de/58f53b61330e74b8d1401abb448c27027fb66ca14556a120248fc3ff84b0/crossrefapi-1.7.0-py3-none-any.whl", hash = "sha256:577919e26727651a546dfb94781fc0f24b05fe0d05a62f8e49dba87c4bb7f87e", size = 14652 },
 ]
 
 [[package]]
 name = "decorator"
 version = "5.2.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190 },
+]
+
+[[package]]
+name = "deprecated"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/d0/205d54408c08b13550c733c4b85429e7ead111c7f0014309637425520a9a/deprecated-1.3.1-py2.py3-none-any.whl", hash = "sha256:597bfef186b6f60181535a29fbe44865ce137a5079f295b479886c82729d5f3f", size = 11298 },
+]
+
+[[package]]
+name = "dotty-dict"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/ab/88d67f02024700b48cd8232579ad1316aa9df2272c63049c27cc094229d6/dotty_dict-1.3.1.tar.gz", hash = "sha256:4b016e03b8ae265539757a53eba24b9bfda506fb94fbce0bee843c6f05541a15", size = 7699 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1a/91/e0d457ee03ec33d79ee2cd8d212debb1bc21dfb99728ae35efdb5832dc22/dotty_dict-1.3.1-py3-none-any.whl", hash = "sha256:5022d234d9922f13aa711b4950372a06a6d64cb6d6db9ba43d0ba133ebfce31f", size = 7014 },
 ]
 
 [[package]]
 name = "executing"
 version = "2.2.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317 },
 ]
 
 [[package]]
@@ -303,57 +336,85 @@ dependencies = [
     { name = "starlette" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/01/64/1296f46d6b9e3b23fb22e5d01af3f104ef411425531376212f1eefa2794d/fastapi-0.116.2.tar.gz", hash = "sha256:231a6af2fe21cfa2c32730170ad8514985fc250bec16c9b242d3b94c835ef529", size = 298595, upload-time = "2025-09-16T18:29:23.058Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/64/1296f46d6b9e3b23fb22e5d01af3f104ef411425531376212f1eefa2794d/fastapi-0.116.2.tar.gz", hash = "sha256:231a6af2fe21cfa2c32730170ad8514985fc250bec16c9b242d3b94c835ef529", size = 298595 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/32/e4/c543271a8018874b7f682bf6156863c416e1334b8ed3e51a69495c5d4360/fastapi-0.116.2-py3-none-any.whl", hash = "sha256:c3a7a8fb830b05f7e087d920e0d786ca1fc9892eb4e9a84b227be4c1bc7569db", size = 95670, upload-time = "2025-09-16T18:29:21.329Z" },
+    { url = "https://files.pythonhosted.org/packages/32/e4/c543271a8018874b7f682bf6156863c416e1334b8ed3e51a69495c5d4360/fastapi-0.116.2-py3-none-any.whl", hash = "sha256:c3a7a8fb830b05f7e087d920e0d786ca1fc9892eb4e9a84b227be4c1bc7569db", size = 95670 },
+]
+
+[[package]]
+name = "gitdb"
+version = "4.0.12"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "smmap" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794 },
+]
+
+[[package]]
+name = "gitpython"
+version = "3.1.46"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "gitdb" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/b5/59d16470a1f0dfe8c793f9ef56fd3826093fc52b3bd96d6b9d6c26c7e27b/gitpython-3.1.46.tar.gz", hash = "sha256:400124c7d0ef4ea03f7310ac2fbf7151e09ff97f2a3288d64a440c584a29c37f", size = 215371 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/09/e21df6aef1e1ffc0c816f0522ddc3f6dcded766c3261813131c78a704470/gitpython-3.1.46-py3-none-any.whl", hash = "sha256:79812ed143d9d25b6d176a10bb511de0f9c67b1fa641d82097b0ab90398a2058", size = 208620 },
 ]
 
 [[package]]
 name = "greenlet"
 version = "3.3.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/8a/99/1cd3411c56a410994669062bd73dd58270c00cc074cac15f385a1fd91f8a/greenlet-3.3.1.tar.gz", hash = "sha256:41848f3230b58c08bb43dee542e74a2a2e34d3c59dc3076cec9151aeeedcae98", size = 184690, upload-time = "2026-01-23T15:31:02.076Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/99/1cd3411c56a410994669062bd73dd58270c00cc074cac15f385a1fd91f8a/greenlet-3.3.1.tar.gz", hash = "sha256:41848f3230b58c08bb43dee542e74a2a2e34d3c59dc3076cec9151aeeedcae98", size = 184690 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f9/c8/9d76a66421d1ae24340dfae7e79c313957f6e3195c144d2c73333b5bfe34/greenlet-3.3.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7e806ca53acf6d15a888405880766ec84721aa4181261cd11a457dfe9a7a4975", size = 276443, upload-time = "2026-01-23T15:30:10.066Z" },
-    { url = "https://files.pythonhosted.org/packages/81/99/401ff34bb3c032d1f10477d199724f5e5f6fbfb59816ad1455c79c1eb8e7/greenlet-3.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d842c94b9155f1c9b3058036c24ffb8ff78b428414a19792b2380be9cecf4f36", size = 597359, upload-time = "2026-01-23T16:00:57.394Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/bc/4dcc0871ed557792d304f50be0f7487a14e017952ec689effe2180a6ff35/greenlet-3.3.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:20fedaadd422fa02695f82093f9a98bad3dab5fcda793c658b945fcde2ab27ba", size = 607805, upload-time = "2026-01-23T16:05:28.068Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/05/821587cf19e2ce1f2b24945d890b164401e5085f9d09cbd969b0c193cd20/greenlet-3.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14194f5f4305800ff329cbf02c5fcc88f01886cadd29941b807668a45f0d2336", size = 609947, upload-time = "2026-01-23T15:32:51.004Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/52/ee8c46ed9f8babaa93a19e577f26e3d28a519feac6350ed6f25f1afee7e9/greenlet-3.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7b2fe4150a0cf59f847a67db8c155ac36aed89080a6a639e9f16df5d6c6096f1", size = 1567487, upload-time = "2026-01-23T16:04:22.125Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/7c/456a74f07029597626f3a6db71b273a3632aecb9afafeeca452cfa633197/greenlet-3.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49f4ad195d45f4a66a0eb9c1ba4832bb380570d361912fa3554746830d332149", size = 1636087, upload-time = "2026-01-23T15:33:47.486Z" },
-    { url = "https://files.pythonhosted.org/packages/34/2f/5e0e41f33c69655300a5e54aeb637cf8ff57f1786a3aba374eacc0228c1d/greenlet-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cc98b9c4e4870fa983436afa999d4eb16b12872fab7071423d5262fa7120d57a", size = 227156, upload-time = "2026-01-23T15:34:34.808Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/ab/717c58343cf02c5265b531384b248787e04d8160b8afe53d9eec053d7b44/greenlet-3.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bfb2d1763d777de5ee495c85309460f6fd8146e50ec9d0ae0183dbf6f0a829d1", size = 226403, upload-time = "2026-01-23T15:31:39.372Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/ab/d26750f2b7242c2b90ea2ad71de70cfcd73a948a49513188a0fc0d6fc15a/greenlet-3.3.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:7ab327905cabb0622adca5971e488064e35115430cec2c35a50fd36e72a315b3", size = 275205, upload-time = "2026-01-23T15:30:24.556Z" },
-    { url = "https://files.pythonhosted.org/packages/10/d3/be7d19e8fad7c5a78eeefb2d896a08cd4643e1e90c605c4be3b46264998f/greenlet-3.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65be2f026ca6a176f88fb935ee23c18333ccea97048076aef4db1ef5bc0713ac", size = 599284, upload-time = "2026-01-23T16:00:58.584Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/21/fe703aaa056fdb0f17e5afd4b5c80195bbdab701208918938bd15b00d39b/greenlet-3.3.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7a3ae05b3d225b4155bda56b072ceb09d05e974bc74be6c3fc15463cf69f33fd", size = 610274, upload-time = "2026-01-23T16:05:29.312Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/86/5c6ab23bb3c28c21ed6bebad006515cfe08b04613eb105ca0041fecca852/greenlet-3.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6423481193bbbe871313de5fd06a082f2649e7ce6e08015d2a76c1e9186ca5b3", size = 612904, upload-time = "2026-01-23T15:32:52.317Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/f3/7949994264e22639e40718c2daf6f6df5169bf48fb038c008a489ec53a50/greenlet-3.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:33a956fe78bbbda82bfc95e128d61129b32d66bcf0a20a1f0c08aa4839ffa951", size = 1567316, upload-time = "2026-01-23T16:04:23.316Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/6e/d73c94d13b6465e9f7cd6231c68abde838bb22408596c05d9059830b7872/greenlet-3.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b065d3284be43728dd280f6f9a13990b56470b81be20375a207cdc814a983f2", size = 1636549, upload-time = "2026-01-23T15:33:48.643Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/b3/c9c23a6478b3bcc91f979ce4ca50879e4d0b2bd7b9a53d8ecded719b92e2/greenlet-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:27289986f4e5b0edec7b5a91063c109f0276abb09a7e9bdab08437525977c946", size = 227042, upload-time = "2026-01-23T15:33:58.216Z" },
-    { url = "https://files.pythonhosted.org/packages/90/e7/824beda656097edee36ab15809fd063447b200cc03a7f6a24c34d520bc88/greenlet-3.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:2f080e028001c5273e0b42690eaf359aeef9cb1389da0f171ea51a5dc3c7608d", size = 226294, upload-time = "2026-01-23T15:30:52.73Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/fb/011c7c717213182caf78084a9bea51c8590b0afda98001f69d9f853a495b/greenlet-3.3.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:bd59acd8529b372775cd0fcbc5f420ae20681c5b045ce25bd453ed8455ab99b5", size = 275737, upload-time = "2026-01-23T15:32:16.889Z" },
-    { url = "https://files.pythonhosted.org/packages/41/2e/a3a417d620363fdbb08a48b1dd582956a46a61bf8fd27ee8164f9dfe87c2/greenlet-3.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b31c05dd84ef6871dd47120386aed35323c944d86c3d91a17c4b8d23df62f15b", size = 646422, upload-time = "2026-01-23T16:01:00.354Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/09/c6c4a0db47defafd2d6bab8ddfe47ad19963b4e30f5bed84d75328059f8c/greenlet-3.3.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02925a0bfffc41e542c70aa14c7eda3593e4d7e274bfcccca1827e6c0875902e", size = 658219, upload-time = "2026-01-23T16:05:30.956Z" },
-    { url = "https://files.pythonhosted.org/packages/80/38/9d42d60dffb04b45f03dbab9430898352dba277758640751dc5cc316c521/greenlet-3.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34a729e2e4e4ffe9ae2408d5ecaf12f944853f40ad724929b7585bca808a9d6f", size = 660237, upload-time = "2026-01-23T15:32:53.967Z" },
-    { url = "https://files.pythonhosted.org/packages/96/61/373c30b7197f9e756e4c81ae90a8d55dc3598c17673f91f4d31c3c689c3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aec9ab04e82918e623415947921dea15851b152b822661cce3f8e4393c3df683", size = 1615261, upload-time = "2026-01-23T16:04:25.066Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/d3/ca534310343f5945316f9451e953dcd89b36fe7a19de652a1dc5a0eeef3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71c767cf281a80d02b6c1bdc41c9468e1f5a494fb11bc8688c360524e273d7b1", size = 1683719, upload-time = "2026-01-23T15:33:50.61Z" },
-    { url = "https://files.pythonhosted.org/packages/52/cb/c21a3fd5d2c9c8b622e7bede6d6d00e00551a5ee474ea6d831b5f567a8b4/greenlet-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:96aff77af063b607f2489473484e39a0bbae730f2ea90c9e5606c9b73c44174a", size = 228125, upload-time = "2026-01-23T15:32:45.265Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/8e/8a2db6d11491837af1de64b8aff23707c6e85241be13c60ed399a72e2ef8/greenlet-3.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:b066e8b50e28b503f604fa538adc764a638b38cf8e81e025011d26e8a627fa79", size = 227519, upload-time = "2026-01-23T15:31:47.284Z" },
-    { url = "https://files.pythonhosted.org/packages/28/24/cbbec49bacdcc9ec652a81d3efef7b59f326697e7edf6ed775a5e08e54c2/greenlet-3.3.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:3e63252943c921b90abb035ebe9de832c436401d9c45f262d80e2d06cc659242", size = 282706, upload-time = "2026-01-23T15:33:05.525Z" },
-    { url = "https://files.pythonhosted.org/packages/86/2e/4f2b9323c144c4fe8842a4e0d92121465485c3c2c5b9e9b30a52e80f523f/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76e39058e68eb125de10c92524573924e827927df5d3891fbc97bd55764a8774", size = 651209, upload-time = "2026-01-23T16:01:01.517Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/87/50ca60e515f5bb55a2fbc5f0c9b5b156de7d2fc51a0a69abc9d23914a237/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9f9d5e7a9310b7a2f416dd13d2e3fd8b42d803968ea580b7c0f322ccb389b97", size = 654300, upload-time = "2026-01-23T16:05:32.199Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/94/74310866dfa2b73dd08659a3d18762f83985ad3281901ba0ee9a815194fb/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92497c78adf3ac703b57f1e3813c2d874f27f71a178f9ea5887855da413cd6d2", size = 653842, upload-time = "2026-01-23T15:32:55.671Z" },
-    { url = "https://files.pythonhosted.org/packages/97/43/8bf0ffa3d498eeee4c58c212a3905dd6146c01c8dc0b0a046481ca29b18c/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ed6b402bc74d6557a705e197d47f9063733091ed6357b3de33619d8a8d93ac53", size = 1614917, upload-time = "2026-01-23T16:04:26.276Z" },
-    { url = "https://files.pythonhosted.org/packages/89/90/a3be7a5f378fc6e84abe4dcfb2ba32b07786861172e502388b4c90000d1b/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:59913f1e5ada20fde795ba906916aea25d442abcc0593fba7e26c92b7ad76249", size = 1676092, upload-time = "2026-01-23T15:33:52.176Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/2b/98c7f93e6db9977aaee07eb1e51ca63bd5f779b900d362791d3252e60558/greenlet-3.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:301860987846c24cb8964bdec0e31a96ad4a2a801b41b4ef40963c1b44f33451", size = 233181, upload-time = "2026-01-23T15:33:00.29Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c8/9d76a66421d1ae24340dfae7e79c313957f6e3195c144d2c73333b5bfe34/greenlet-3.3.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7e806ca53acf6d15a888405880766ec84721aa4181261cd11a457dfe9a7a4975", size = 276443 },
+    { url = "https://files.pythonhosted.org/packages/81/99/401ff34bb3c032d1f10477d199724f5e5f6fbfb59816ad1455c79c1eb8e7/greenlet-3.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d842c94b9155f1c9b3058036c24ffb8ff78b428414a19792b2380be9cecf4f36", size = 597359 },
+    { url = "https://files.pythonhosted.org/packages/2b/bc/4dcc0871ed557792d304f50be0f7487a14e017952ec689effe2180a6ff35/greenlet-3.3.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:20fedaadd422fa02695f82093f9a98bad3dab5fcda793c658b945fcde2ab27ba", size = 607805 },
+    { url = "https://files.pythonhosted.org/packages/3b/cd/7a7ca57588dac3389e97f7c9521cb6641fd8b6602faf1eaa4188384757df/greenlet-3.3.1-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c620051669fd04ac6b60ebc70478210119c56e2d5d5df848baec4312e260e4ca", size = 622363 },
+    { url = "https://files.pythonhosted.org/packages/cf/05/821587cf19e2ce1f2b24945d890b164401e5085f9d09cbd969b0c193cd20/greenlet-3.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14194f5f4305800ff329cbf02c5fcc88f01886cadd29941b807668a45f0d2336", size = 609947 },
+    { url = "https://files.pythonhosted.org/packages/a4/52/ee8c46ed9f8babaa93a19e577f26e3d28a519feac6350ed6f25f1afee7e9/greenlet-3.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7b2fe4150a0cf59f847a67db8c155ac36aed89080a6a639e9f16df5d6c6096f1", size = 1567487 },
+    { url = "https://files.pythonhosted.org/packages/8f/7c/456a74f07029597626f3a6db71b273a3632aecb9afafeeca452cfa633197/greenlet-3.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49f4ad195d45f4a66a0eb9c1ba4832bb380570d361912fa3554746830d332149", size = 1636087 },
+    { url = "https://files.pythonhosted.org/packages/34/2f/5e0e41f33c69655300a5e54aeb637cf8ff57f1786a3aba374eacc0228c1d/greenlet-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cc98b9c4e4870fa983436afa999d4eb16b12872fab7071423d5262fa7120d57a", size = 227156 },
+    { url = "https://files.pythonhosted.org/packages/c8/ab/717c58343cf02c5265b531384b248787e04d8160b8afe53d9eec053d7b44/greenlet-3.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bfb2d1763d777de5ee495c85309460f6fd8146e50ec9d0ae0183dbf6f0a829d1", size = 226403 },
+    { url = "https://files.pythonhosted.org/packages/ec/ab/d26750f2b7242c2b90ea2ad71de70cfcd73a948a49513188a0fc0d6fc15a/greenlet-3.3.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:7ab327905cabb0622adca5971e488064e35115430cec2c35a50fd36e72a315b3", size = 275205 },
+    { url = "https://files.pythonhosted.org/packages/10/d3/be7d19e8fad7c5a78eeefb2d896a08cd4643e1e90c605c4be3b46264998f/greenlet-3.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65be2f026ca6a176f88fb935ee23c18333ccea97048076aef4db1ef5bc0713ac", size = 599284 },
+    { url = "https://files.pythonhosted.org/packages/ae/21/fe703aaa056fdb0f17e5afd4b5c80195bbdab701208918938bd15b00d39b/greenlet-3.3.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7a3ae05b3d225b4155bda56b072ceb09d05e974bc74be6c3fc15463cf69f33fd", size = 610274 },
+    { url = "https://files.pythonhosted.org/packages/06/00/95df0b6a935103c0452dad2203f5be8377e551b8466a29650c4c5a5af6cc/greenlet-3.3.1-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:12184c61e5d64268a160226fb4818af4df02cfead8379d7f8b99a56c3a54ff3e", size = 624375 },
+    { url = "https://files.pythonhosted.org/packages/cb/86/5c6ab23bb3c28c21ed6bebad006515cfe08b04613eb105ca0041fecca852/greenlet-3.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6423481193bbbe871313de5fd06a082f2649e7ce6e08015d2a76c1e9186ca5b3", size = 612904 },
+    { url = "https://files.pythonhosted.org/packages/c2/f3/7949994264e22639e40718c2daf6f6df5169bf48fb038c008a489ec53a50/greenlet-3.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:33a956fe78bbbda82bfc95e128d61129b32d66bcf0a20a1f0c08aa4839ffa951", size = 1567316 },
+    { url = "https://files.pythonhosted.org/packages/8d/6e/d73c94d13b6465e9f7cd6231c68abde838bb22408596c05d9059830b7872/greenlet-3.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b065d3284be43728dd280f6f9a13990b56470b81be20375a207cdc814a983f2", size = 1636549 },
+    { url = "https://files.pythonhosted.org/packages/5e/b3/c9c23a6478b3bcc91f979ce4ca50879e4d0b2bd7b9a53d8ecded719b92e2/greenlet-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:27289986f4e5b0edec7b5a91063c109f0276abb09a7e9bdab08437525977c946", size = 227042 },
+    { url = "https://files.pythonhosted.org/packages/90/e7/824beda656097edee36ab15809fd063447b200cc03a7f6a24c34d520bc88/greenlet-3.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:2f080e028001c5273e0b42690eaf359aeef9cb1389da0f171ea51a5dc3c7608d", size = 226294 },
+    { url = "https://files.pythonhosted.org/packages/ae/fb/011c7c717213182caf78084a9bea51c8590b0afda98001f69d9f853a495b/greenlet-3.3.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:bd59acd8529b372775cd0fcbc5f420ae20681c5b045ce25bd453ed8455ab99b5", size = 275737 },
+    { url = "https://files.pythonhosted.org/packages/41/2e/a3a417d620363fdbb08a48b1dd582956a46a61bf8fd27ee8164f9dfe87c2/greenlet-3.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b31c05dd84ef6871dd47120386aed35323c944d86c3d91a17c4b8d23df62f15b", size = 646422 },
+    { url = "https://files.pythonhosted.org/packages/b4/09/c6c4a0db47defafd2d6bab8ddfe47ad19963b4e30f5bed84d75328059f8c/greenlet-3.3.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02925a0bfffc41e542c70aa14c7eda3593e4d7e274bfcccca1827e6c0875902e", size = 658219 },
+    { url = "https://files.pythonhosted.org/packages/e2/89/b95f2ddcc5f3c2bc09c8ee8d77be312df7f9e7175703ab780f2014a0e781/greenlet-3.3.1-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3e0f3878ca3a3ff63ab4ea478585942b53df66ddde327b59ecb191b19dbbd62d", size = 671455 },
+    { url = "https://files.pythonhosted.org/packages/80/38/9d42d60dffb04b45f03dbab9430898352dba277758640751dc5cc316c521/greenlet-3.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34a729e2e4e4ffe9ae2408d5ecaf12f944853f40ad724929b7585bca808a9d6f", size = 660237 },
+    { url = "https://files.pythonhosted.org/packages/96/61/373c30b7197f9e756e4c81ae90a8d55dc3598c17673f91f4d31c3c689c3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aec9ab04e82918e623415947921dea15851b152b822661cce3f8e4393c3df683", size = 1615261 },
+    { url = "https://files.pythonhosted.org/packages/fd/d3/ca534310343f5945316f9451e953dcd89b36fe7a19de652a1dc5a0eeef3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71c767cf281a80d02b6c1bdc41c9468e1f5a494fb11bc8688c360524e273d7b1", size = 1683719 },
+    { url = "https://files.pythonhosted.org/packages/52/cb/c21a3fd5d2c9c8b622e7bede6d6d00e00551a5ee474ea6d831b5f567a8b4/greenlet-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:96aff77af063b607f2489473484e39a0bbae730f2ea90c9e5606c9b73c44174a", size = 228125 },
+    { url = "https://files.pythonhosted.org/packages/6a/8e/8a2db6d11491837af1de64b8aff23707c6e85241be13c60ed399a72e2ef8/greenlet-3.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:b066e8b50e28b503f604fa538adc764a638b38cf8e81e025011d26e8a627fa79", size = 227519 },
+    { url = "https://files.pythonhosted.org/packages/28/24/cbbec49bacdcc9ec652a81d3efef7b59f326697e7edf6ed775a5e08e54c2/greenlet-3.3.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:3e63252943c921b90abb035ebe9de832c436401d9c45f262d80e2d06cc659242", size = 282706 },
+    { url = "https://files.pythonhosted.org/packages/86/2e/4f2b9323c144c4fe8842a4e0d92121465485c3c2c5b9e9b30a52e80f523f/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76e39058e68eb125de10c92524573924e827927df5d3891fbc97bd55764a8774", size = 651209 },
+    { url = "https://files.pythonhosted.org/packages/d9/87/50ca60e515f5bb55a2fbc5f0c9b5b156de7d2fc51a0a69abc9d23914a237/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9f9d5e7a9310b7a2f416dd13d2e3fd8b42d803968ea580b7c0f322ccb389b97", size = 654300 },
+    { url = "https://files.pythonhosted.org/packages/7c/25/c51a63f3f463171e09cb586eb64db0861eb06667ab01a7968371a24c4f3b/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b9721549a95db96689458a1e0ae32412ca18776ed004463df3a9299c1b257ab", size = 662574 },
+    { url = "https://files.pythonhosted.org/packages/1d/94/74310866dfa2b73dd08659a3d18762f83985ad3281901ba0ee9a815194fb/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92497c78adf3ac703b57f1e3813c2d874f27f71a178f9ea5887855da413cd6d2", size = 653842 },
+    { url = "https://files.pythonhosted.org/packages/97/43/8bf0ffa3d498eeee4c58c212a3905dd6146c01c8dc0b0a046481ca29b18c/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ed6b402bc74d6557a705e197d47f9063733091ed6357b3de33619d8a8d93ac53", size = 1614917 },
+    { url = "https://files.pythonhosted.org/packages/89/90/a3be7a5f378fc6e84abe4dcfb2ba32b07786861172e502388b4c90000d1b/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:59913f1e5ada20fde795ba906916aea25d442abcc0593fba7e26c92b7ad76249", size = 1676092 },
+    { url = "https://files.pythonhosted.org/packages/e1/2b/98c7f93e6db9977aaee07eb1e51ca63bd5f779b900d362791d3252e60558/greenlet-3.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:301860987846c24cb8964bdec0e31a96ad4a2a801b41b4ef40963c1b44f33451", size = 233181 },
 ]
 
 [[package]]
 name = "h11"
 version = "0.16.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515 },
 ]
 
 [[package]]
@@ -364,38 +425,38 @@ dependencies = [
     { name = "certifi" },
     { name = "h11" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784 },
 ]
 
 [[package]]
 name = "httptools"
 version = "0.7.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/53/7f/403e5d787dc4942316e515e949b0c8a013d84078a915910e9f391ba9b3ed/httptools-0.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:38e0c83a2ea9746ebbd643bdfb521b9aa4a91703e2cd705c20443405d2fd16a5", size = 206280, upload-time = "2025-10-10T03:54:39.274Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/0d/7f3fd28e2ce311ccc998c388dd1c53b18120fda3b70ebb022b135dc9839b/httptools-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f25bbaf1235e27704f1a7b86cd3304eabc04f569c828101d94a0e605ef7205a5", size = 110004, upload-time = "2025-10-10T03:54:40.403Z" },
-    { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655, upload-time = "2025-10-10T03:54:41.347Z" },
-    { url = "https://files.pythonhosted.org/packages/11/7d/71fee6f1844e6fa378f2eddde6c3e41ce3a1fb4b2d81118dd544e3441ec0/httptools-0.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7fe6e96090df46b36ccfaf746f03034e5ab723162bc51b0a4cf58305324036f2", size = 511440, upload-time = "2025-10-10T03:54:42.452Z" },
-    { url = "https://files.pythonhosted.org/packages/22/a5/079d216712a4f3ffa24af4a0381b108aa9c45b7a5cc6eb141f81726b1823/httptools-0.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f72fdbae2dbc6e68b8239defb48e6a5937b12218e6ffc2c7846cc37befa84362", size = 495186, upload-time = "2025-10-10T03:54:43.937Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/9e/025ad7b65278745dee3bd0ebf9314934c4592560878308a6121f7f812084/httptools-0.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e99c7b90a29fd82fea9ef57943d501a16f3404d7b9ee81799d41639bdaae412c", size = 499192, upload-time = "2025-10-10T03:54:45.003Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/de/40a8f202b987d43afc4d54689600ff03ce65680ede2f31df348d7f368b8f/httptools-0.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3e14f530fefa7499334a79b0cf7e7cd2992870eb893526fb097d51b4f2d0f321", size = 86694, upload-time = "2025-10-10T03:54:45.923Z" },
-    { url = "https://files.pythonhosted.org/packages/09/8f/c77b1fcbfd262d422f12da02feb0d218fa228d52485b77b953832105bb90/httptools-0.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6babce6cfa2a99545c60bfef8bee0cc0545413cb0018f617c8059a30ad985de3", size = 202889, upload-time = "2025-10-10T03:54:47.089Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/1a/22887f53602feaa066354867bc49a68fc295c2293433177ee90870a7d517/httptools-0.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:601b7628de7504077dd3dcb3791c6b8694bbd967148a6d1f01806509254fb1ca", size = 108180, upload-time = "2025-10-10T03:54:48.052Z" },
-    { url = "https://files.pythonhosted.org/packages/32/6a/6aaa91937f0010d288d3d124ca2946d48d60c3a5ee7ca62afe870e3ea011/httptools-0.7.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:04c6c0e6c5fb0739c5b8a9eb046d298650a0ff38cf42537fc372b28dc7e4472c", size = 478596, upload-time = "2025-10-10T03:54:48.919Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/70/023d7ce117993107be88d2cbca566a7c1323ccbaf0af7eabf2064fe356f6/httptools-0.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69d4f9705c405ae3ee83d6a12283dc9feba8cc6aaec671b412917e644ab4fa66", size = 473268, upload-time = "2025-10-10T03:54:49.993Z" },
-    { url = "https://files.pythonhosted.org/packages/32/4d/9dd616c38da088e3f436e9a616e1d0cc66544b8cdac405cc4e81c8679fc7/httptools-0.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:44c8f4347d4b31269c8a9205d8a5ee2df5322b09bbbd30f8f862185bb6b05346", size = 455517, upload-time = "2025-10-10T03:54:51.066Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/3a/a6c595c310b7df958e739aae88724e24f9246a514d909547778d776799be/httptools-0.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:465275d76db4d554918aba40bf1cbebe324670f3dfc979eaffaa5d108e2ed650", size = 458337, upload-time = "2025-10-10T03:54:52.196Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/82/88e8d6d2c51edc1cc391b6e044c6c435b6aebe97b1abc33db1b0b24cd582/httptools-0.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:322d00c2068d125bd570f7bf78b2d367dad02b919d8581d7476d8b75b294e3e6", size = 85743, upload-time = "2025-10-10T03:54:53.448Z" },
-    { url = "https://files.pythonhosted.org/packages/34/50/9d095fcbb6de2d523e027a2f304d4551855c2f46e0b82befd718b8b20056/httptools-0.7.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:c08fe65728b8d70b6923ce31e3956f859d5e1e8548e6f22ec520a962c6757270", size = 203619, upload-time = "2025-10-10T03:54:54.321Z" },
-    { url = "https://files.pythonhosted.org/packages/07/f0/89720dc5139ae54b03f861b5e2c55a37dba9a5da7d51e1e824a1f343627f/httptools-0.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7aea2e3c3953521c3c51106ee11487a910d45586e351202474d45472db7d72d3", size = 108714, upload-time = "2025-10-10T03:54:55.163Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/cb/eea88506f191fb552c11787c23f9a405f4c7b0c5799bf73f2249cd4f5228/httptools-0.7.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0e68b8582f4ea9166be62926077a3334064d422cf08ab87d8b74664f8e9058e1", size = 472909, upload-time = "2025-10-10T03:54:56.056Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/4a/a548bdfae6369c0d078bab5769f7b66f17f1bfaa6fa28f81d6be6959066b/httptools-0.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df091cf961a3be783d6aebae963cc9b71e00d57fa6f149025075217bc6a55a7b", size = 470831, upload-time = "2025-10-10T03:54:57.219Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/31/14df99e1c43bd132eec921c2e7e11cda7852f65619bc0fc5bdc2d0cb126c/httptools-0.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f084813239e1eb403ddacd06a30de3d3e09a9b76e7894dcda2b22f8a726e9c60", size = 452631, upload-time = "2025-10-10T03:54:58.219Z" },
-    { url = "https://files.pythonhosted.org/packages/22/d2/b7e131f7be8d854d48cb6d048113c30f9a46dca0c9a8b08fcb3fcd588cdc/httptools-0.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7347714368fb2b335e9063bc2b96f2f87a9ceffcd9758ac295f8bbcd3ffbc0ca", size = 452910, upload-time = "2025-10-10T03:54:59.366Z" },
-    { url = "https://files.pythonhosted.org/packages/53/cf/878f3b91e4e6e011eff6d1fa9ca39f7eb17d19c9d7971b04873734112f30/httptools-0.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:cfabda2a5bb85aa2a904ce06d974a3f30fb36cc63d7feaddec05d2050acede96", size = 88205, upload-time = "2025-10-10T03:55:00.389Z" },
+    { url = "https://files.pythonhosted.org/packages/53/7f/403e5d787dc4942316e515e949b0c8a013d84078a915910e9f391ba9b3ed/httptools-0.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:38e0c83a2ea9746ebbd643bdfb521b9aa4a91703e2cd705c20443405d2fd16a5", size = 206280 },
+    { url = "https://files.pythonhosted.org/packages/2a/0d/7f3fd28e2ce311ccc998c388dd1c53b18120fda3b70ebb022b135dc9839b/httptools-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f25bbaf1235e27704f1a7b86cd3304eabc04f569c828101d94a0e605ef7205a5", size = 110004 },
+    { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655 },
+    { url = "https://files.pythonhosted.org/packages/11/7d/71fee6f1844e6fa378f2eddde6c3e41ce3a1fb4b2d81118dd544e3441ec0/httptools-0.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7fe6e96090df46b36ccfaf746f03034e5ab723162bc51b0a4cf58305324036f2", size = 511440 },
+    { url = "https://files.pythonhosted.org/packages/22/a5/079d216712a4f3ffa24af4a0381b108aa9c45b7a5cc6eb141f81726b1823/httptools-0.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f72fdbae2dbc6e68b8239defb48e6a5937b12218e6ffc2c7846cc37befa84362", size = 495186 },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/025ad7b65278745dee3bd0ebf9314934c4592560878308a6121f7f812084/httptools-0.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e99c7b90a29fd82fea9ef57943d501a16f3404d7b9ee81799d41639bdaae412c", size = 499192 },
+    { url = "https://files.pythonhosted.org/packages/6d/de/40a8f202b987d43afc4d54689600ff03ce65680ede2f31df348d7f368b8f/httptools-0.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3e14f530fefa7499334a79b0cf7e7cd2992870eb893526fb097d51b4f2d0f321", size = 86694 },
+    { url = "https://files.pythonhosted.org/packages/09/8f/c77b1fcbfd262d422f12da02feb0d218fa228d52485b77b953832105bb90/httptools-0.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6babce6cfa2a99545c60bfef8bee0cc0545413cb0018f617c8059a30ad985de3", size = 202889 },
+    { url = "https://files.pythonhosted.org/packages/0a/1a/22887f53602feaa066354867bc49a68fc295c2293433177ee90870a7d517/httptools-0.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:601b7628de7504077dd3dcb3791c6b8694bbd967148a6d1f01806509254fb1ca", size = 108180 },
+    { url = "https://files.pythonhosted.org/packages/32/6a/6aaa91937f0010d288d3d124ca2946d48d60c3a5ee7ca62afe870e3ea011/httptools-0.7.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:04c6c0e6c5fb0739c5b8a9eb046d298650a0ff38cf42537fc372b28dc7e4472c", size = 478596 },
+    { url = "https://files.pythonhosted.org/packages/6d/70/023d7ce117993107be88d2cbca566a7c1323ccbaf0af7eabf2064fe356f6/httptools-0.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69d4f9705c405ae3ee83d6a12283dc9feba8cc6aaec671b412917e644ab4fa66", size = 473268 },
+    { url = "https://files.pythonhosted.org/packages/32/4d/9dd616c38da088e3f436e9a616e1d0cc66544b8cdac405cc4e81c8679fc7/httptools-0.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:44c8f4347d4b31269c8a9205d8a5ee2df5322b09bbbd30f8f862185bb6b05346", size = 455517 },
+    { url = "https://files.pythonhosted.org/packages/1d/3a/a6c595c310b7df958e739aae88724e24f9246a514d909547778d776799be/httptools-0.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:465275d76db4d554918aba40bf1cbebe324670f3dfc979eaffaa5d108e2ed650", size = 458337 },
+    { url = "https://files.pythonhosted.org/packages/fd/82/88e8d6d2c51edc1cc391b6e044c6c435b6aebe97b1abc33db1b0b24cd582/httptools-0.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:322d00c2068d125bd570f7bf78b2d367dad02b919d8581d7476d8b75b294e3e6", size = 85743 },
+    { url = "https://files.pythonhosted.org/packages/34/50/9d095fcbb6de2d523e027a2f304d4551855c2f46e0b82befd718b8b20056/httptools-0.7.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:c08fe65728b8d70b6923ce31e3956f859d5e1e8548e6f22ec520a962c6757270", size = 203619 },
+    { url = "https://files.pythonhosted.org/packages/07/f0/89720dc5139ae54b03f861b5e2c55a37dba9a5da7d51e1e824a1f343627f/httptools-0.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7aea2e3c3953521c3c51106ee11487a910d45586e351202474d45472db7d72d3", size = 108714 },
+    { url = "https://files.pythonhosted.org/packages/b3/cb/eea88506f191fb552c11787c23f9a405f4c7b0c5799bf73f2249cd4f5228/httptools-0.7.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0e68b8582f4ea9166be62926077a3334064d422cf08ab87d8b74664f8e9058e1", size = 472909 },
+    { url = "https://files.pythonhosted.org/packages/e0/4a/a548bdfae6369c0d078bab5769f7b66f17f1bfaa6fa28f81d6be6959066b/httptools-0.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df091cf961a3be783d6aebae963cc9b71e00d57fa6f149025075217bc6a55a7b", size = 470831 },
+    { url = "https://files.pythonhosted.org/packages/4d/31/14df99e1c43bd132eec921c2e7e11cda7852f65619bc0fc5bdc2d0cb126c/httptools-0.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f084813239e1eb403ddacd06a30de3d3e09a9b76e7894dcda2b22f8a726e9c60", size = 452631 },
+    { url = "https://files.pythonhosted.org/packages/22/d2/b7e131f7be8d854d48cb6d048113c30f9a46dca0c9a8b08fcb3fcd588cdc/httptools-0.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7347714368fb2b335e9063bc2b96f2f87a9ceffcd9758ac295f8bbcd3ffbc0ca", size = 452910 },
+    { url = "https://files.pythonhosted.org/packages/53/cf/878f3b91e4e6e011eff6d1fa9ca39f7eb17d19c9d7971b04873734112f30/httptools-0.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:cfabda2a5bb85aa2a904ce06d974a3f30fb36cc63d7feaddec05d2050acede96", size = 88205 },
 ]
 
 [[package]]
@@ -408,27 +469,36 @@ dependencies = [
     { name = "httpcore" },
     { name = "idna" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 },
 ]
 
 [[package]]
 name = "idna"
 version = "3.11"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008 },
+]
+
+[[package]]
+name = "importlib-resources"
+version = "6.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/8c/f834fbf984f691b4f7ff60f50b514cc3de5cc08abfc3295564dd89c5e2e7/importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c", size = 44693 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/ed/1f1afb2e9e7f38a545d628f864d562a5ae64fe6f7a10e28ffb9b185b4e89/importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec", size = 37461 },
 ]
 
 [[package]]
 name = "iniconfig"
 version = "2.3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484 },
 ]
 
 [[package]]
@@ -446,18 +516,18 @@ dependencies = [
     { name = "stack-data" },
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e5/61/1810830e8b93c72dcd3c0f150c80a00c3deb229562d9423807ec92c3a539/ipython-8.38.0.tar.gz", hash = "sha256:9cfea8c903ce0867cc2f23199ed8545eb741f3a69420bfcf3743ad1cec856d39", size = 5513996, upload-time = "2026-01-05T10:59:06.901Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e5/61/1810830e8b93c72dcd3c0f150c80a00c3deb229562d9423807ec92c3a539/ipython-8.38.0.tar.gz", hash = "sha256:9cfea8c903ce0867cc2f23199ed8545eb741f3a69420bfcf3743ad1cec856d39", size = 5513996 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9f/df/db59624f4c71b39717c423409950ac3f2c8b2ce4b0aac843112c7fb3f721/ipython-8.38.0-py3-none-any.whl", hash = "sha256:750162629d800ac65bb3b543a14e7a74b0e88063eac9b92124d4b2aa3f6d8e86", size = 831813, upload-time = "2026-01-05T10:59:04.239Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/df/db59624f4c71b39717c423409950ac3f2c8b2ce4b0aac843112c7fb3f721/ipython-8.38.0-py3-none-any.whl", hash = "sha256:750162629d800ac65bb3b543a14e7a74b0e88063eac9b92124d4b2aa3f6d8e86", size = 831813 },
 ]
 
 [[package]]
 name = "itsdangerous"
 version = "2.2.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9c/cb/8ac0172223afbccb63986cc25049b154ecfb5e85932587206f42317be31d/itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173", size = 54410, upload-time = "2024-04-16T21:28:15.614Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9c/cb/8ac0172223afbccb63986cc25049b154ecfb5e85932587206f42317be31d/itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173", size = 54410 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234, upload-time = "2024-04-16T21:28:14.499Z" },
+    { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234 },
 ]
 
 [[package]]
@@ -467,69 +537,81 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "parso" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278 },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899 },
 ]
 
 [[package]]
 name = "librt"
 version = "0.8.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/56/9c/b4b0c54d84da4a94b37bd44151e46d5e583c9534c7e02250b961b1b6d8a8/librt-0.8.1.tar.gz", hash = "sha256:be46a14693955b3bd96014ccbdb8339ee8c9346fbe11c1b78901b55125f14c73", size = 177471, upload-time = "2026-02-17T16:13:06.101Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/56/9c/b4b0c54d84da4a94b37bd44151e46d5e583c9534c7e02250b961b1b6d8a8/librt-0.8.1.tar.gz", hash = "sha256:be46a14693955b3bd96014ccbdb8339ee8c9346fbe11c1b78901b55125f14c73", size = 177471 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/95/21/d39b0a87ac52fc98f621fb6f8060efb017a767ebbbac2f99fbcbc9ddc0d7/librt-0.8.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a28f2612ab566b17f3698b0da021ff9960610301607c9a5e8eaca62f5e1c350a", size = 66516, upload-time = "2026-02-17T16:11:41.604Z" },
-    { url = "https://files.pythonhosted.org/packages/69/f1/46375e71441c43e8ae335905e069f1c54febee63a146278bcee8782c84fd/librt-0.8.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:60a78b694c9aee2a0f1aaeaa7d101cf713e92e8423a941d2897f4fa37908dab9", size = 68634, upload-time = "2026-02-17T16:11:43.268Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/33/c510de7f93bf1fa19e13423a606d8189a02624a800710f6e6a0a0f0784b3/librt-0.8.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:758509ea3f1eba2a57558e7e98f4659d0ea7670bff49673b0dde18a3c7e6c0eb", size = 198941, upload-time = "2026-02-17T16:11:44.28Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/36/e725903416409a533d92398e88ce665476f275081d0d7d42f9c4951999e5/librt-0.8.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:039b9f2c506bd0ab0f8725aa5ba339c6f0cd19d3b514b50d134789809c24285d", size = 209991, upload-time = "2026-02-17T16:11:45.462Z" },
-    { url = "https://files.pythonhosted.org/packages/30/7a/8d908a152e1875c9f8eac96c97a480df425e657cdb47854b9efaa4998889/librt-0.8.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bb54f1205a3a6ab41a6fd71dfcdcbd278670d3a90ca502a30d9da583105b6f7", size = 224476, upload-time = "2026-02-17T16:11:46.542Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/b8/a22c34f2c485b8903a06f3fe3315341fe6876ef3599792344669db98fcff/librt-0.8.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:05bd41cdee35b0c59c259f870f6da532a2c5ca57db95b5f23689fcb5c9e42440", size = 217518, upload-time = "2026-02-17T16:11:47.746Z" },
-    { url = "https://files.pythonhosted.org/packages/79/6f/5c6fea00357e4f82ba44f81dbfb027921f1ab10e320d4a64e1c408d035d9/librt-0.8.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adfab487facf03f0d0857b8710cf82d0704a309d8ffc33b03d9302b4c64e91a9", size = 225116, upload-time = "2026-02-17T16:11:49.298Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/a0/95ced4e7b1267fe1e2720a111685bcddf0e781f7e9e0ce59d751c44dcfe5/librt-0.8.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:153188fe98a72f206042be10a2c6026139852805215ed9539186312d50a8e972", size = 217751, upload-time = "2026-02-17T16:11:50.49Z" },
-    { url = "https://files.pythonhosted.org/packages/93/c2/0517281cb4d4101c27ab59472924e67f55e375bc46bedae94ac6dc6e1902/librt-0.8.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:dd3c41254ee98604b08bd5b3af5bf0a89740d4ee0711de95b65166bf44091921", size = 218378, upload-time = "2026-02-17T16:11:51.783Z" },
-    { url = "https://files.pythonhosted.org/packages/43/e8/37b3ac108e8976888e559a7b227d0ceac03c384cfd3e7a1c2ee248dbae79/librt-0.8.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e0d138c7ae532908cbb342162b2611dbd4d90c941cd25ab82084aaf71d2c0bd0", size = 241199, upload-time = "2026-02-17T16:11:53.561Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/5b/35812d041c53967fedf551a39399271bbe4257e681236a2cf1a69c8e7fa1/librt-0.8.1-cp312-cp312-win32.whl", hash = "sha256:43353b943613c5d9c49a25aaffdba46f888ec354e71e3529a00cca3f04d66a7a", size = 54917, upload-time = "2026-02-17T16:11:54.758Z" },
-    { url = "https://files.pythonhosted.org/packages/de/d1/fa5d5331b862b9775aaf2a100f5ef86854e5d4407f71bddf102f4421e034/librt-0.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:ff8baf1f8d3f4b6b7257fcb75a501f2a5499d0dda57645baa09d4d0d34b19444", size = 62017, upload-time = "2026-02-17T16:11:55.748Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/7c/c614252f9acda59b01a66e2ddfd243ed1c7e1deab0293332dfbccf862808/librt-0.8.1-cp312-cp312-win_arm64.whl", hash = "sha256:0f2ae3725904f7377e11cc37722d5d401e8b3d5851fb9273d7f4fe04f6b3d37d", size = 52441, upload-time = "2026-02-17T16:11:56.801Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/3c/f614c8e4eaac7cbf2bbdf9528790b21d89e277ee20d57dc6e559c626105f/librt-0.8.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e6bad1cd94f6764e1e21950542f818a09316645337fd5ab9a7acc45d99a8f35", size = 66529, upload-time = "2026-02-17T16:11:57.809Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/96/5836544a45100ae411eda07d29e3d99448e5258b6e9c8059deb92945f5c2/librt-0.8.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cf450f498c30af55551ba4f66b9123b7185362ec8b625a773b3d39aa1a717583", size = 68669, upload-time = "2026-02-17T16:11:58.843Z" },
-    { url = "https://files.pythonhosted.org/packages/06/53/f0b992b57af6d5531bf4677d75c44f095f2366a1741fb695ee462ae04b05/librt-0.8.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:eca45e982fa074090057132e30585a7e8674e9e885d402eae85633e9f449ce6c", size = 199279, upload-time = "2026-02-17T16:11:59.862Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/ad/4848cc16e268d14280d8168aee4f31cea92bbd2b79ce33d3e166f2b4e4fc/librt-0.8.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c3811485fccfda840861905b8c70bba5ec094e02825598bb9d4ca3936857a04", size = 210288, upload-time = "2026-02-17T16:12:00.954Z" },
-    { url = "https://files.pythonhosted.org/packages/52/05/27fdc2e95de26273d83b96742d8d3b7345f2ea2bdbd2405cc504644f2096/librt-0.8.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e4af413908f77294605e28cfd98063f54b2c790561383971d2f52d113d9c363", size = 224809, upload-time = "2026-02-17T16:12:02.108Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/d0/78200a45ba3240cb042bc597d6f2accba9193a2c57d0356268cbbe2d0925/librt-0.8.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5212a5bd7fae98dae95710032902edcd2ec4dc994e883294f75c857b83f9aba0", size = 218075, upload-time = "2026-02-17T16:12:03.631Z" },
-    { url = "https://files.pythonhosted.org/packages/af/72/a210839fa74c90474897124c064ffca07f8d4b347b6574d309686aae7ca6/librt-0.8.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e692aa2d1d604e6ca12d35e51fdc36f4cda6345e28e36374579f7ef3611b3012", size = 225486, upload-time = "2026-02-17T16:12:04.725Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/c1/a03cc63722339ddbf087485f253493e2b013039f5b707e8e6016141130fa/librt-0.8.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4be2a5c926b9770c9e08e717f05737a269b9d0ebc5d2f0060f0fe3fe9ce47acb", size = 218219, upload-time = "2026-02-17T16:12:05.828Z" },
-    { url = "https://files.pythonhosted.org/packages/58/f5/fff6108af0acf941c6f274a946aea0e484bd10cd2dc37610287ce49388c5/librt-0.8.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fd1a720332ea335ceb544cf0a03f81df92abd4bb887679fd1e460976b0e6214b", size = 218750, upload-time = "2026-02-17T16:12:07.09Z" },
-    { url = "https://files.pythonhosted.org/packages/71/67/5a387bfef30ec1e4b4f30562c8586566faf87e47d696768c19feb49e3646/librt-0.8.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2af9e01e0ef80d95ae3c720be101227edae5f2fe7e3dc63d8857fadfc5a1d", size = 241624, upload-time = "2026-02-17T16:12:08.43Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/be/24f8502db11d405232ac1162eb98069ca49c3306c1d75c6ccc61d9af8789/librt-0.8.1-cp313-cp313-win32.whl", hash = "sha256:086a32dbb71336627e78cc1d6ee305a68d038ef7d4c39aaff41ae8c9aa46e91a", size = 54969, upload-time = "2026-02-17T16:12:09.633Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/73/c9fdf6cb2a529c1a092ce769a12d88c8cca991194dfe641b6af12fa964d2/librt-0.8.1-cp313-cp313-win_amd64.whl", hash = "sha256:e11769a1dbda4da7b00a76cfffa67aa47cfa66921d2724539eee4b9ede780b79", size = 62000, upload-time = "2026-02-17T16:12:10.632Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/97/68f80ca3ac4924f250cdfa6e20142a803e5e50fca96ef5148c52ee8c10ea/librt-0.8.1-cp313-cp313-win_arm64.whl", hash = "sha256:924817ab3141aca17893386ee13261f1d100d1ef410d70afe4389f2359fea4f0", size = 52495, upload-time = "2026-02-17T16:12:11.633Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/6a/907ef6800f7bca71b525a05f1839b21f708c09043b1c6aa77b6b827b3996/librt-0.8.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6cfa7fe54fd4d1f47130017351a959fe5804bda7a0bc7e07a2cdbc3fdd28d34f", size = 66081, upload-time = "2026-02-17T16:12:12.766Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/18/25e991cd5640c9fb0f8d91b18797b29066b792f17bf8493da183bf5caabe/librt-0.8.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:228c2409c079f8c11fb2e5d7b277077f694cb93443eb760e00b3b83cb8b3176c", size = 68309, upload-time = "2026-02-17T16:12:13.756Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/36/46820d03f058cfb5a9de5940640ba03165ed8aded69e0733c417bb04df34/librt-0.8.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7aae78ab5e3206181780e56912d1b9bb9f90a7249ce12f0e8bf531d0462dd0fc", size = 196804, upload-time = "2026-02-17T16:12:14.818Z" },
-    { url = "https://files.pythonhosted.org/packages/59/18/5dd0d3b87b8ff9c061849fbdb347758d1f724b9a82241aa908e0ec54ccd0/librt-0.8.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:172d57ec04346b047ca6af181e1ea4858086c80bdf455f61994c4aa6fc3f866c", size = 206907, upload-time = "2026-02-17T16:12:16.513Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/96/ef04902aad1424fd7299b62d1890e803e6ab4018c3044dca5922319c4b97/librt-0.8.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b1977c4ea97ce5eb7755a78fae68d87e4102e4aaf54985e8b56806849cc06a3", size = 221217, upload-time = "2026-02-17T16:12:17.906Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/ff/7e01f2dda84a8f5d280637a2e5827210a8acca9a567a54507ef1c75b342d/librt-0.8.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:10c42e1f6fd06733ef65ae7bebce2872bcafd8d6e6b0a08fe0a05a23b044fb14", size = 214622, upload-time = "2026-02-17T16:12:19.108Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/8c/5b093d08a13946034fed57619742f790faf77058558b14ca36a6e331161e/librt-0.8.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4c8dfa264b9193c4ee19113c985c95f876fae5e51f731494fc4e0cf594990ba7", size = 221987, upload-time = "2026-02-17T16:12:20.331Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/cc/86b0b3b151d40920ad45a94ce0171dec1aebba8a9d72bb3fa00c73ab25dd/librt-0.8.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:01170b6729a438f0dedc4a26ed342e3dc4f02d1000b4b19f980e1877f0c297e6", size = 215132, upload-time = "2026-02-17T16:12:21.54Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/be/8588164a46edf1e69858d952654e216a9a91174688eeefb9efbb38a9c799/librt-0.8.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:7b02679a0d783bdae30d443025b94465d8c3dc512f32f5b5031f93f57ac32071", size = 215195, upload-time = "2026-02-17T16:12:23.073Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/f2/0b9279bea735c734d69344ecfe056c1ba211694a72df10f568745c899c76/librt-0.8.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:190b109bb69592a3401fe1ffdea41a2e73370ace2ffdc4a0e8e2b39cdea81b78", size = 237946, upload-time = "2026-02-17T16:12:24.275Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/cc/5f2a34fbc8aeb35314a3641f9956fa9051a947424652fad9882be7a97949/librt-0.8.1-cp314-cp314-win32.whl", hash = "sha256:e70a57ecf89a0f64c24e37f38d3fe217a58169d2fe6ed6d70554964042474023", size = 50689, upload-time = "2026-02-17T16:12:25.766Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/76/cd4d010ab2147339ca2b93e959c3686e964edc6de66ddacc935c325883d7/librt-0.8.1-cp314-cp314-win_amd64.whl", hash = "sha256:7e2f3edca35664499fbb36e4770650c4bd4a08abc1f4458eab9df4ec56389730", size = 57875, upload-time = "2026-02-17T16:12:27.465Z" },
-    { url = "https://files.pythonhosted.org/packages/84/0f/2143cb3c3ca48bd3379dcd11817163ca50781927c4537345d608b5045998/librt-0.8.1-cp314-cp314-win_arm64.whl", hash = "sha256:0d2f82168e55ddefd27c01c654ce52379c0750ddc31ee86b4b266bcf4d65f2a3", size = 48058, upload-time = "2026-02-17T16:12:28.556Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/0e/9b23a87e37baf00311c3efe6b48d6b6c168c29902dfc3f04c338372fd7db/librt-0.8.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c74a2da57a094bd48d03fa5d196da83d2815678385d2978657499063709abe1", size = 68313, upload-time = "2026-02-17T16:12:29.659Z" },
-    { url = "https://files.pythonhosted.org/packages/db/9a/859c41e5a4f1c84200a7d2b92f586aa27133c8243b6cac9926f6e54d01b9/librt-0.8.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a355d99c4c0d8e5b770313b8b247411ed40949ca44e33e46a4789b9293a907ee", size = 70994, upload-time = "2026-02-17T16:12:31.516Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/28/10605366ee599ed34223ac2bf66404c6fb59399f47108215d16d5ad751a8/librt-0.8.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2eb345e8b33fb748227409c9f1233d4df354d6e54091f0e8fc53acdb2ffedeb7", size = 220770, upload-time = "2026-02-17T16:12:33.294Z" },
-    { url = "https://files.pythonhosted.org/packages/af/8d/16ed8fd452dafae9c48d17a6bc1ee3e818fd40ef718d149a8eff2c9f4ea2/librt-0.8.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9be2f15e53ce4e83cc08adc29b26fb5978db62ef2a366fbdf716c8a6c8901040", size = 235409, upload-time = "2026-02-17T16:12:35.443Z" },
-    { url = "https://files.pythonhosted.org/packages/89/1b/7bdf3e49349c134b25db816e4a3db6b94a47ac69d7d46b1e682c2c4949be/librt-0.8.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:785ae29c1f5c6e7c2cde2c7c0e148147f4503da3abc5d44d482068da5322fd9e", size = 246473, upload-time = "2026-02-17T16:12:36.656Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/8a/91fab8e4fd2a24930a17188c7af5380eb27b203d72101c9cc000dbdfd95a/librt-0.8.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1d3a7da44baf692f0c6aeb5b2a09c5e6fc7a703bca9ffa337ddd2e2da53f7732", size = 238866, upload-time = "2026-02-17T16:12:37.849Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/e0/c45a098843fc7c07e18a7f8a24ca8496aecbf7bdcd54980c6ca1aaa79a8e/librt-0.8.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5fc48998000cbc39ec0d5311312dda93ecf92b39aaf184c5e817d5d440b29624", size = 250248, upload-time = "2026-02-17T16:12:39.445Z" },
-    { url = "https://files.pythonhosted.org/packages/82/30/07627de23036640c952cce0c1fe78972e77d7d2f8fd54fa5ef4554ff4a56/librt-0.8.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:e96baa6820280077a78244b2e06e416480ed859bbd8e5d641cf5742919d8beb4", size = 240629, upload-time = "2026-02-17T16:12:40.889Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/c1/55bfe1ee3542eba055616f9098eaf6eddb966efb0ca0f44eaa4aba327307/librt-0.8.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31362dbfe297b23590530007062c32c6f6176f6099646bb2c95ab1b00a57c382", size = 239615, upload-time = "2026-02-17T16:12:42.446Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/39/191d3d28abc26c9099b19852e6c99f7f6d400b82fa5a4e80291bd3803e19/librt-0.8.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cc3656283d11540ab0ea01978378e73e10002145117055e03722417aeab30994", size = 263001, upload-time = "2026-02-17T16:12:43.627Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/eb/7697f60fbe7042ab4e88f4ee6af496b7f222fffb0a4e3593ef1f29f81652/librt-0.8.1-cp314-cp314t-win32.whl", hash = "sha256:738f08021b3142c2918c03692608baed43bc51144c29e35807682f8070ee2a3a", size = 51328, upload-time = "2026-02-17T16:12:45.148Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/72/34bf2eb7a15414a23e5e70ecb9440c1d3179f393d9349338a91e2781c0fb/librt-0.8.1-cp314-cp314t-win_amd64.whl", hash = "sha256:89815a22daf9c51884fb5dbe4f1ef65ee6a146e0b6a8df05f753e2e4a9359bf4", size = 58722, upload-time = "2026-02-17T16:12:46.85Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/c8/d148e041732d631fc76036f8b30fae4e77b027a1e95b7a84bb522481a940/librt-0.8.1-cp314-cp314t-win_arm64.whl", hash = "sha256:bf512a71a23504ed08103a13c941f763db13fb11177beb3d9244c98c29fb4a61", size = 48755, upload-time = "2026-02-17T16:12:47.943Z" },
+    { url = "https://files.pythonhosted.org/packages/95/21/d39b0a87ac52fc98f621fb6f8060efb017a767ebbbac2f99fbcbc9ddc0d7/librt-0.8.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a28f2612ab566b17f3698b0da021ff9960610301607c9a5e8eaca62f5e1c350a", size = 66516 },
+    { url = "https://files.pythonhosted.org/packages/69/f1/46375e71441c43e8ae335905e069f1c54febee63a146278bcee8782c84fd/librt-0.8.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:60a78b694c9aee2a0f1aaeaa7d101cf713e92e8423a941d2897f4fa37908dab9", size = 68634 },
+    { url = "https://files.pythonhosted.org/packages/0a/33/c510de7f93bf1fa19e13423a606d8189a02624a800710f6e6a0a0f0784b3/librt-0.8.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:758509ea3f1eba2a57558e7e98f4659d0ea7670bff49673b0dde18a3c7e6c0eb", size = 198941 },
+    { url = "https://files.pythonhosted.org/packages/dd/36/e725903416409a533d92398e88ce665476f275081d0d7d42f9c4951999e5/librt-0.8.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:039b9f2c506bd0ab0f8725aa5ba339c6f0cd19d3b514b50d134789809c24285d", size = 209991 },
+    { url = "https://files.pythonhosted.org/packages/30/7a/8d908a152e1875c9f8eac96c97a480df425e657cdb47854b9efaa4998889/librt-0.8.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bb54f1205a3a6ab41a6fd71dfcdcbd278670d3a90ca502a30d9da583105b6f7", size = 224476 },
+    { url = "https://files.pythonhosted.org/packages/a8/b8/a22c34f2c485b8903a06f3fe3315341fe6876ef3599792344669db98fcff/librt-0.8.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:05bd41cdee35b0c59c259f870f6da532a2c5ca57db95b5f23689fcb5c9e42440", size = 217518 },
+    { url = "https://files.pythonhosted.org/packages/79/6f/5c6fea00357e4f82ba44f81dbfb027921f1ab10e320d4a64e1c408d035d9/librt-0.8.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adfab487facf03f0d0857b8710cf82d0704a309d8ffc33b03d9302b4c64e91a9", size = 225116 },
+    { url = "https://files.pythonhosted.org/packages/f2/a0/95ced4e7b1267fe1e2720a111685bcddf0e781f7e9e0ce59d751c44dcfe5/librt-0.8.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:153188fe98a72f206042be10a2c6026139852805215ed9539186312d50a8e972", size = 217751 },
+    { url = "https://files.pythonhosted.org/packages/93/c2/0517281cb4d4101c27ab59472924e67f55e375bc46bedae94ac6dc6e1902/librt-0.8.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:dd3c41254ee98604b08bd5b3af5bf0a89740d4ee0711de95b65166bf44091921", size = 218378 },
+    { url = "https://files.pythonhosted.org/packages/43/e8/37b3ac108e8976888e559a7b227d0ceac03c384cfd3e7a1c2ee248dbae79/librt-0.8.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e0d138c7ae532908cbb342162b2611dbd4d90c941cd25ab82084aaf71d2c0bd0", size = 241199 },
+    { url = "https://files.pythonhosted.org/packages/4b/5b/35812d041c53967fedf551a39399271bbe4257e681236a2cf1a69c8e7fa1/librt-0.8.1-cp312-cp312-win32.whl", hash = "sha256:43353b943613c5d9c49a25aaffdba46f888ec354e71e3529a00cca3f04d66a7a", size = 54917 },
+    { url = "https://files.pythonhosted.org/packages/de/d1/fa5d5331b862b9775aaf2a100f5ef86854e5d4407f71bddf102f4421e034/librt-0.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:ff8baf1f8d3f4b6b7257fcb75a501f2a5499d0dda57645baa09d4d0d34b19444", size = 62017 },
+    { url = "https://files.pythonhosted.org/packages/c7/7c/c614252f9acda59b01a66e2ddfd243ed1c7e1deab0293332dfbccf862808/librt-0.8.1-cp312-cp312-win_arm64.whl", hash = "sha256:0f2ae3725904f7377e11cc37722d5d401e8b3d5851fb9273d7f4fe04f6b3d37d", size = 52441 },
+    { url = "https://files.pythonhosted.org/packages/c5/3c/f614c8e4eaac7cbf2bbdf9528790b21d89e277ee20d57dc6e559c626105f/librt-0.8.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e6bad1cd94f6764e1e21950542f818a09316645337fd5ab9a7acc45d99a8f35", size = 66529 },
+    { url = "https://files.pythonhosted.org/packages/ab/96/5836544a45100ae411eda07d29e3d99448e5258b6e9c8059deb92945f5c2/librt-0.8.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cf450f498c30af55551ba4f66b9123b7185362ec8b625a773b3d39aa1a717583", size = 68669 },
+    { url = "https://files.pythonhosted.org/packages/06/53/f0b992b57af6d5531bf4677d75c44f095f2366a1741fb695ee462ae04b05/librt-0.8.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:eca45e982fa074090057132e30585a7e8674e9e885d402eae85633e9f449ce6c", size = 199279 },
+    { url = "https://files.pythonhosted.org/packages/f3/ad/4848cc16e268d14280d8168aee4f31cea92bbd2b79ce33d3e166f2b4e4fc/librt-0.8.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c3811485fccfda840861905b8c70bba5ec094e02825598bb9d4ca3936857a04", size = 210288 },
+    { url = "https://files.pythonhosted.org/packages/52/05/27fdc2e95de26273d83b96742d8d3b7345f2ea2bdbd2405cc504644f2096/librt-0.8.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e4af413908f77294605e28cfd98063f54b2c790561383971d2f52d113d9c363", size = 224809 },
+    { url = "https://files.pythonhosted.org/packages/7a/d0/78200a45ba3240cb042bc597d6f2accba9193a2c57d0356268cbbe2d0925/librt-0.8.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5212a5bd7fae98dae95710032902edcd2ec4dc994e883294f75c857b83f9aba0", size = 218075 },
+    { url = "https://files.pythonhosted.org/packages/af/72/a210839fa74c90474897124c064ffca07f8d4b347b6574d309686aae7ca6/librt-0.8.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e692aa2d1d604e6ca12d35e51fdc36f4cda6345e28e36374579f7ef3611b3012", size = 225486 },
+    { url = "https://files.pythonhosted.org/packages/a3/c1/a03cc63722339ddbf087485f253493e2b013039f5b707e8e6016141130fa/librt-0.8.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4be2a5c926b9770c9e08e717f05737a269b9d0ebc5d2f0060f0fe3fe9ce47acb", size = 218219 },
+    { url = "https://files.pythonhosted.org/packages/58/f5/fff6108af0acf941c6f274a946aea0e484bd10cd2dc37610287ce49388c5/librt-0.8.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fd1a720332ea335ceb544cf0a03f81df92abd4bb887679fd1e460976b0e6214b", size = 218750 },
+    { url = "https://files.pythonhosted.org/packages/71/67/5a387bfef30ec1e4b4f30562c8586566faf87e47d696768c19feb49e3646/librt-0.8.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2af9e01e0ef80d95ae3c720be101227edae5f2fe7e3dc63d8857fadfc5a1d", size = 241624 },
+    { url = "https://files.pythonhosted.org/packages/d4/be/24f8502db11d405232ac1162eb98069ca49c3306c1d75c6ccc61d9af8789/librt-0.8.1-cp313-cp313-win32.whl", hash = "sha256:086a32dbb71336627e78cc1d6ee305a68d038ef7d4c39aaff41ae8c9aa46e91a", size = 54969 },
+    { url = "https://files.pythonhosted.org/packages/5c/73/c9fdf6cb2a529c1a092ce769a12d88c8cca991194dfe641b6af12fa964d2/librt-0.8.1-cp313-cp313-win_amd64.whl", hash = "sha256:e11769a1dbda4da7b00a76cfffa67aa47cfa66921d2724539eee4b9ede780b79", size = 62000 },
+    { url = "https://files.pythonhosted.org/packages/d3/97/68f80ca3ac4924f250cdfa6e20142a803e5e50fca96ef5148c52ee8c10ea/librt-0.8.1-cp313-cp313-win_arm64.whl", hash = "sha256:924817ab3141aca17893386ee13261f1d100d1ef410d70afe4389f2359fea4f0", size = 52495 },
+    { url = "https://files.pythonhosted.org/packages/c9/6a/907ef6800f7bca71b525a05f1839b21f708c09043b1c6aa77b6b827b3996/librt-0.8.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6cfa7fe54fd4d1f47130017351a959fe5804bda7a0bc7e07a2cdbc3fdd28d34f", size = 66081 },
+    { url = "https://files.pythonhosted.org/packages/1b/18/25e991cd5640c9fb0f8d91b18797b29066b792f17bf8493da183bf5caabe/librt-0.8.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:228c2409c079f8c11fb2e5d7b277077f694cb93443eb760e00b3b83cb8b3176c", size = 68309 },
+    { url = "https://files.pythonhosted.org/packages/a4/36/46820d03f058cfb5a9de5940640ba03165ed8aded69e0733c417bb04df34/librt-0.8.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7aae78ab5e3206181780e56912d1b9bb9f90a7249ce12f0e8bf531d0462dd0fc", size = 196804 },
+    { url = "https://files.pythonhosted.org/packages/59/18/5dd0d3b87b8ff9c061849fbdb347758d1f724b9a82241aa908e0ec54ccd0/librt-0.8.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:172d57ec04346b047ca6af181e1ea4858086c80bdf455f61994c4aa6fc3f866c", size = 206907 },
+    { url = "https://files.pythonhosted.org/packages/d1/96/ef04902aad1424fd7299b62d1890e803e6ab4018c3044dca5922319c4b97/librt-0.8.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b1977c4ea97ce5eb7755a78fae68d87e4102e4aaf54985e8b56806849cc06a3", size = 221217 },
+    { url = "https://files.pythonhosted.org/packages/6d/ff/7e01f2dda84a8f5d280637a2e5827210a8acca9a567a54507ef1c75b342d/librt-0.8.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:10c42e1f6fd06733ef65ae7bebce2872bcafd8d6e6b0a08fe0a05a23b044fb14", size = 214622 },
+    { url = "https://files.pythonhosted.org/packages/1e/8c/5b093d08a13946034fed57619742f790faf77058558b14ca36a6e331161e/librt-0.8.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4c8dfa264b9193c4ee19113c985c95f876fae5e51f731494fc4e0cf594990ba7", size = 221987 },
+    { url = "https://files.pythonhosted.org/packages/d3/cc/86b0b3b151d40920ad45a94ce0171dec1aebba8a9d72bb3fa00c73ab25dd/librt-0.8.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:01170b6729a438f0dedc4a26ed342e3dc4f02d1000b4b19f980e1877f0c297e6", size = 215132 },
+    { url = "https://files.pythonhosted.org/packages/fc/be/8588164a46edf1e69858d952654e216a9a91174688eeefb9efbb38a9c799/librt-0.8.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:7b02679a0d783bdae30d443025b94465d8c3dc512f32f5b5031f93f57ac32071", size = 215195 },
+    { url = "https://files.pythonhosted.org/packages/f5/f2/0b9279bea735c734d69344ecfe056c1ba211694a72df10f568745c899c76/librt-0.8.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:190b109bb69592a3401fe1ffdea41a2e73370ace2ffdc4a0e8e2b39cdea81b78", size = 237946 },
+    { url = "https://files.pythonhosted.org/packages/e9/cc/5f2a34fbc8aeb35314a3641f9956fa9051a947424652fad9882be7a97949/librt-0.8.1-cp314-cp314-win32.whl", hash = "sha256:e70a57ecf89a0f64c24e37f38d3fe217a58169d2fe6ed6d70554964042474023", size = 50689 },
+    { url = "https://files.pythonhosted.org/packages/a0/76/cd4d010ab2147339ca2b93e959c3686e964edc6de66ddacc935c325883d7/librt-0.8.1-cp314-cp314-win_amd64.whl", hash = "sha256:7e2f3edca35664499fbb36e4770650c4bd4a08abc1f4458eab9df4ec56389730", size = 57875 },
+    { url = "https://files.pythonhosted.org/packages/84/0f/2143cb3c3ca48bd3379dcd11817163ca50781927c4537345d608b5045998/librt-0.8.1-cp314-cp314-win_arm64.whl", hash = "sha256:0d2f82168e55ddefd27c01c654ce52379c0750ddc31ee86b4b266bcf4d65f2a3", size = 48058 },
+    { url = "https://files.pythonhosted.org/packages/d2/0e/9b23a87e37baf00311c3efe6b48d6b6c168c29902dfc3f04c338372fd7db/librt-0.8.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c74a2da57a094bd48d03fa5d196da83d2815678385d2978657499063709abe1", size = 68313 },
+    { url = "https://files.pythonhosted.org/packages/db/9a/859c41e5a4f1c84200a7d2b92f586aa27133c8243b6cac9926f6e54d01b9/librt-0.8.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a355d99c4c0d8e5b770313b8b247411ed40949ca44e33e46a4789b9293a907ee", size = 70994 },
+    { url = "https://files.pythonhosted.org/packages/4c/28/10605366ee599ed34223ac2bf66404c6fb59399f47108215d16d5ad751a8/librt-0.8.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2eb345e8b33fb748227409c9f1233d4df354d6e54091f0e8fc53acdb2ffedeb7", size = 220770 },
+    { url = "https://files.pythonhosted.org/packages/af/8d/16ed8fd452dafae9c48d17a6bc1ee3e818fd40ef718d149a8eff2c9f4ea2/librt-0.8.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9be2f15e53ce4e83cc08adc29b26fb5978db62ef2a366fbdf716c8a6c8901040", size = 235409 },
+    { url = "https://files.pythonhosted.org/packages/89/1b/7bdf3e49349c134b25db816e4a3db6b94a47ac69d7d46b1e682c2c4949be/librt-0.8.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:785ae29c1f5c6e7c2cde2c7c0e148147f4503da3abc5d44d482068da5322fd9e", size = 246473 },
+    { url = "https://files.pythonhosted.org/packages/4e/8a/91fab8e4fd2a24930a17188c7af5380eb27b203d72101c9cc000dbdfd95a/librt-0.8.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1d3a7da44baf692f0c6aeb5b2a09c5e6fc7a703bca9ffa337ddd2e2da53f7732", size = 238866 },
+    { url = "https://files.pythonhosted.org/packages/b9/e0/c45a098843fc7c07e18a7f8a24ca8496aecbf7bdcd54980c6ca1aaa79a8e/librt-0.8.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5fc48998000cbc39ec0d5311312dda93ecf92b39aaf184c5e817d5d440b29624", size = 250248 },
+    { url = "https://files.pythonhosted.org/packages/82/30/07627de23036640c952cce0c1fe78972e77d7d2f8fd54fa5ef4554ff4a56/librt-0.8.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:e96baa6820280077a78244b2e06e416480ed859bbd8e5d641cf5742919d8beb4", size = 240629 },
+    { url = "https://files.pythonhosted.org/packages/fb/c1/55bfe1ee3542eba055616f9098eaf6eddb966efb0ca0f44eaa4aba327307/librt-0.8.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31362dbfe297b23590530007062c32c6f6176f6099646bb2c95ab1b00a57c382", size = 239615 },
+    { url = "https://files.pythonhosted.org/packages/2b/39/191d3d28abc26c9099b19852e6c99f7f6d400b82fa5a4e80291bd3803e19/librt-0.8.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cc3656283d11540ab0ea01978378e73e10002145117055e03722417aeab30994", size = 263001 },
+    { url = "https://files.pythonhosted.org/packages/b9/eb/7697f60fbe7042ab4e88f4ee6af496b7f222fffb0a4e3593ef1f29f81652/librt-0.8.1-cp314-cp314t-win32.whl", hash = "sha256:738f08021b3142c2918c03692608baed43bc51144c29e35807682f8070ee2a3a", size = 51328 },
+    { url = "https://files.pythonhosted.org/packages/7c/72/34bf2eb7a15414a23e5e70ecb9440c1d3179f393d9349338a91e2781c0fb/librt-0.8.1-cp314-cp314t-win_amd64.whl", hash = "sha256:89815a22daf9c51884fb5dbe4f1ef65ee6a146e0b6a8df05f753e2e4a9359bf4", size = 58722 },
+    { url = "https://files.pythonhosted.org/packages/b2/c8/d148e041732d631fc76036f8b30fae4e77b027a1e95b7a84bb522481a940/librt-0.8.1-cp314-cp314t-win_arm64.whl", hash = "sha256:bf512a71a23504ed08103a13c941f763db13fb11177beb3d9244c98c29fb4a61", size = 48755 },
 ]
 
 [[package]]
@@ -539,72 +621,84 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markupsafe" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9e/38/bd5b78a920a64d708fe6bc8e0a2c075e1389d53bef8413725c63ba041535/mako-1.3.10.tar.gz", hash = "sha256:99579a6f39583fa7e5630a28c3c1f440e4e97a414b80372649c0ce338da2ea28", size = 392474, upload-time = "2025-04-10T12:44:31.16Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/38/bd5b78a920a64d708fe6bc8e0a2c075e1389d53bef8413725c63ba041535/mako-1.3.10.tar.gz", hash = "sha256:99579a6f39583fa7e5630a28c3c1f440e4e97a414b80372649c0ce338da2ea28", size = 392474 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/87/fb/99f81ac72ae23375f22b7afdb7642aba97c00a713c217124420147681a2f/mako-1.3.10-py3-none-any.whl", hash = "sha256:baef24a52fc4fc514a0887ac600f9f1cff3d82c61d4d700a1fa84d597b88db59", size = 78509, upload-time = "2025-04-10T12:50:53.297Z" },
+    { url = "https://files.pythonhosted.org/packages/87/fb/99f81ac72ae23375f22b7afdb7642aba97c00a713c217124420147681a2f/mako-1.3.10-py3-none-any.whl", hash = "sha256:baef24a52fc4fc514a0887ac600f9f1cff3d82c61d4d700a1fa84d597b88db59", size = 78509 },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321 },
 ]
 
 [[package]]
 name = "markupsafe"
 version = "3.0.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
-    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
-    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
-    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
-    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
-    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
-    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
-    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
-    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
-    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
-    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
-    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
-    { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" },
-    { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" },
-    { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" },
-    { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" },
-    { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" },
-    { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" },
-    { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" },
-    { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" },
-    { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" },
-    { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" },
-    { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615 },
+    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020 },
+    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332 },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947 },
+    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962 },
+    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760 },
+    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529 },
+    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015 },
+    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540 },
+    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105 },
+    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906 },
+    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622 },
+    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029 },
+    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374 },
+    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980 },
+    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990 },
+    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784 },
+    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588 },
+    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041 },
+    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543 },
+    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113 },
+    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911 },
+    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658 },
+    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066 },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639 },
+    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569 },
+    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284 },
+    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801 },
+    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769 },
+    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642 },
+    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612 },
+    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200 },
+    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973 },
+    { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619 },
+    { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029 },
+    { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408 },
+    { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005 },
+    { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048 },
+    { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821 },
+    { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606 },
+    { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043 },
+    { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747 },
+    { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341 },
+    { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073 },
+    { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661 },
+    { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069 },
+    { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670 },
+    { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598 },
+    { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261 },
+    { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835 },
+    { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733 },
+    { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672 },
+    { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819 },
+    { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426 },
+    { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146 },
 ]
 
 [[package]]
@@ -614,9 +708,18 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" },
+    { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516 },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 },
 ]
 
 [[package]]
@@ -629,63 +732,63 @@ dependencies = [
     { name = "pathspec" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404, upload-time = "2025-12-15T05:03:48.42Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/06/8a/19bfae96f6615aa8a0604915512e0289b1fad33d5909bf7244f02935d33a/mypy-1.19.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8174a03289288c1f6c46d55cef02379b478bfbc8e358e02047487cad44c6ca1", size = 13206053, upload-time = "2025-12-15T05:03:46.622Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/34/3e63879ab041602154ba2a9f99817bb0c85c4df19a23a1443c8986e4d565/mypy-1.19.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffcebe56eb09ff0c0885e750036a095e23793ba6c2e894e7e63f6d89ad51f22e", size = 12219134, upload-time = "2025-12-15T05:03:24.367Z" },
-    { url = "https://files.pythonhosted.org/packages/89/cc/2db6f0e95366b630364e09845672dbee0cbf0bbe753a204b29a944967cd9/mypy-1.19.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b64d987153888790bcdb03a6473d321820597ab8dd9243b27a92153c4fa50fd2", size = 12731616, upload-time = "2025-12-15T05:02:44.725Z" },
-    { url = "https://files.pythonhosted.org/packages/00/be/dd56c1fd4807bc1eba1cf18b2a850d0de7bacb55e158755eb79f77c41f8e/mypy-1.19.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c35d298c2c4bba75feb2195655dfea8124d855dfd7343bf8b8c055421eaf0cf8", size = 13620847, upload-time = "2025-12-15T05:03:39.633Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/42/332951aae42b79329f743bf1da088cd75d8d4d9acc18fbcbd84f26c1af4e/mypy-1.19.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:34c81968774648ab5ac09c29a375fdede03ba253f8f8287847bd480782f73a6a", size = 13834976, upload-time = "2025-12-15T05:03:08.786Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/63/e7493e5f90e1e085c562bb06e2eb32cae27c5057b9653348d38b47daaecc/mypy-1.19.1-cp312-cp312-win_amd64.whl", hash = "sha256:b10e7c2cd7870ba4ad9b2d8a6102eb5ffc1f16ca35e3de6bfa390c1113029d13", size = 10118104, upload-time = "2025-12-15T05:03:10.834Z" },
-    { url = "https://files.pythonhosted.org/packages/de/9f/a6abae693f7a0c697dbb435aac52e958dc8da44e92e08ba88d2e42326176/mypy-1.19.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e3157c7594ff2ef1634ee058aafc56a82db665c9438fd41b390f3bde1ab12250", size = 13201927, upload-time = "2025-12-15T05:02:29.138Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/a4/45c35ccf6e1c65afc23a069f50e2c66f46bd3798cbe0d680c12d12935caa/mypy-1.19.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdb12f69bcc02700c2b47e070238f42cb87f18c0bc1fc4cdb4fb2bc5fd7a3b8b", size = 12206730, upload-time = "2025-12-15T05:03:01.325Z" },
-    { url = "https://files.pythonhosted.org/packages/05/bb/cdcf89678e26b187650512620eec8368fded4cfd99cfcb431e4cdfd19dec/mypy-1.19.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f859fb09d9583a985be9a493d5cfc5515b56b08f7447759a0c5deaf68d80506e", size = 12724581, upload-time = "2025-12-15T05:03:20.087Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/32/dd260d52babf67bad8e6770f8e1102021877ce0edea106e72df5626bb0ec/mypy-1.19.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9a6538e0415310aad77cb94004ca6482330fece18036b5f360b62c45814c4ef", size = 13616252, upload-time = "2025-12-15T05:02:49.036Z" },
-    { url = "https://files.pythonhosted.org/packages/71/d0/5e60a9d2e3bd48432ae2b454b7ef2b62a960ab51292b1eda2a95edd78198/mypy-1.19.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:da4869fc5e7f62a88f3fe0b5c919d1d9f7ea3cef92d3689de2823fd27e40aa75", size = 13840848, upload-time = "2025-12-15T05:02:55.95Z" },
-    { url = "https://files.pythonhosted.org/packages/98/76/d32051fa65ecf6cc8c6610956473abdc9b4c43301107476ac03559507843/mypy-1.19.1-cp313-cp313-win_amd64.whl", hash = "sha256:016f2246209095e8eda7538944daa1d60e1e8134d98983b9fc1e92c1fc0cb8dd", size = 10135510, upload-time = "2025-12-15T05:02:58.438Z" },
-    { url = "https://files.pythonhosted.org/packages/de/eb/b83e75f4c820c4247a58580ef86fcd35165028f191e7e1ba57128c52782d/mypy-1.19.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06e6170bd5836770e8104c8fdd58e5e725cfeb309f0a6c681a811f557e97eac1", size = 13199744, upload-time = "2025-12-15T05:03:30.823Z" },
-    { url = "https://files.pythonhosted.org/packages/94/28/52785ab7bfa165f87fcbb61547a93f98bb20e7f82f90f165a1f69bce7b3d/mypy-1.19.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:804bd67b8054a85447c8954215a906d6eff9cabeabe493fb6334b24f4bfff718", size = 12215815, upload-time = "2025-12-15T05:02:42.323Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/c6/bdd60774a0dbfb05122e3e925f2e9e846c009e479dcec4821dad881f5b52/mypy-1.19.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21761006a7f497cb0d4de3d8ef4ca70532256688b0523eee02baf9eec895e27b", size = 12740047, upload-time = "2025-12-15T05:03:33.168Z" },
-    { url = "https://files.pythonhosted.org/packages/32/2a/66ba933fe6c76bd40d1fe916a83f04fed253152f451a877520b3c4a5e41e/mypy-1.19.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28902ee51f12e0f19e1e16fbe2f8f06b6637f482c459dd393efddd0ec7f82045", size = 13601998, upload-time = "2025-12-15T05:03:13.056Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/da/5055c63e377c5c2418760411fd6a63ee2b96cf95397259038756c042574f/mypy-1.19.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:481daf36a4c443332e2ae9c137dfee878fcea781a2e3f895d54bd3002a900957", size = 13807476, upload-time = "2025-12-15T05:03:17.977Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/09/4ebd873390a063176f06b0dbf1f7783dd87bd120eae7727fa4ae4179b685/mypy-1.19.1-cp314-cp314-win_amd64.whl", hash = "sha256:8bb5c6f6d043655e055be9b542aa5f3bdd30e4f3589163e85f93f3640060509f", size = 10281872, upload-time = "2025-12-15T05:03:05.549Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239, upload-time = "2025-12-15T05:03:07.248Z" },
+    { url = "https://files.pythonhosted.org/packages/06/8a/19bfae96f6615aa8a0604915512e0289b1fad33d5909bf7244f02935d33a/mypy-1.19.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8174a03289288c1f6c46d55cef02379b478bfbc8e358e02047487cad44c6ca1", size = 13206053 },
+    { url = "https://files.pythonhosted.org/packages/a5/34/3e63879ab041602154ba2a9f99817bb0c85c4df19a23a1443c8986e4d565/mypy-1.19.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffcebe56eb09ff0c0885e750036a095e23793ba6c2e894e7e63f6d89ad51f22e", size = 12219134 },
+    { url = "https://files.pythonhosted.org/packages/89/cc/2db6f0e95366b630364e09845672dbee0cbf0bbe753a204b29a944967cd9/mypy-1.19.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b64d987153888790bcdb03a6473d321820597ab8dd9243b27a92153c4fa50fd2", size = 12731616 },
+    { url = "https://files.pythonhosted.org/packages/00/be/dd56c1fd4807bc1eba1cf18b2a850d0de7bacb55e158755eb79f77c41f8e/mypy-1.19.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c35d298c2c4bba75feb2195655dfea8124d855dfd7343bf8b8c055421eaf0cf8", size = 13620847 },
+    { url = "https://files.pythonhosted.org/packages/6d/42/332951aae42b79329f743bf1da088cd75d8d4d9acc18fbcbd84f26c1af4e/mypy-1.19.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:34c81968774648ab5ac09c29a375fdede03ba253f8f8287847bd480782f73a6a", size = 13834976 },
+    { url = "https://files.pythonhosted.org/packages/6f/63/e7493e5f90e1e085c562bb06e2eb32cae27c5057b9653348d38b47daaecc/mypy-1.19.1-cp312-cp312-win_amd64.whl", hash = "sha256:b10e7c2cd7870ba4ad9b2d8a6102eb5ffc1f16ca35e3de6bfa390c1113029d13", size = 10118104 },
+    { url = "https://files.pythonhosted.org/packages/de/9f/a6abae693f7a0c697dbb435aac52e958dc8da44e92e08ba88d2e42326176/mypy-1.19.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e3157c7594ff2ef1634ee058aafc56a82db665c9438fd41b390f3bde1ab12250", size = 13201927 },
+    { url = "https://files.pythonhosted.org/packages/9a/a4/45c35ccf6e1c65afc23a069f50e2c66f46bd3798cbe0d680c12d12935caa/mypy-1.19.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdb12f69bcc02700c2b47e070238f42cb87f18c0bc1fc4cdb4fb2bc5fd7a3b8b", size = 12206730 },
+    { url = "https://files.pythonhosted.org/packages/05/bb/cdcf89678e26b187650512620eec8368fded4cfd99cfcb431e4cdfd19dec/mypy-1.19.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f859fb09d9583a985be9a493d5cfc5515b56b08f7447759a0c5deaf68d80506e", size = 12724581 },
+    { url = "https://files.pythonhosted.org/packages/d1/32/dd260d52babf67bad8e6770f8e1102021877ce0edea106e72df5626bb0ec/mypy-1.19.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9a6538e0415310aad77cb94004ca6482330fece18036b5f360b62c45814c4ef", size = 13616252 },
+    { url = "https://files.pythonhosted.org/packages/71/d0/5e60a9d2e3bd48432ae2b454b7ef2b62a960ab51292b1eda2a95edd78198/mypy-1.19.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:da4869fc5e7f62a88f3fe0b5c919d1d9f7ea3cef92d3689de2823fd27e40aa75", size = 13840848 },
+    { url = "https://files.pythonhosted.org/packages/98/76/d32051fa65ecf6cc8c6610956473abdc9b4c43301107476ac03559507843/mypy-1.19.1-cp313-cp313-win_amd64.whl", hash = "sha256:016f2246209095e8eda7538944daa1d60e1e8134d98983b9fc1e92c1fc0cb8dd", size = 10135510 },
+    { url = "https://files.pythonhosted.org/packages/de/eb/b83e75f4c820c4247a58580ef86fcd35165028f191e7e1ba57128c52782d/mypy-1.19.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06e6170bd5836770e8104c8fdd58e5e725cfeb309f0a6c681a811f557e97eac1", size = 13199744 },
+    { url = "https://files.pythonhosted.org/packages/94/28/52785ab7bfa165f87fcbb61547a93f98bb20e7f82f90f165a1f69bce7b3d/mypy-1.19.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:804bd67b8054a85447c8954215a906d6eff9cabeabe493fb6334b24f4bfff718", size = 12215815 },
+    { url = "https://files.pythonhosted.org/packages/0a/c6/bdd60774a0dbfb05122e3e925f2e9e846c009e479dcec4821dad881f5b52/mypy-1.19.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21761006a7f497cb0d4de3d8ef4ca70532256688b0523eee02baf9eec895e27b", size = 12740047 },
+    { url = "https://files.pythonhosted.org/packages/32/2a/66ba933fe6c76bd40d1fe916a83f04fed253152f451a877520b3c4a5e41e/mypy-1.19.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28902ee51f12e0f19e1e16fbe2f8f06b6637f482c459dd393efddd0ec7f82045", size = 13601998 },
+    { url = "https://files.pythonhosted.org/packages/e3/da/5055c63e377c5c2418760411fd6a63ee2b96cf95397259038756c042574f/mypy-1.19.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:481daf36a4c443332e2ae9c137dfee878fcea781a2e3f895d54bd3002a900957", size = 13807476 },
+    { url = "https://files.pythonhosted.org/packages/cd/09/4ebd873390a063176f06b0dbf1f7783dd87bd120eae7727fa4ae4179b685/mypy-1.19.1-cp314-cp314-win_amd64.whl", hash = "sha256:8bb5c6f6d043655e055be9b542aa5f3bdd30e4f3589163e85f93f3640060509f", size = 10281872 },
+    { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239 },
 ]
 
 [[package]]
 name = "mypy-extensions"
 version = "1.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963 },
 ]
 
 [[package]]
 name = "packaging"
 version = "26.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366 },
 ]
 
 [[package]]
 name = "parso"
 version = "0.8.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", hash = "sha256:2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd", size = 401621, upload-time = "2026-02-09T15:45:24.425Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", hash = "sha256:2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd", size = 401621 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", hash = "sha256:2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff", size = 106894, upload-time = "2026-02-09T15:45:21.391Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", hash = "sha256:2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff", size = 106894 },
 ]
 
 [[package]]
 name = "pathspec"
 version = "1.0.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206 },
 ]
 
 [[package]]
@@ -695,18 +798,18 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "ptyprocess" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772 },
 ]
 
 [[package]]
 name = "pluggy"
 version = "1.6.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538 },
 ]
 
 [[package]]
@@ -716,36 +819,36 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "wcwidth" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
+    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431 },
 ]
 
 [[package]]
 name = "ptyprocess"
 version = "0.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" },
+    { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993 },
 ]
 
 [[package]]
 name = "pure-eval"
 version = "0.2.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842 },
 ]
 
 [[package]]
 name = "pycparser"
 version = "3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172 },
 ]
 
 [[package]]
@@ -758,9 +861,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580 },
 ]
 
 [[package]]
@@ -770,77 +873,73 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
-    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
-    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
-    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
-    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
-    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
-    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
-    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
-    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
-    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
-    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
-    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
-    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
-    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
-    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
-    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
-    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
-    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
-    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
-    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
-    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
-    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
-    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
-    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
-    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990 },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003 },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200 },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578 },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504 },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816 },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366 },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698 },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603 },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591 },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068 },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908 },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145 },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179 },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403 },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206 },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307 },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258 },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917 },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186 },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164 },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146 },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788 },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133 },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852 },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679 },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766 },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005 },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622 },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725 },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040 },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691 },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897 },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302 },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877 },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680 },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960 },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102 },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039 },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126 },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489 },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288 },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255 },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760 },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092 },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385 },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832 },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585 },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078 },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914 },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560 },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244 },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955 },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906 },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607 },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769 },
 ]
 
 [[package]]
 name = "pygments"
 version = "2.19.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217 },
 ]
 
 [[package]]
@@ -854,9 +953,9 @@ dependencies = [
     { name = "pluggy" },
     { name = "pygments" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750 },
 ]
 
 [[package]]
@@ -866,136 +965,173 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f2/a8/ecbc8ede70921dd2f544ab1cadd3ff3bf842af27f87bbdea774c7baa1d38/pytest_asyncio-0.25.3.tar.gz", hash = "sha256:fc1da2cf9f125ada7e710b4ddad05518d4cee187ae9412e9ac9271003497f07a", size = 54239, upload-time = "2025-01-28T18:37:58.729Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/a8/ecbc8ede70921dd2f544ab1cadd3ff3bf842af27f87bbdea774c7baa1d38/pytest_asyncio-0.25.3.tar.gz", hash = "sha256:fc1da2cf9f125ada7e710b4ddad05518d4cee187ae9412e9ac9271003497f07a", size = 54239 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/67/17/3493c5624e48fd97156ebaec380dcaafee9506d7e2c46218ceebbb57d7de/pytest_asyncio-0.25.3-py3-none-any.whl", hash = "sha256:9e89518e0f9bd08928f97a3482fdc4e244df17529460bc038291ccaf8f85c7c3", size = 19467, upload-time = "2025-01-28T18:37:56.798Z" },
+    { url = "https://files.pythonhosted.org/packages/67/17/3493c5624e48fd97156ebaec380dcaafee9506d7e2c46218ceebbb57d7de/pytest_asyncio-0.25.3-py3-none-any.whl", hash = "sha256:9e89518e0f9bd08928f97a3482fdc4e244df17529460bc038291ccaf8f85c7c3", size = 19467 },
 ]
 
 [[package]]
 name = "python-dotenv"
 version = "1.2.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" },
+    { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230 },
+]
+
+[[package]]
+name = "python-gitlab"
+version = "5.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "requests" },
+    { name = "requests-toolbelt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d6/08/d35d0f28549c43611e942f39b6321a7b35c02189d5badceefe601c0207ce/python_gitlab-5.6.0.tar.gz", hash = "sha256:bc531e8ba3e5641b60409445d4919ace68a2c18cb0ec6d48fbced6616b954166", size = 396148 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/5e/2e1ed7145835afaad87664b2f675a1d7b6e1211ad6ecfe57e200ae45f0bd/python_gitlab-5.6.0-py3-none-any.whl", hash = "sha256:68980cd70929fc7f8f06d8a7b09bd046a6b79e1995c19d61249f046005099100", size = 148836 },
 ]
 
 [[package]]
 name = "python-multipart"
 version = "0.0.22"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612, upload-time = "2026-01-25T10:15:56.219Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579, upload-time = "2026-01-25T10:15:54.811Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579 },
+]
+
+[[package]]
+name = "python-semantic-release"
+version = "9.21.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "click-option-group" },
+    { name = "deprecated" },
+    { name = "dotty-dict" },
+    { name = "gitpython" },
+    { name = "importlib-resources" },
+    { name = "jinja2" },
+    { name = "pydantic" },
+    { name = "python-gitlab" },
+    { name = "requests" },
+    { name = "rich" },
+    { name = "shellingham" },
+    { name = "tomlkit" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f7/ae/3ac172d9cb71dcf25be15c727ce84b3b16f31df98e8015a0a73fe3e29e1c/python_semantic_release-9.21.1.tar.gz", hash = "sha256:b5c509a573899e88e8f29504d2f83e9ddab9a66af861ec1baf39f2b86bbf3517", size = 308463 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/af/b7c6e77142586c4809cb93b636f62cecda73fa543ec4bd00a89eb3e1d4f3/python_semantic_release-9.21.1-py3-none-any.whl", hash = "sha256:e69afe5100106390eec9e800132c947ed774bdcf9aa8f0df29589ea9ef375a21", size = 132726 },
 ]
 
 [[package]]
 name = "pyyaml"
 version = "6.0.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
-    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
-    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
-    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
-    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
-    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
-    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
-    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
-    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
-    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
-    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
-    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
-    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
-    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
-    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
-    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
-    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
-    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063 },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973 },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116 },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011 },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870 },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089 },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181 },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658 },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003 },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344 },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669 },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252 },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081 },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159 },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626 },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613 },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115 },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427 },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090 },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246 },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814 },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809 },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454 },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355 },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175 },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228 },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194 },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429 },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912 },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108 },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641 },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901 },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132 },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261 },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272 },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923 },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062 },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341 },
 ]
 
 [[package]]
 name = "rapidfuzz"
 version = "3.14.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d3/28/9d808fe62375b9aab5ba92fa9b29371297b067c2790b2d7cda648b1e2f8d/rapidfuzz-3.14.3.tar.gz", hash = "sha256:2491937177868bc4b1e469087601d53f925e8d270ccc21e07404b4b5814b7b5f", size = 57863900, upload-time = "2025-11-01T11:54:52.321Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/28/9d808fe62375b9aab5ba92fa9b29371297b067c2790b2d7cda648b1e2f8d/rapidfuzz-3.14.3.tar.gz", hash = "sha256:2491937177868bc4b1e469087601d53f925e8d270ccc21e07404b4b5814b7b5f", size = 57863900 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/8e/3c215e860b458cfbedb3ed73bc72e98eb7e0ed72f6b48099604a7a3260c2/rapidfuzz-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:685c93ea961d135893b5984a5a9851637d23767feabe414ec974f43babbd8226", size = 1945306, upload-time = "2025-11-01T11:53:06.452Z" },
-    { url = "https://files.pythonhosted.org/packages/36/d9/31b33512015c899f4a6e6af64df8dfe8acddf4c8b40a4b3e0e6e1bcd00e5/rapidfuzz-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fa7c8f26f009f8c673fbfb443792f0cf8cf50c4e18121ff1e285b5e08a94fbdb", size = 1390788, upload-time = "2025-11-01T11:53:08.721Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/67/2ee6f8de6e2081ccd560a571d9c9063184fe467f484a17fa90311a7f4a2e/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:57f878330c8d361b2ce76cebb8e3e1dc827293b6abf404e67d53260d27b5d941", size = 1374580, upload-time = "2025-11-01T11:53:10.164Z" },
-    { url = "https://files.pythonhosted.org/packages/30/83/80d22997acd928eda7deadc19ccd15883904622396d6571e935993e0453a/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c5f545f454871e6af05753a0172849c82feaf0f521c5ca62ba09e1b382d6382", size = 3154947, upload-time = "2025-11-01T11:53:12.093Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/cf/9f49831085a16384695f9fb096b99662f589e30b89b4a589a1ebc1a19d34/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:07aa0b5d8863e3151e05026a28e0d924accf0a7a3b605da978f0359bb804df43", size = 1223872, upload-time = "2025-11-01T11:53:13.664Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/0f/41ee8034e744b871c2e071ef0d360686f5ccfe5659f4fd96c3ec406b3c8b/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73b07566bc7e010e7b5bd490fb04bb312e820970180df6b5655e9e6224c137db", size = 2392512, upload-time = "2025-11-01T11:53:15.109Z" },
-    { url = "https://files.pythonhosted.org/packages/da/86/280038b6b0c2ccec54fb957c732ad6b41cc1fd03b288d76545b9cf98343f/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6de00eb84c71476af7d3110cf25d8fe7c792d7f5fa86764ef0b4ca97e78ca3ed", size = 2521398, upload-time = "2025-11-01T11:53:17.146Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/7b/05c26f939607dca0006505e3216248ae2de631e39ef94dd63dbbf0860021/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d7843a1abf0091773a530636fdd2a49a41bcae22f9910b86b4f903e76ddc82dc", size = 4259416, upload-time = "2025-11-01T11:53:19.34Z" },
-    { url = "https://files.pythonhosted.org/packages/40/eb/9e3af4103d91788f81111af1b54a28de347cdbed8eaa6c91d5e98a889aab/rapidfuzz-3.14.3-cp312-cp312-win32.whl", hash = "sha256:dea97ac3ca18cd3ba8f3d04b5c1fe4aa60e58e8d9b7793d3bd595fdb04128d7a", size = 1709527, upload-time = "2025-11-01T11:53:20.949Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/63/d06ecce90e2cf1747e29aeab9f823d21e5877a4c51b79720b2d3be7848f8/rapidfuzz-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:b5100fd6bcee4d27f28f4e0a1c6b5127bc8ba7c2a9959cad9eab0bf4a7ab3329", size = 1538989, upload-time = "2025-11-01T11:53:22.428Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/6d/beee32dcda64af8128aab3ace2ccb33d797ed58c434c6419eea015fec779/rapidfuzz-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:4e49c9e992bc5fc873bd0fff7ef16a4405130ec42f2ce3d2b735ba5d3d4eb70f", size = 811161, upload-time = "2025-11-01T11:53:23.811Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/4f/0d94d09646853bd26978cb3a7541b6233c5760687777fa97da8de0d9a6ac/rapidfuzz-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dbcb726064b12f356bf10fffdb6db4b6dce5390b23627c08652b3f6e49aa56ae", size = 1939646, upload-time = "2025-11-01T11:53:25.292Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/eb/f96aefc00f3bbdbab9c0657363ea8437a207d7545ac1c3789673e05d80bd/rapidfuzz-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1704fc70d214294e554a2421b473779bcdeef715881c5e927dc0f11e1692a0ff", size = 1385512, upload-time = "2025-11-01T11:53:27.594Z" },
-    { url = "https://files.pythonhosted.org/packages/26/34/71c4f7749c12ee223dba90017a5947e8f03731a7cc9f489b662a8e9e643d/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc65e72790ddfd310c2c8912b45106e3800fefe160b0c2ef4d6b6fec4e826457", size = 1373571, upload-time = "2025-11-01T11:53:29.096Z" },
-    { url = "https://files.pythonhosted.org/packages/32/00/ec8597a64f2be301ce1ee3290d067f49f6a7afb226b67d5f15b56d772ba5/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43e38c1305cffae8472572a0584d4ffc2f130865586a81038ca3965301f7c97c", size = 3156759, upload-time = "2025-11-01T11:53:30.777Z" },
-    { url = "https://files.pythonhosted.org/packages/61/d5/b41eeb4930501cc899d5a9a7b5c9a33d85a670200d7e81658626dcc0ecc0/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:e195a77d06c03c98b3fc06b8a28576ba824392ce40de8c708f96ce04849a052e", size = 1222067, upload-time = "2025-11-01T11:53:32.334Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/7d/6d9abb4ffd1027c6ed837b425834f3bed8344472eb3a503ab55b3407c721/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1b7ef2f4b8583a744338a18f12c69693c194fb6777c0e9ada98cd4d9e8f09d10", size = 2394775, upload-time = "2025-11-01T11:53:34.24Z" },
-    { url = "https://files.pythonhosted.org/packages/15/ce/4f3ab4c401c5a55364da1ffff8cc879fc97b4e5f4fa96033827da491a973/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:a2135b138bcdcb4c3742d417f215ac2d8c2b87bde15b0feede231ae95f09ec41", size = 2526123, upload-time = "2025-11-01T11:53:35.779Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/4b/54f804975376a328f57293bd817c12c9036171d15cf7292032e3f5820b2d/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:33a325ed0e8e1aa20c3e75f8ab057a7b248fdea7843c2a19ade0008906c14af0", size = 4262874, upload-time = "2025-11-01T11:53:37.866Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/b6/958db27d8a29a50ee6edd45d33debd3ce732e7209183a72f57544cd5fe22/rapidfuzz-3.14.3-cp313-cp313-win32.whl", hash = "sha256:8383b6d0d92f6cd008f3c9216535be215a064b2cc890398a678b56e6d280cb63", size = 1707972, upload-time = "2025-11-01T11:53:39.442Z" },
-    { url = "https://files.pythonhosted.org/packages/07/75/fde1f334b0cec15b5946d9f84d73250fbfcc73c236b4bc1b25129d90876b/rapidfuzz-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:e6b5e3036976f0fde888687d91be86d81f9ac5f7b02e218913c38285b756be6c", size = 1537011, upload-time = "2025-11-01T11:53:40.92Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/d7/d83fe001ce599dc7ead57ba1debf923dc961b6bdce522b741e6b8c82f55c/rapidfuzz-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:7ba009977601d8b0828bfac9a110b195b3e4e79b350dcfa48c11269a9f1918a0", size = 810744, upload-time = "2025-11-01T11:53:42.723Z" },
-    { url = "https://files.pythonhosted.org/packages/92/13/a486369e63ff3c1a58444d16b15c5feb943edd0e6c28a1d7d67cb8946b8f/rapidfuzz-3.14.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a0a28add871425c2fe94358c6300bbeb0bc2ed828ca003420ac6825408f5a424", size = 1967702, upload-time = "2025-11-01T11:53:44.554Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/82/efad25e260b7810f01d6b69122685e355bed78c94a12784bac4e0beb2afb/rapidfuzz-3.14.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:010e12e2411a4854b0434f920e72b717c43f8ec48d57e7affe5c42ecfa05dd0e", size = 1410702, upload-time = "2025-11-01T11:53:46.066Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/1a/34c977b860cde91082eae4a97ae503f43e0d84d4af301d857679b66f9869/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cfc3d57abd83c734d1714ec39c88a34dd69c85474918ebc21296f1e61eb5ca8", size = 1382337, upload-time = "2025-11-01T11:53:47.62Z" },
-    { url = "https://files.pythonhosted.org/packages/88/74/f50ea0e24a5880a9159e8fd256b84d8f4634c2f6b4f98028bdd31891d907/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89acb8cbb52904f763e5ac238083b9fc193bed8d1f03c80568b20e4cef43a519", size = 3165563, upload-time = "2025-11-01T11:53:49.216Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/7a/e744359404d7737049c26099423fc54bcbf303de5d870d07d2fb1410f567/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_31_armv7l.whl", hash = "sha256:7d9af908c2f371bfb9c985bd134e295038e3031e666e4b2ade1e7cb7f5af2f1a", size = 1214727, upload-time = "2025-11-01T11:53:50.883Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/2e/87adfe14ce75768ec6c2b8acd0e05e85e84be4be5e3d283cdae360afc4fe/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1f1925619627f8798f8c3a391d81071336942e5fe8467bc3c567f982e7ce2897", size = 2403349, upload-time = "2025-11-01T11:53:52.322Z" },
-    { url = "https://files.pythonhosted.org/packages/70/17/6c0b2b2bff9c8b12e12624c07aa22e922b0c72a490f180fa9183d1ef2c75/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:152555187360978119e98ce3e8263d70dd0c40c7541193fc302e9b7125cf8f58", size = 2507596, upload-time = "2025-11-01T11:53:53.835Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/d1/87852a7cbe4da7b962174c749a47433881a63a817d04f3e385ea9babcd9e/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:52619d25a09546b8db078981ca88939d72caa6b8701edd8b22e16482a38e799f", size = 4273595, upload-time = "2025-11-01T11:53:55.961Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/ab/1d0354b7d1771a28fa7fe089bc23acec2bdd3756efa2419f463e3ed80e16/rapidfuzz-3.14.3-cp313-cp313t-win32.whl", hash = "sha256:489ce98a895c98cad284f0a47960c3e264c724cb4cfd47a1430fa091c0c25204", size = 1757773, upload-time = "2025-11-01T11:53:57.628Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/0c/71ef356adc29e2bdf74cd284317b34a16b80258fa0e7e242dd92cc1e6d10/rapidfuzz-3.14.3-cp313-cp313t-win_amd64.whl", hash = "sha256:656e52b054d5b5c2524169240e50cfa080b04b1c613c5f90a2465e84888d6f15", size = 1576797, upload-time = "2025-11-01T11:53:59.455Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/d2/0e64fc27bb08d4304aa3d11154eb5480bcf5d62d60140a7ee984dc07468a/rapidfuzz-3.14.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c7e40c0a0af02ad6e57e89f62bef8604f55a04ecae90b0ceeda591bbf5923317", size = 829940, upload-time = "2025-11-01T11:54:01.1Z" },
-    { url = "https://files.pythonhosted.org/packages/32/6f/1b88aaeade83abc5418788f9e6b01efefcd1a69d65ded37d89cd1662be41/rapidfuzz-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:442125473b247227d3f2de807a11da6c08ccf536572d1be943f8e262bae7e4ea", size = 1942086, upload-time = "2025-11-01T11:54:02.592Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/2c/b23861347436cb10f46c2bd425489ec462790faaa360a54a7ede5f78de88/rapidfuzz-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ec0c8c0c3d4f97ced46b2e191e883f8c82dbbf6d5ebc1842366d7eff13cd5a6", size = 1386993, upload-time = "2025-11-01T11:54:04.12Z" },
-    { url = "https://files.pythonhosted.org/packages/83/86/5d72e2c060aa1fbdc1f7362d938f6b237dff91f5b9fc5dd7cc297e112250/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2dc37bc20272f388b8c3a4eba4febc6e77e50a8f450c472def4751e7678f55e4", size = 1379126, upload-time = "2025-11-01T11:54:05.777Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/bc/ef2cee3e4d8b3fc22705ff519f0d487eecc756abdc7c25d53686689d6cf2/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dee362e7e79bae940a5e2b3f6d09c6554db6a4e301cc68343886c08be99844f1", size = 3159304, upload-time = "2025-11-01T11:54:07.351Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/36/dc5f2f62bbc7bc90be1f75eeaf49ed9502094bb19290dfb4747317b17f12/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:4b39921df948388a863f0e267edf2c36302983459b021ab928d4b801cbe6a421", size = 1218207, upload-time = "2025-11-01T11:54:09.641Z" },
-    { url = "https://files.pythonhosted.org/packages/df/7e/8f4be75c1bc62f47edf2bbbe2370ee482fae655ebcc4718ac3827ead3904/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:beda6aa9bc44d1d81242e7b291b446be352d3451f8217fcb068fc2933927d53b", size = 2401245, upload-time = "2025-11-01T11:54:11.543Z" },
-    { url = "https://files.pythonhosted.org/packages/05/38/f7c92759e1bb188dd05b80d11c630ba59b8d7856657baf454ff56059c2ab/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:6a014ba09657abfcfeed64b7d09407acb29af436d7fc075b23a298a7e4a6b41c", size = 2518308, upload-time = "2025-11-01T11:54:13.134Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/ac/85820f70fed5ecb5f1d9a55f1e1e2090ef62985ef41db289b5ac5ec56e28/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:32eeafa3abce138bb725550c0e228fc7eaeec7059aa8093d9cbbec2b58c2371a", size = 4265011, upload-time = "2025-11-01T11:54:15.087Z" },
-    { url = "https://files.pythonhosted.org/packages/46/a9/616930721ea9835c918af7cde22bff17f9db3639b0c1a7f96684be7f5630/rapidfuzz-3.14.3-cp314-cp314-win32.whl", hash = "sha256:adb44d996fc610c7da8c5048775b21db60dd63b1548f078e95858c05c86876a3", size = 1742245, upload-time = "2025-11-01T11:54:17.19Z" },
-    { url = "https://files.pythonhosted.org/packages/06/8a/f2fa5e9635b1ccafda4accf0e38246003f69982d7c81f2faa150014525a4/rapidfuzz-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:f3d15d8527e2b293e38ce6e437631af0708df29eafd7c9fc48210854c94472f9", size = 1584856, upload-time = "2025-11-01T11:54:18.764Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/97/09e20663917678a6d60d8e0e29796db175b1165e2079830430342d5298be/rapidfuzz-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:576e4b9012a67e0bf54fccb69a7b6c94d4e86a9540a62f1a5144977359133583", size = 833490, upload-time = "2025-11-01T11:54:20.753Z" },
-    { url = "https://files.pythonhosted.org/packages/03/1b/6b6084576ba87bf21877c77218a0c97ba98cb285b0c02eaaee3acd7c4513/rapidfuzz-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:cec3c0da88562727dd5a5a364bd9efeb535400ff0bfb1443156dd139a1dd7b50", size = 1968658, upload-time = "2025-11-01T11:54:22.25Z" },
-    { url = "https://files.pythonhosted.org/packages/38/c0/fb02a0db80d95704b0a6469cc394e8c38501abf7e1c0b2afe3261d1510c2/rapidfuzz-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d1fa009f8b1100e4880868137e7bf0501422898f7674f2adcd85d5a67f041296", size = 1410742, upload-time = "2025-11-01T11:54:23.863Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/72/3fbf12819fc6afc8ec75a45204013b40979d068971e535a7f3512b05e765/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b86daa7419b5e8b180690efd1fdbac43ff19230803282521c5b5a9c83977655", size = 1382810, upload-time = "2025-11-01T11:54:25.571Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/18/0f1991d59bb7eee28922a00f79d83eafa8c7bfb4e8edebf4af2a160e7196/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7bd1816db05d6c5ffb3a4df0a2b7b56fb8c81ef584d08e37058afa217da91b1", size = 3166349, upload-time = "2025-11-01T11:54:27.195Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/f0/baa958b1989c8f88c78bbb329e969440cf330b5a01a982669986495bb980/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:33da4bbaf44e9755b0ce192597f3bde7372fe2e381ab305f41b707a95ac57aa7", size = 1214994, upload-time = "2025-11-01T11:54:28.821Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/a0/cd12ec71f9b2519a3954febc5740291cceabc64c87bc6433afcb36259f3b/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3fecce764cf5a991ee2195a844196da840aba72029b2612f95ac68a8b74946bf", size = 2403919, upload-time = "2025-11-01T11:54:30.393Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/ce/019bd2176c1644098eced4f0595cb4b3ef52e4941ac9a5854f209d0a6e16/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:ecd7453e02cf072258c3a6b8e930230d789d5d46cc849503729f9ce475d0e785", size = 2508346, upload-time = "2025-11-01T11:54:32.048Z" },
-    { url = "https://files.pythonhosted.org/packages/23/f8/be16c68e2c9e6c4f23e8f4adbb7bccc9483200087ed28ff76c5312da9b14/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea188aa00e9bcae8c8411f006a5f2f06c4607a02f24eab0d8dc58566aa911f35", size = 4274105, upload-time = "2025-11-01T11:54:33.701Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/d1/5ab148e03f7e6ec8cd220ccf7af74d3aaa4de26dd96df58936beb7cba820/rapidfuzz-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:7ccbf68100c170e9a0581accbe9291850936711548c6688ce3bfb897b8c589ad", size = 1793465, upload-time = "2025-11-01T11:54:35.331Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/97/433b2d98e97abd9fff1c470a109b311669f44cdec8d0d5aa250aceaed1fb/rapidfuzz-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:9ec02e62ae765a318d6de38df609c57fc6dacc65c0ed1fd489036834fd8a620c", size = 1623491, upload-time = "2025-11-01T11:54:38.085Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/f6/e2176eb94f94892441bce3ddc514c179facb65db245e7ce3356965595b19/rapidfuzz-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:e805e52322ae29aa945baf7168b6c898120fbc16d2b8f940b658a5e9e3999253", size = 851487, upload-time = "2025-11-01T11:54:40.176Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/8e/3c215e860b458cfbedb3ed73bc72e98eb7e0ed72f6b48099604a7a3260c2/rapidfuzz-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:685c93ea961d135893b5984a5a9851637d23767feabe414ec974f43babbd8226", size = 1945306 },
+    { url = "https://files.pythonhosted.org/packages/36/d9/31b33512015c899f4a6e6af64df8dfe8acddf4c8b40a4b3e0e6e1bcd00e5/rapidfuzz-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fa7c8f26f009f8c673fbfb443792f0cf8cf50c4e18121ff1e285b5e08a94fbdb", size = 1390788 },
+    { url = "https://files.pythonhosted.org/packages/a9/67/2ee6f8de6e2081ccd560a571d9c9063184fe467f484a17fa90311a7f4a2e/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:57f878330c8d361b2ce76cebb8e3e1dc827293b6abf404e67d53260d27b5d941", size = 1374580 },
+    { url = "https://files.pythonhosted.org/packages/30/83/80d22997acd928eda7deadc19ccd15883904622396d6571e935993e0453a/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c5f545f454871e6af05753a0172849c82feaf0f521c5ca62ba09e1b382d6382", size = 3154947 },
+    { url = "https://files.pythonhosted.org/packages/5b/cf/9f49831085a16384695f9fb096b99662f589e30b89b4a589a1ebc1a19d34/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:07aa0b5d8863e3151e05026a28e0d924accf0a7a3b605da978f0359bb804df43", size = 1223872 },
+    { url = "https://files.pythonhosted.org/packages/c8/0f/41ee8034e744b871c2e071ef0d360686f5ccfe5659f4fd96c3ec406b3c8b/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73b07566bc7e010e7b5bd490fb04bb312e820970180df6b5655e9e6224c137db", size = 2392512 },
+    { url = "https://files.pythonhosted.org/packages/da/86/280038b6b0c2ccec54fb957c732ad6b41cc1fd03b288d76545b9cf98343f/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6de00eb84c71476af7d3110cf25d8fe7c792d7f5fa86764ef0b4ca97e78ca3ed", size = 2521398 },
+    { url = "https://files.pythonhosted.org/packages/fa/7b/05c26f939607dca0006505e3216248ae2de631e39ef94dd63dbbf0860021/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d7843a1abf0091773a530636fdd2a49a41bcae22f9910b86b4f903e76ddc82dc", size = 4259416 },
+    { url = "https://files.pythonhosted.org/packages/40/eb/9e3af4103d91788f81111af1b54a28de347cdbed8eaa6c91d5e98a889aab/rapidfuzz-3.14.3-cp312-cp312-win32.whl", hash = "sha256:dea97ac3ca18cd3ba8f3d04b5c1fe4aa60e58e8d9b7793d3bd595fdb04128d7a", size = 1709527 },
+    { url = "https://files.pythonhosted.org/packages/b8/63/d06ecce90e2cf1747e29aeab9f823d21e5877a4c51b79720b2d3be7848f8/rapidfuzz-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:b5100fd6bcee4d27f28f4e0a1c6b5127bc8ba7c2a9959cad9eab0bf4a7ab3329", size = 1538989 },
+    { url = "https://files.pythonhosted.org/packages/fc/6d/beee32dcda64af8128aab3ace2ccb33d797ed58c434c6419eea015fec779/rapidfuzz-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:4e49c9e992bc5fc873bd0fff7ef16a4405130ec42f2ce3d2b735ba5d3d4eb70f", size = 811161 },
+    { url = "https://files.pythonhosted.org/packages/e4/4f/0d94d09646853bd26978cb3a7541b6233c5760687777fa97da8de0d9a6ac/rapidfuzz-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dbcb726064b12f356bf10fffdb6db4b6dce5390b23627c08652b3f6e49aa56ae", size = 1939646 },
+    { url = "https://files.pythonhosted.org/packages/b6/eb/f96aefc00f3bbdbab9c0657363ea8437a207d7545ac1c3789673e05d80bd/rapidfuzz-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1704fc70d214294e554a2421b473779bcdeef715881c5e927dc0f11e1692a0ff", size = 1385512 },
+    { url = "https://files.pythonhosted.org/packages/26/34/71c4f7749c12ee223dba90017a5947e8f03731a7cc9f489b662a8e9e643d/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc65e72790ddfd310c2c8912b45106e3800fefe160b0c2ef4d6b6fec4e826457", size = 1373571 },
+    { url = "https://files.pythonhosted.org/packages/32/00/ec8597a64f2be301ce1ee3290d067f49f6a7afb226b67d5f15b56d772ba5/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43e38c1305cffae8472572a0584d4ffc2f130865586a81038ca3965301f7c97c", size = 3156759 },
+    { url = "https://files.pythonhosted.org/packages/61/d5/b41eeb4930501cc899d5a9a7b5c9a33d85a670200d7e81658626dcc0ecc0/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:e195a77d06c03c98b3fc06b8a28576ba824392ce40de8c708f96ce04849a052e", size = 1222067 },
+    { url = "https://files.pythonhosted.org/packages/2a/7d/6d9abb4ffd1027c6ed837b425834f3bed8344472eb3a503ab55b3407c721/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1b7ef2f4b8583a744338a18f12c69693c194fb6777c0e9ada98cd4d9e8f09d10", size = 2394775 },
+    { url = "https://files.pythonhosted.org/packages/15/ce/4f3ab4c401c5a55364da1ffff8cc879fc97b4e5f4fa96033827da491a973/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:a2135b138bcdcb4c3742d417f215ac2d8c2b87bde15b0feede231ae95f09ec41", size = 2526123 },
+    { url = "https://files.pythonhosted.org/packages/c1/4b/54f804975376a328f57293bd817c12c9036171d15cf7292032e3f5820b2d/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:33a325ed0e8e1aa20c3e75f8ab057a7b248fdea7843c2a19ade0008906c14af0", size = 4262874 },
+    { url = "https://files.pythonhosted.org/packages/e9/b6/958db27d8a29a50ee6edd45d33debd3ce732e7209183a72f57544cd5fe22/rapidfuzz-3.14.3-cp313-cp313-win32.whl", hash = "sha256:8383b6d0d92f6cd008f3c9216535be215a064b2cc890398a678b56e6d280cb63", size = 1707972 },
+    { url = "https://files.pythonhosted.org/packages/07/75/fde1f334b0cec15b5946d9f84d73250fbfcc73c236b4bc1b25129d90876b/rapidfuzz-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:e6b5e3036976f0fde888687d91be86d81f9ac5f7b02e218913c38285b756be6c", size = 1537011 },
+    { url = "https://files.pythonhosted.org/packages/2e/d7/d83fe001ce599dc7ead57ba1debf923dc961b6bdce522b741e6b8c82f55c/rapidfuzz-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:7ba009977601d8b0828bfac9a110b195b3e4e79b350dcfa48c11269a9f1918a0", size = 810744 },
+    { url = "https://files.pythonhosted.org/packages/92/13/a486369e63ff3c1a58444d16b15c5feb943edd0e6c28a1d7d67cb8946b8f/rapidfuzz-3.14.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a0a28add871425c2fe94358c6300bbeb0bc2ed828ca003420ac6825408f5a424", size = 1967702 },
+    { url = "https://files.pythonhosted.org/packages/f1/82/efad25e260b7810f01d6b69122685e355bed78c94a12784bac4e0beb2afb/rapidfuzz-3.14.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:010e12e2411a4854b0434f920e72b717c43f8ec48d57e7affe5c42ecfa05dd0e", size = 1410702 },
+    { url = "https://files.pythonhosted.org/packages/ba/1a/34c977b860cde91082eae4a97ae503f43e0d84d4af301d857679b66f9869/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cfc3d57abd83c734d1714ec39c88a34dd69c85474918ebc21296f1e61eb5ca8", size = 1382337 },
+    { url = "https://files.pythonhosted.org/packages/88/74/f50ea0e24a5880a9159e8fd256b84d8f4634c2f6b4f98028bdd31891d907/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89acb8cbb52904f763e5ac238083b9fc193bed8d1f03c80568b20e4cef43a519", size = 3165563 },
+    { url = "https://files.pythonhosted.org/packages/e8/7a/e744359404d7737049c26099423fc54bcbf303de5d870d07d2fb1410f567/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_31_armv7l.whl", hash = "sha256:7d9af908c2f371bfb9c985bd134e295038e3031e666e4b2ade1e7cb7f5af2f1a", size = 1214727 },
+    { url = "https://files.pythonhosted.org/packages/d3/2e/87adfe14ce75768ec6c2b8acd0e05e85e84be4be5e3d283cdae360afc4fe/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1f1925619627f8798f8c3a391d81071336942e5fe8467bc3c567f982e7ce2897", size = 2403349 },
+    { url = "https://files.pythonhosted.org/packages/70/17/6c0b2b2bff9c8b12e12624c07aa22e922b0c72a490f180fa9183d1ef2c75/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:152555187360978119e98ce3e8263d70dd0c40c7541193fc302e9b7125cf8f58", size = 2507596 },
+    { url = "https://files.pythonhosted.org/packages/c3/d1/87852a7cbe4da7b962174c749a47433881a63a817d04f3e385ea9babcd9e/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:52619d25a09546b8db078981ca88939d72caa6b8701edd8b22e16482a38e799f", size = 4273595 },
+    { url = "https://files.pythonhosted.org/packages/c1/ab/1d0354b7d1771a28fa7fe089bc23acec2bdd3756efa2419f463e3ed80e16/rapidfuzz-3.14.3-cp313-cp313t-win32.whl", hash = "sha256:489ce98a895c98cad284f0a47960c3e264c724cb4cfd47a1430fa091c0c25204", size = 1757773 },
+    { url = "https://files.pythonhosted.org/packages/0b/0c/71ef356adc29e2bdf74cd284317b34a16b80258fa0e7e242dd92cc1e6d10/rapidfuzz-3.14.3-cp313-cp313t-win_amd64.whl", hash = "sha256:656e52b054d5b5c2524169240e50cfa080b04b1c613c5f90a2465e84888d6f15", size = 1576797 },
+    { url = "https://files.pythonhosted.org/packages/fe/d2/0e64fc27bb08d4304aa3d11154eb5480bcf5d62d60140a7ee984dc07468a/rapidfuzz-3.14.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c7e40c0a0af02ad6e57e89f62bef8604f55a04ecae90b0ceeda591bbf5923317", size = 829940 },
+    { url = "https://files.pythonhosted.org/packages/32/6f/1b88aaeade83abc5418788f9e6b01efefcd1a69d65ded37d89cd1662be41/rapidfuzz-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:442125473b247227d3f2de807a11da6c08ccf536572d1be943f8e262bae7e4ea", size = 1942086 },
+    { url = "https://files.pythonhosted.org/packages/a0/2c/b23861347436cb10f46c2bd425489ec462790faaa360a54a7ede5f78de88/rapidfuzz-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ec0c8c0c3d4f97ced46b2e191e883f8c82dbbf6d5ebc1842366d7eff13cd5a6", size = 1386993 },
+    { url = "https://files.pythonhosted.org/packages/83/86/5d72e2c060aa1fbdc1f7362d938f6b237dff91f5b9fc5dd7cc297e112250/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2dc37bc20272f388b8c3a4eba4febc6e77e50a8f450c472def4751e7678f55e4", size = 1379126 },
+    { url = "https://files.pythonhosted.org/packages/c9/bc/ef2cee3e4d8b3fc22705ff519f0d487eecc756abdc7c25d53686689d6cf2/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dee362e7e79bae940a5e2b3f6d09c6554db6a4e301cc68343886c08be99844f1", size = 3159304 },
+    { url = "https://files.pythonhosted.org/packages/a0/36/dc5f2f62bbc7bc90be1f75eeaf49ed9502094bb19290dfb4747317b17f12/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:4b39921df948388a863f0e267edf2c36302983459b021ab928d4b801cbe6a421", size = 1218207 },
+    { url = "https://files.pythonhosted.org/packages/df/7e/8f4be75c1bc62f47edf2bbbe2370ee482fae655ebcc4718ac3827ead3904/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:beda6aa9bc44d1d81242e7b291b446be352d3451f8217fcb068fc2933927d53b", size = 2401245 },
+    { url = "https://files.pythonhosted.org/packages/05/38/f7c92759e1bb188dd05b80d11c630ba59b8d7856657baf454ff56059c2ab/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:6a014ba09657abfcfeed64b7d09407acb29af436d7fc075b23a298a7e4a6b41c", size = 2518308 },
+    { url = "https://files.pythonhosted.org/packages/c7/ac/85820f70fed5ecb5f1d9a55f1e1e2090ef62985ef41db289b5ac5ec56e28/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:32eeafa3abce138bb725550c0e228fc7eaeec7059aa8093d9cbbec2b58c2371a", size = 4265011 },
+    { url = "https://files.pythonhosted.org/packages/46/a9/616930721ea9835c918af7cde22bff17f9db3639b0c1a7f96684be7f5630/rapidfuzz-3.14.3-cp314-cp314-win32.whl", hash = "sha256:adb44d996fc610c7da8c5048775b21db60dd63b1548f078e95858c05c86876a3", size = 1742245 },
+    { url = "https://files.pythonhosted.org/packages/06/8a/f2fa5e9635b1ccafda4accf0e38246003f69982d7c81f2faa150014525a4/rapidfuzz-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:f3d15d8527e2b293e38ce6e437631af0708df29eafd7c9fc48210854c94472f9", size = 1584856 },
+    { url = "https://files.pythonhosted.org/packages/ef/97/09e20663917678a6d60d8e0e29796db175b1165e2079830430342d5298be/rapidfuzz-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:576e4b9012a67e0bf54fccb69a7b6c94d4e86a9540a62f1a5144977359133583", size = 833490 },
+    { url = "https://files.pythonhosted.org/packages/03/1b/6b6084576ba87bf21877c77218a0c97ba98cb285b0c02eaaee3acd7c4513/rapidfuzz-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:cec3c0da88562727dd5a5a364bd9efeb535400ff0bfb1443156dd139a1dd7b50", size = 1968658 },
+    { url = "https://files.pythonhosted.org/packages/38/c0/fb02a0db80d95704b0a6469cc394e8c38501abf7e1c0b2afe3261d1510c2/rapidfuzz-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d1fa009f8b1100e4880868137e7bf0501422898f7674f2adcd85d5a67f041296", size = 1410742 },
+    { url = "https://files.pythonhosted.org/packages/a4/72/3fbf12819fc6afc8ec75a45204013b40979d068971e535a7f3512b05e765/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b86daa7419b5e8b180690efd1fdbac43ff19230803282521c5b5a9c83977655", size = 1382810 },
+    { url = "https://files.pythonhosted.org/packages/0f/18/0f1991d59bb7eee28922a00f79d83eafa8c7bfb4e8edebf4af2a160e7196/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7bd1816db05d6c5ffb3a4df0a2b7b56fb8c81ef584d08e37058afa217da91b1", size = 3166349 },
+    { url = "https://files.pythonhosted.org/packages/0d/f0/baa958b1989c8f88c78bbb329e969440cf330b5a01a982669986495bb980/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:33da4bbaf44e9755b0ce192597f3bde7372fe2e381ab305f41b707a95ac57aa7", size = 1214994 },
+    { url = "https://files.pythonhosted.org/packages/e4/a0/cd12ec71f9b2519a3954febc5740291cceabc64c87bc6433afcb36259f3b/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3fecce764cf5a991ee2195a844196da840aba72029b2612f95ac68a8b74946bf", size = 2403919 },
+    { url = "https://files.pythonhosted.org/packages/0b/ce/019bd2176c1644098eced4f0595cb4b3ef52e4941ac9a5854f209d0a6e16/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:ecd7453e02cf072258c3a6b8e930230d789d5d46cc849503729f9ce475d0e785", size = 2508346 },
+    { url = "https://files.pythonhosted.org/packages/23/f8/be16c68e2c9e6c4f23e8f4adbb7bccc9483200087ed28ff76c5312da9b14/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea188aa00e9bcae8c8411f006a5f2f06c4607a02f24eab0d8dc58566aa911f35", size = 4274105 },
+    { url = "https://files.pythonhosted.org/packages/a1/d1/5ab148e03f7e6ec8cd220ccf7af74d3aaa4de26dd96df58936beb7cba820/rapidfuzz-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:7ccbf68100c170e9a0581accbe9291850936711548c6688ce3bfb897b8c589ad", size = 1793465 },
+    { url = "https://files.pythonhosted.org/packages/cd/97/433b2d98e97abd9fff1c470a109b311669f44cdec8d0d5aa250aceaed1fb/rapidfuzz-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:9ec02e62ae765a318d6de38df609c57fc6dacc65c0ed1fd489036834fd8a620c", size = 1623491 },
+    { url = "https://files.pythonhosted.org/packages/e2/f6/e2176eb94f94892441bce3ddc514c179facb65db245e7ce3356965595b19/rapidfuzz-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:e805e52322ae29aa945baf7168b6c898120fbc16d2b8f940b658a5e9e3999253", size = 851487 },
 ]
 
 [[package]]
@@ -1008,34 +1144,59 @@ dependencies = [
     { name = "idna" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738 },
+]
+
+[[package]]
+name = "requests-toolbelt"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481 },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458 },
 ]
 
 [[package]]
 name = "ruff"
 version = "0.15.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/da/31/d6e536cdebb6568ae75a7f00e4b4819ae0ad2640c3604c305a0428680b0c/ruff-0.15.4.tar.gz", hash = "sha256:3412195319e42d634470cc97aa9803d07e9d5c9223b99bcb1518f0c725f26ae1", size = 4569550, upload-time = "2026-02-26T20:04:14.959Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/31/d6e536cdebb6568ae75a7f00e4b4819ae0ad2640c3604c305a0428680b0c/ruff-0.15.4.tar.gz", hash = "sha256:3412195319e42d634470cc97aa9803d07e9d5c9223b99bcb1518f0c725f26ae1", size = 4569550 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f2/82/c11a03cfec3a4d26a0ea1e571f0f44be5993b923f905eeddfc397c13d360/ruff-0.15.4-py3-none-linux_armv6l.whl", hash = "sha256:a1810931c41606c686bae8b5b9a8072adac2f611bb433c0ba476acba17a332e0", size = 10453333, upload-time = "2026-02-26T20:04:20.093Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/5d/6a1f271f6e31dffb31855996493641edc3eef8077b883eaf007a2f1c2976/ruff-0.15.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5a1632c66672b8b4d3e1d1782859e98d6e0b4e70829530666644286600a33992", size = 10853356, upload-time = "2026-02-26T20:04:05.808Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/d8/0fab9f8842b83b1a9c2bf81b85063f65e93fb512e60effa95b0be49bfc54/ruff-0.15.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a4386ba2cd6c0f4ff75252845906acc7c7c8e1ac567b7bc3d373686ac8c222ba", size = 10187434, upload-time = "2026-02-26T20:03:54.656Z" },
-    { url = "https://files.pythonhosted.org/packages/85/cc/cc220fd9394eff5db8d94dec199eec56dd6c9f3651d8869d024867a91030/ruff-0.15.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2496488bdfd3732747558b6f95ae427ff066d1fcd054daf75f5a50674411e75", size = 10535456, upload-time = "2026-02-26T20:03:52.738Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/0f/bced38fa5cf24373ec767713c8e4cadc90247f3863605fb030e597878661/ruff-0.15.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3f1c4893841ff2d54cbda1b2860fa3260173df5ddd7b95d370186f8a5e66a4ac", size = 10287772, upload-time = "2026-02-26T20:04:08.138Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/90/58a1802d84fed15f8f281925b21ab3cecd813bde52a8ca033a4de8ab0e7a/ruff-0.15.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:820b8766bd65503b6c30aaa6331e8ef3a6e564f7999c844e9a547c40179e440a", size = 11049051, upload-time = "2026-02-26T20:04:03.53Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/ac/b7ad36703c35f3866584564dc15f12f91cb1a26a897dc2fd13d7cb3ae1af/ruff-0.15.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9fb74bab47139c1751f900f857fa503987253c3ef89129b24ed375e72873e85", size = 11890494, upload-time = "2026-02-26T20:04:10.497Z" },
-    { url = "https://files.pythonhosted.org/packages/93/3d/3eb2f47a39a8b0da99faf9c54d3eb24720add1e886a5309d4d1be73a6380/ruff-0.15.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f80c98765949c518142b3a50a5db89343aa90f2c2bf7799de9986498ae6176db", size = 11326221, upload-time = "2026-02-26T20:04:12.84Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/90/bf134f4c1e5243e62690e09d63c55df948a74084c8ac3e48a88468314da6/ruff-0.15.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:451a2e224151729b3b6c9ffb36aed9091b2996fe4bdbd11f47e27d8f2e8888ec", size = 11168459, upload-time = "2026-02-26T20:04:00.969Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/e5/a64d27688789b06b5d55162aafc32059bb8c989c61a5139a36e1368285eb/ruff-0.15.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a8f157f2e583c513c4f5f896163a93198297371f34c04220daf40d133fdd4f7f", size = 11104366, upload-time = "2026-02-26T20:03:48.099Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/f6/32d1dcb66a2559763fc3027bdd65836cad9eb09d90f2ed6a63d8e9252b02/ruff-0.15.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:917cc68503357021f541e69b35361c99387cdbbf99bd0ea4aa6f28ca99ff5338", size = 10510887, upload-time = "2026-02-26T20:03:45.771Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/92/22d1ced50971c5b6433aed166fcef8c9343f567a94cf2b9d9089f6aa80fe/ruff-0.15.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e9737c8161da79fd7cfec19f1e35620375bd8b2a50c3e77fa3d2c16f574105cc", size = 10285939, upload-time = "2026-02-26T20:04:22.42Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/f4/7c20aec3143837641a02509a4668fb146a642fd1211846634edc17eb5563/ruff-0.15.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:291258c917539e18f6ba40482fe31d6f5ac023994ee11d7bdafd716f2aab8a68", size = 10765471, upload-time = "2026-02-26T20:03:58.924Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/09/6d2f7586f09a16120aebdff8f64d962d7c4348313c77ebb29c566cefc357/ruff-0.15.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3f83c45911da6f2cd5936c436cf86b9f09f09165f033a99dcf7477e34041cbc3", size = 11263382, upload-time = "2026-02-26T20:04:24.424Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/fa/2ef715a1cd329ef47c1a050e10dee91a9054b7ce2fcfdd6a06d139afb7ec/ruff-0.15.4-py3-none-win32.whl", hash = "sha256:65594a2d557d4ee9f02834fcdf0a28daa8b3b9f6cb2cb93846025a36db47ef22", size = 10506664, upload-time = "2026-02-26T20:03:50.56Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/a8/c688ef7e29983976820d18710f955751d9f4d4eb69df658af3d006e2ba3e/ruff-0.15.4-py3-none-win_amd64.whl", hash = "sha256:04196ad44f0df220c2ece5b0e959c2f37c777375ec744397d21d15b50a75264f", size = 11651048, upload-time = "2026-02-26T20:04:17.191Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/0a/9e1be9035b37448ce2e68c978f0591da94389ade5a5abafa4cf99985d1b2/ruff-0.15.4-py3-none-win_arm64.whl", hash = "sha256:60d5177e8cfc70e51b9c5fad936c634872a74209f934c1e79107d11787ad5453", size = 10966776, upload-time = "2026-02-26T20:03:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/82/c11a03cfec3a4d26a0ea1e571f0f44be5993b923f905eeddfc397c13d360/ruff-0.15.4-py3-none-linux_armv6l.whl", hash = "sha256:a1810931c41606c686bae8b5b9a8072adac2f611bb433c0ba476acba17a332e0", size = 10453333 },
+    { url = "https://files.pythonhosted.org/packages/ce/5d/6a1f271f6e31dffb31855996493641edc3eef8077b883eaf007a2f1c2976/ruff-0.15.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5a1632c66672b8b4d3e1d1782859e98d6e0b4e70829530666644286600a33992", size = 10853356 },
+    { url = "https://files.pythonhosted.org/packages/b1/d8/0fab9f8842b83b1a9c2bf81b85063f65e93fb512e60effa95b0be49bfc54/ruff-0.15.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a4386ba2cd6c0f4ff75252845906acc7c7c8e1ac567b7bc3d373686ac8c222ba", size = 10187434 },
+    { url = "https://files.pythonhosted.org/packages/85/cc/cc220fd9394eff5db8d94dec199eec56dd6c9f3651d8869d024867a91030/ruff-0.15.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2496488bdfd3732747558b6f95ae427ff066d1fcd054daf75f5a50674411e75", size = 10535456 },
+    { url = "https://files.pythonhosted.org/packages/fa/0f/bced38fa5cf24373ec767713c8e4cadc90247f3863605fb030e597878661/ruff-0.15.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3f1c4893841ff2d54cbda1b2860fa3260173df5ddd7b95d370186f8a5e66a4ac", size = 10287772 },
+    { url = "https://files.pythonhosted.org/packages/2b/90/58a1802d84fed15f8f281925b21ab3cecd813bde52a8ca033a4de8ab0e7a/ruff-0.15.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:820b8766bd65503b6c30aaa6331e8ef3a6e564f7999c844e9a547c40179e440a", size = 11049051 },
+    { url = "https://files.pythonhosted.org/packages/d2/ac/b7ad36703c35f3866584564dc15f12f91cb1a26a897dc2fd13d7cb3ae1af/ruff-0.15.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9fb74bab47139c1751f900f857fa503987253c3ef89129b24ed375e72873e85", size = 11890494 },
+    { url = "https://files.pythonhosted.org/packages/93/3d/3eb2f47a39a8b0da99faf9c54d3eb24720add1e886a5309d4d1be73a6380/ruff-0.15.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f80c98765949c518142b3a50a5db89343aa90f2c2bf7799de9986498ae6176db", size = 11326221 },
+    { url = "https://files.pythonhosted.org/packages/ff/90/bf134f4c1e5243e62690e09d63c55df948a74084c8ac3e48a88468314da6/ruff-0.15.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:451a2e224151729b3b6c9ffb36aed9091b2996fe4bdbd11f47e27d8f2e8888ec", size = 11168459 },
+    { url = "https://files.pythonhosted.org/packages/b5/e5/a64d27688789b06b5d55162aafc32059bb8c989c61a5139a36e1368285eb/ruff-0.15.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a8f157f2e583c513c4f5f896163a93198297371f34c04220daf40d133fdd4f7f", size = 11104366 },
+    { url = "https://files.pythonhosted.org/packages/f1/f6/32d1dcb66a2559763fc3027bdd65836cad9eb09d90f2ed6a63d8e9252b02/ruff-0.15.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:917cc68503357021f541e69b35361c99387cdbbf99bd0ea4aa6f28ca99ff5338", size = 10510887 },
+    { url = "https://files.pythonhosted.org/packages/ff/92/22d1ced50971c5b6433aed166fcef8c9343f567a94cf2b9d9089f6aa80fe/ruff-0.15.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e9737c8161da79fd7cfec19f1e35620375bd8b2a50c3e77fa3d2c16f574105cc", size = 10285939 },
+    { url = "https://files.pythonhosted.org/packages/e6/f4/7c20aec3143837641a02509a4668fb146a642fd1211846634edc17eb5563/ruff-0.15.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:291258c917539e18f6ba40482fe31d6f5ac023994ee11d7bdafd716f2aab8a68", size = 10765471 },
+    { url = "https://files.pythonhosted.org/packages/d0/09/6d2f7586f09a16120aebdff8f64d962d7c4348313c77ebb29c566cefc357/ruff-0.15.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3f83c45911da6f2cd5936c436cf86b9f09f09165f033a99dcf7477e34041cbc3", size = 11263382 },
+    { url = "https://files.pythonhosted.org/packages/1b/fa/2ef715a1cd329ef47c1a050e10dee91a9054b7ce2fcfdd6a06d139afb7ec/ruff-0.15.4-py3-none-win32.whl", hash = "sha256:65594a2d557d4ee9f02834fcdf0a28daa8b3b9f6cb2cb93846025a36db47ef22", size = 10506664 },
+    { url = "https://files.pythonhosted.org/packages/d0/a8/c688ef7e29983976820d18710f955751d9f4d4eb69df658af3d006e2ba3e/ruff-0.15.4-py3-none-win_amd64.whl", hash = "sha256:04196ad44f0df220c2ece5b0e959c2f37c777375ec744397d21d15b50a75264f", size = 11651048 },
+    { url = "https://files.pythonhosted.org/packages/3e/0a/9e1be9035b37448ce2e68c978f0591da94389ade5a5abafa4cf99985d1b2/ruff-0.15.4-py3-none-win_arm64.whl", hash = "sha256:60d5177e8cfc70e51b9c5fad936c634872a74209f934c1e79107d11787ad5453", size = 10966776 },
 ]
 
 [[package]]
@@ -1062,6 +1223,7 @@ dev = [
     { name = "mypy" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
+    { name = "python-semantic-release" },
     { name = "ruff" },
 ]
 
@@ -1078,6 +1240,7 @@ requires-dist = [
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.3,<9.0" },
     { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.25,<0.26" },
     { name = "python-multipart", specifier = ">=0.0.9,<0.1" },
+    { name = "python-semantic-release", marker = "extra == 'dev'", specifier = ">=9.0,<10.0" },
     { name = "rapidfuzz", specifier = ">=3.14.3" },
     { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.9" },
     { name = "sqlalchemy", specifier = ">=2.0,<2.1" },
@@ -1086,6 +1249,24 @@ requires-dist = [
 ]
 provides-extras = ["dev"]
 
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755 },
+]
+
+[[package]]
+name = "smmap"
+version = "5.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/44/cd/a040c4b3119bbe532e5b0732286f805445375489fceaec1f48306068ee3b/smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5", size = 22329 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/be/d09147ad1ec7934636ad912901c5fd7667e1c858e19d355237db0d0cd5e4/smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e", size = 24303 },
+]
+
 [[package]]
 name = "sqlalchemy"
 version = "2.0.46"
@@ -1094,38 +1275,38 @@ dependencies = [
     { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/06/aa/9ce0f3e7a9829ead5c8ce549392f33a12c4555a6c0609bb27d882e9c7ddf/sqlalchemy-2.0.46.tar.gz", hash = "sha256:cf36851ee7219c170bb0793dbc3da3e80c582e04a5437bc601bfe8c85c9216d7", size = 9865393, upload-time = "2026-01-21T18:03:45.119Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/aa/9ce0f3e7a9829ead5c8ce549392f33a12c4555a6c0609bb27d882e9c7ddf/sqlalchemy-2.0.46.tar.gz", hash = "sha256:cf36851ee7219c170bb0793dbc3da3e80c582e04a5437bc601bfe8c85c9216d7", size = 9865393 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b6/35/d16bfa235c8b7caba3730bba43e20b1e376d2224f407c178fbf59559f23e/sqlalchemy-2.0.46-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a9a72b0da8387f15d5810f1facca8f879de9b85af8c645138cba61ea147968c", size = 2153405, upload-time = "2026-01-21T19:05:54.143Z" },
-    { url = "https://files.pythonhosted.org/packages/06/6c/3192e24486749862f495ddc6584ed730c0c994a67550ec395d872a2ad650/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2347c3f0efc4de367ba00218e0ae5c4ba2306e47216ef80d6e31761ac97cb0b9", size = 3334702, upload-time = "2026-01-21T18:46:45.384Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/a2/b9f33c8d68a3747d972a0bb758c6b63691f8fb8a49014bc3379ba15d4274/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9094c8b3197db12aa6f05c51c05daaad0a92b8c9af5388569847b03b1007fb1b", size = 3347664, upload-time = "2026-01-21T18:40:09.979Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/d2/3e59e2a91eaec9db7e8dc6b37b91489b5caeb054f670f32c95bcba98940f/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37fee2164cf21417478b6a906adc1a91d69ae9aba8f9533e67ce882f4bb1de53", size = 3277372, upload-time = "2026-01-21T18:46:47.168Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/dd/67bc2e368b524e2192c3927b423798deda72c003e73a1e94c21e74b20a85/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b1e14b2f6965a685c7128bd315e27387205429c2e339eeec55cb75ca4ab0ea2e", size = 3312425, upload-time = "2026-01-21T18:40:11.548Z" },
-    { url = "https://files.pythonhosted.org/packages/43/82/0ecd68e172bfe62247e96cb47867c2d68752566811a4e8c9d8f6e7c38a65/sqlalchemy-2.0.46-cp312-cp312-win32.whl", hash = "sha256:412f26bb4ba942d52016edc8d12fb15d91d3cd46b0047ba46e424213ad407bcb", size = 2113155, upload-time = "2026-01-21T18:42:49.748Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/2a/2821a45742073fc0331dc132552b30de68ba9563230853437cac54b2b53e/sqlalchemy-2.0.46-cp312-cp312-win_amd64.whl", hash = "sha256:ea3cd46b6713a10216323cda3333514944e510aa691c945334713fca6b5279ff", size = 2140078, upload-time = "2026-01-21T18:42:51.197Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/4b/fa7838fe20bb752810feed60e45625a9a8b0102c0c09971e2d1d95362992/sqlalchemy-2.0.46-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:93a12da97cca70cea10d4b4fc602589c4511f96c1f8f6c11817620c021d21d00", size = 2150268, upload-time = "2026-01-21T19:05:56.621Z" },
-    { url = "https://files.pythonhosted.org/packages/46/c1/b34dccd712e8ea846edf396e00973dda82d598cb93762e55e43e6835eba9/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af865c18752d416798dae13f83f38927c52f085c52e2f32b8ab0fef46fdd02c2", size = 3276511, upload-time = "2026-01-21T18:46:49.022Z" },
-    { url = "https://files.pythonhosted.org/packages/96/48/a04d9c94753e5d5d096c628c82a98c4793b9c08ca0e7155c3eb7d7db9f24/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d679b5f318423eacb61f933a9a0f75535bfca7056daeadbf6bd5bcee6183aee", size = 3292881, upload-time = "2026-01-21T18:40:13.089Z" },
-    { url = "https://files.pythonhosted.org/packages/be/f4/06eda6e91476f90a7d8058f74311cb65a2fb68d988171aced81707189131/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64901e08c33462acc9ec3bad27fc7a5c2b6491665f2aa57564e57a4f5d7c52ad", size = 3224559, upload-time = "2026-01-21T18:46:50.974Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/a2/d2af04095412ca6345ac22b33b89fe8d6f32a481e613ffcb2377d931d8d0/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8ac45e8f4eaac0f9f8043ea0e224158855c6a4329fd4ee37c45c61e3beb518e", size = 3262728, upload-time = "2026-01-21T18:40:14.883Z" },
-    { url = "https://files.pythonhosted.org/packages/31/48/1980c7caa5978a3b8225b4d230e69a2a6538a3562b8b31cea679b6933c83/sqlalchemy-2.0.46-cp313-cp313-win32.whl", hash = "sha256:8d3b44b3d0ab2f1319d71d9863d76eeb46766f8cf9e921ac293511804d39813f", size = 2111295, upload-time = "2026-01-21T18:42:52.366Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/54/f8d65bbde3d877617c4720f3c9f60e99bb7266df0d5d78b6e25e7c149f35/sqlalchemy-2.0.46-cp313-cp313-win_amd64.whl", hash = "sha256:77f8071d8fbcbb2dd11b7fd40dedd04e8ebe2eb80497916efedba844298065ef", size = 2137076, upload-time = "2026-01-21T18:42:53.924Z" },
-    { url = "https://files.pythonhosted.org/packages/56/ba/9be4f97c7eb2b9d5544f2624adfc2853e796ed51d2bb8aec90bc94b7137e/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1e8cc6cc01da346dc92d9509a63033b9b1bda4fed7a7a7807ed385c7dccdc10", size = 3556533, upload-time = "2026-01-21T18:33:06.636Z" },
-    { url = "https://files.pythonhosted.org/packages/20/a6/b1fc6634564dbb4415b7ed6419cdfeaadefd2c39cdab1e3aa07a5f2474c2/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96c7cca1a4babaaf3bfff3e4e606e38578856917e52f0384635a95b226c87764", size = 3523208, upload-time = "2026-01-21T18:45:08.436Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/d8/41e0bdfc0f930ff236f86fccd12962d8fa03713f17ed57332d38af6a3782/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b2a9f9aee38039cf4755891a1e50e1effcc42ea6ba053743f452c372c3152b1b", size = 3464292, upload-time = "2026-01-21T18:33:08.208Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/8b/9dcbec62d95bea85f5ecad9b8d65b78cc30fb0ffceeb3597961f3712549b/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:db23b1bf8cfe1f7fda19018e7207b20cdb5168f83c437ff7e95d19e39289c447", size = 3473497, upload-time = "2026-01-21T18:45:10.552Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/f8/5ecdfc73383ec496de038ed1614de9e740a82db9ad67e6e4514ebc0708a3/sqlalchemy-2.0.46-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:56bdd261bfd0895452006d5316cbf35739c53b9bb71a170a331fa0ea560b2ada", size = 2152079, upload-time = "2026-01-21T19:05:58.477Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/bf/eba3036be7663ce4d9c050bc3d63794dc29fbe01691f2bf5ccb64e048d20/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33e462154edb9493f6c3ad2125931e273bbd0be8ae53f3ecd1c161ea9a1dd366", size = 3272216, upload-time = "2026-01-21T18:46:52.634Z" },
-    { url = "https://files.pythonhosted.org/packages/05/45/1256fb597bb83b58a01ddb600c59fe6fdf0e5afe333f0456ed75c0f8d7bd/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bcdce05f056622a632f1d44bb47dbdb677f58cad393612280406ce37530eb6d", size = 3277208, upload-time = "2026-01-21T18:40:16.38Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/a0/2053b39e4e63b5d7ceb3372cface0859a067c1ddbd575ea7e9985716f771/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e84b09a9b0f19accedcbeff5c2caf36e0dd537341a33aad8d680336152dc34e", size = 3221994, upload-time = "2026-01-21T18:46:54.622Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/87/97713497d9502553c68f105a1cb62786ba1ee91dea3852ae4067ed956a50/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4f52f7291a92381e9b4de9050b0a65ce5d6a763333406861e33906b8aa4906bf", size = 3243990, upload-time = "2026-01-21T18:40:18.253Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/87/5d1b23548f420ff823c236f8bea36b1a997250fd2f892e44a3838ca424f4/sqlalchemy-2.0.46-cp314-cp314-win32.whl", hash = "sha256:70ed2830b169a9960193f4d4322d22be5c0925357d82cbf485b3369893350908", size = 2114215, upload-time = "2026-01-21T18:42:55.232Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/20/555f39cbcf0c10cf452988b6a93c2a12495035f68b3dbd1a408531049d31/sqlalchemy-2.0.46-cp314-cp314-win_amd64.whl", hash = "sha256:3c32e993bc57be6d177f7d5d31edb93f30726d798ad86ff9066d75d9bf2e0b6b", size = 2139867, upload-time = "2026-01-21T18:42:56.474Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/f0/f96c8057c982d9d8a7a68f45d69c674bc6f78cad401099692fe16521640a/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4dafb537740eef640c4d6a7c254611dca2df87eaf6d14d6a5fca9d1f4c3fc0fa", size = 3561202, upload-time = "2026-01-21T18:33:10.337Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/53/3b37dda0a5b137f21ef608d8dfc77b08477bab0fe2ac9d3e0a66eaeab6fc/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42a1643dc5427b69aca967dae540a90b0fbf57eaf248f13a90ea5930e0966863", size = 3526296, upload-time = "2026-01-21T18:45:12.657Z" },
-    { url = "https://files.pythonhosted.org/packages/33/75/f28622ba6dde79cd545055ea7bd4062dc934e0621f7b3be2891f8563f8de/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ff33c6e6ad006bbc0f34f5faf941cfc62c45841c64c0a058ac38c799f15b5ede", size = 3470008, upload-time = "2026-01-21T18:33:11.725Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/42/4afecbbc38d5e99b18acef446453c76eec6fbd03db0a457a12a056836e22/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82ec52100ec1e6ec671563bbd02d7c7c8d0b9e71a0723c72f22ecf52d1755330", size = 3476137, upload-time = "2026-01-21T18:45:15.001Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/a1/9c4efa03300926601c19c18582531b45aededfb961ab3c3585f1e24f120b/sqlalchemy-2.0.46-py3-none-any.whl", hash = "sha256:f9c11766e7e7c0a2767dda5acb006a118640c9fc0a4104214b96269bfb78399e", size = 1937882, upload-time = "2026-01-21T18:22:10.456Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/35/d16bfa235c8b7caba3730bba43e20b1e376d2224f407c178fbf59559f23e/sqlalchemy-2.0.46-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a9a72b0da8387f15d5810f1facca8f879de9b85af8c645138cba61ea147968c", size = 2153405 },
+    { url = "https://files.pythonhosted.org/packages/06/6c/3192e24486749862f495ddc6584ed730c0c994a67550ec395d872a2ad650/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2347c3f0efc4de367ba00218e0ae5c4ba2306e47216ef80d6e31761ac97cb0b9", size = 3334702 },
+    { url = "https://files.pythonhosted.org/packages/ea/a2/b9f33c8d68a3747d972a0bb758c6b63691f8fb8a49014bc3379ba15d4274/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9094c8b3197db12aa6f05c51c05daaad0a92b8c9af5388569847b03b1007fb1b", size = 3347664 },
+    { url = "https://files.pythonhosted.org/packages/aa/d2/3e59e2a91eaec9db7e8dc6b37b91489b5caeb054f670f32c95bcba98940f/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37fee2164cf21417478b6a906adc1a91d69ae9aba8f9533e67ce882f4bb1de53", size = 3277372 },
+    { url = "https://files.pythonhosted.org/packages/dd/dd/67bc2e368b524e2192c3927b423798deda72c003e73a1e94c21e74b20a85/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b1e14b2f6965a685c7128bd315e27387205429c2e339eeec55cb75ca4ab0ea2e", size = 3312425 },
+    { url = "https://files.pythonhosted.org/packages/43/82/0ecd68e172bfe62247e96cb47867c2d68752566811a4e8c9d8f6e7c38a65/sqlalchemy-2.0.46-cp312-cp312-win32.whl", hash = "sha256:412f26bb4ba942d52016edc8d12fb15d91d3cd46b0047ba46e424213ad407bcb", size = 2113155 },
+    { url = "https://files.pythonhosted.org/packages/bc/2a/2821a45742073fc0331dc132552b30de68ba9563230853437cac54b2b53e/sqlalchemy-2.0.46-cp312-cp312-win_amd64.whl", hash = "sha256:ea3cd46b6713a10216323cda3333514944e510aa691c945334713fca6b5279ff", size = 2140078 },
+    { url = "https://files.pythonhosted.org/packages/b3/4b/fa7838fe20bb752810feed60e45625a9a8b0102c0c09971e2d1d95362992/sqlalchemy-2.0.46-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:93a12da97cca70cea10d4b4fc602589c4511f96c1f8f6c11817620c021d21d00", size = 2150268 },
+    { url = "https://files.pythonhosted.org/packages/46/c1/b34dccd712e8ea846edf396e00973dda82d598cb93762e55e43e6835eba9/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af865c18752d416798dae13f83f38927c52f085c52e2f32b8ab0fef46fdd02c2", size = 3276511 },
+    { url = "https://files.pythonhosted.org/packages/96/48/a04d9c94753e5d5d096c628c82a98c4793b9c08ca0e7155c3eb7d7db9f24/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d679b5f318423eacb61f933a9a0f75535bfca7056daeadbf6bd5bcee6183aee", size = 3292881 },
+    { url = "https://files.pythonhosted.org/packages/be/f4/06eda6e91476f90a7d8058f74311cb65a2fb68d988171aced81707189131/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64901e08c33462acc9ec3bad27fc7a5c2b6491665f2aa57564e57a4f5d7c52ad", size = 3224559 },
+    { url = "https://files.pythonhosted.org/packages/ab/a2/d2af04095412ca6345ac22b33b89fe8d6f32a481e613ffcb2377d931d8d0/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8ac45e8f4eaac0f9f8043ea0e224158855c6a4329fd4ee37c45c61e3beb518e", size = 3262728 },
+    { url = "https://files.pythonhosted.org/packages/31/48/1980c7caa5978a3b8225b4d230e69a2a6538a3562b8b31cea679b6933c83/sqlalchemy-2.0.46-cp313-cp313-win32.whl", hash = "sha256:8d3b44b3d0ab2f1319d71d9863d76eeb46766f8cf9e921ac293511804d39813f", size = 2111295 },
+    { url = "https://files.pythonhosted.org/packages/2d/54/f8d65bbde3d877617c4720f3c9f60e99bb7266df0d5d78b6e25e7c149f35/sqlalchemy-2.0.46-cp313-cp313-win_amd64.whl", hash = "sha256:77f8071d8fbcbb2dd11b7fd40dedd04e8ebe2eb80497916efedba844298065ef", size = 2137076 },
+    { url = "https://files.pythonhosted.org/packages/56/ba/9be4f97c7eb2b9d5544f2624adfc2853e796ed51d2bb8aec90bc94b7137e/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1e8cc6cc01da346dc92d9509a63033b9b1bda4fed7a7a7807ed385c7dccdc10", size = 3556533 },
+    { url = "https://files.pythonhosted.org/packages/20/a6/b1fc6634564dbb4415b7ed6419cdfeaadefd2c39cdab1e3aa07a5f2474c2/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96c7cca1a4babaaf3bfff3e4e606e38578856917e52f0384635a95b226c87764", size = 3523208 },
+    { url = "https://files.pythonhosted.org/packages/a1/d8/41e0bdfc0f930ff236f86fccd12962d8fa03713f17ed57332d38af6a3782/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b2a9f9aee38039cf4755891a1e50e1effcc42ea6ba053743f452c372c3152b1b", size = 3464292 },
+    { url = "https://files.pythonhosted.org/packages/f0/8b/9dcbec62d95bea85f5ecad9b8d65b78cc30fb0ffceeb3597961f3712549b/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:db23b1bf8cfe1f7fda19018e7207b20cdb5168f83c437ff7e95d19e39289c447", size = 3473497 },
+    { url = "https://files.pythonhosted.org/packages/e9/f8/5ecdfc73383ec496de038ed1614de9e740a82db9ad67e6e4514ebc0708a3/sqlalchemy-2.0.46-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:56bdd261bfd0895452006d5316cbf35739c53b9bb71a170a331fa0ea560b2ada", size = 2152079 },
+    { url = "https://files.pythonhosted.org/packages/e5/bf/eba3036be7663ce4d9c050bc3d63794dc29fbe01691f2bf5ccb64e048d20/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33e462154edb9493f6c3ad2125931e273bbd0be8ae53f3ecd1c161ea9a1dd366", size = 3272216 },
+    { url = "https://files.pythonhosted.org/packages/05/45/1256fb597bb83b58a01ddb600c59fe6fdf0e5afe333f0456ed75c0f8d7bd/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bcdce05f056622a632f1d44bb47dbdb677f58cad393612280406ce37530eb6d", size = 3277208 },
+    { url = "https://files.pythonhosted.org/packages/d9/a0/2053b39e4e63b5d7ceb3372cface0859a067c1ddbd575ea7e9985716f771/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e84b09a9b0f19accedcbeff5c2caf36e0dd537341a33aad8d680336152dc34e", size = 3221994 },
+    { url = "https://files.pythonhosted.org/packages/1e/87/97713497d9502553c68f105a1cb62786ba1ee91dea3852ae4067ed956a50/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4f52f7291a92381e9b4de9050b0a65ce5d6a763333406861e33906b8aa4906bf", size = 3243990 },
+    { url = "https://files.pythonhosted.org/packages/a8/87/5d1b23548f420ff823c236f8bea36b1a997250fd2f892e44a3838ca424f4/sqlalchemy-2.0.46-cp314-cp314-win32.whl", hash = "sha256:70ed2830b169a9960193f4d4322d22be5c0925357d82cbf485b3369893350908", size = 2114215 },
+    { url = "https://files.pythonhosted.org/packages/3a/20/555f39cbcf0c10cf452988b6a93c2a12495035f68b3dbd1a408531049d31/sqlalchemy-2.0.46-cp314-cp314-win_amd64.whl", hash = "sha256:3c32e993bc57be6d177f7d5d31edb93f30726d798ad86ff9066d75d9bf2e0b6b", size = 2139867 },
+    { url = "https://files.pythonhosted.org/packages/3e/f0/f96c8057c982d9d8a7a68f45d69c674bc6f78cad401099692fe16521640a/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4dafb537740eef640c4d6a7c254611dca2df87eaf6d14d6a5fca9d1f4c3fc0fa", size = 3561202 },
+    { url = "https://files.pythonhosted.org/packages/d7/53/3b37dda0a5b137f21ef608d8dfc77b08477bab0fe2ac9d3e0a66eaeab6fc/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42a1643dc5427b69aca967dae540a90b0fbf57eaf248f13a90ea5930e0966863", size = 3526296 },
+    { url = "https://files.pythonhosted.org/packages/33/75/f28622ba6dde79cd545055ea7bd4062dc934e0621f7b3be2891f8563f8de/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ff33c6e6ad006bbc0f34f5faf941cfc62c45841c64c0a058ac38c799f15b5ede", size = 3470008 },
+    { url = "https://files.pythonhosted.org/packages/a9/42/4afecbbc38d5e99b18acef446453c76eec6fbd03db0a457a12a056836e22/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82ec52100ec1e6ec671563bbd02d7c7c8d0b9e71a0723c72f22ecf52d1755330", size = 3476137 },
+    { url = "https://files.pythonhosted.org/packages/fc/a1/9c4efa03300926601c19c18582531b45aededfb961ab3c3585f1e24f120b/sqlalchemy-2.0.46-py3-none-any.whl", hash = "sha256:f9c11766e7e7c0a2767dda5acb006a118640c9fc0a4104214b96269bfb78399e", size = 1937882 },
 ]
 
 [[package]]
@@ -1137,9 +1318,9 @@ dependencies = [
     { name = "executing" },
     { name = "pure-eval" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521 },
 ]
 
 [[package]]
@@ -1150,36 +1331,45 @@ dependencies = [
     { name = "anyio" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a7/a5/d6f429d43394057b67a6b5bbe6eae2f77a6bf7459d961fdb224bf206eee6/starlette-0.48.0.tar.gz", hash = "sha256:7e8cee469a8ab2352911528110ce9088fdc6a37d9876926e73da7ce4aa4c7a46", size = 2652949, upload-time = "2025-09-13T08:41:05.699Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a7/a5/d6f429d43394057b67a6b5bbe6eae2f77a6bf7459d961fdb224bf206eee6/starlette-0.48.0.tar.gz", hash = "sha256:7e8cee469a8ab2352911528110ce9088fdc6a37d9876926e73da7ce4aa4c7a46", size = 2652949 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/72/2db2f49247d0a18b4f1bb9a5a39a0162869acf235f3a96418363947b3d46/starlette-0.48.0-py3-none-any.whl", hash = "sha256:0764ca97b097582558ecb498132ed0c7d942f233f365b86ba37770e026510659", size = 73736, upload-time = "2025-09-13T08:41:03.869Z" },
+    { url = "https://files.pythonhosted.org/packages/be/72/2db2f49247d0a18b4f1bb9a5a39a0162869acf235f3a96418363947b3d46/starlette-0.48.0-py3-none-any.whl", hash = "sha256:0764ca97b097582558ecb498132ed0c7d942f233f365b86ba37770e026510659", size = 73736 },
 ]
 
 [[package]]
 name = "tenacity"
 version = "9.1.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926 },
+]
+
+[[package]]
+name = "tomlkit"
+version = "0.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/af/14b24e41977adb296d6bd1fb59402cf7d60ce364f90c890bd2ec65c43b5a/tomlkit-0.14.0.tar.gz", hash = "sha256:cf00efca415dbd57575befb1f6634c4f42d2d87dbba376128adb42c121b87064", size = 187167 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/11/87d6d29fb5d237229d67973a6c9e06e048f01cf4994dee194ab0ea841814/tomlkit-0.14.0-py3-none-any.whl", hash = "sha256:592064ed85b40fa213469f81ac584f67a4f2992509a7c3ea2d632208623a3680", size = 39310 },
 ]
 
 [[package]]
 name = "traitlets"
 version = "5.14.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" },
+    { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 },
 ]
 
 [[package]]
 name = "typing-extensions"
 version = "4.15.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614 },
 ]
 
 [[package]]
@@ -1189,18 +1379,18 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611 },
 ]
 
 [[package]]
 name = "urllib3"
 version = "2.6.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584 },
 ]
 
 [[package]]
@@ -1211,9 +1401,9 @@ dependencies = [
     { name = "click" },
     { name = "h11" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/de/ad/713be230bcda622eaa35c28f0d328c3675c371238470abdea52417f17a8e/uvicorn-0.34.3.tar.gz", hash = "sha256:35919a9a979d7a59334b6b10e05d77c1d0d574c50e0fc98b8b1a0f165708b55a", size = 76631, upload-time = "2025-06-01T07:48:17.531Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/ad/713be230bcda622eaa35c28f0d328c3675c371238470abdea52417f17a8e/uvicorn-0.34.3.tar.gz", hash = "sha256:35919a9a979d7a59334b6b10e05d77c1d0d574c50e0fc98b8b1a0f165708b55a", size = 76631 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6d/0d/8adfeaa62945f90d19ddc461c55f4a50c258af7662d34b6a3d5d1f8646f6/uvicorn-0.34.3-py3-none-any.whl", hash = "sha256:16246631db62bdfbf069b0645177d6e8a77ba950cfedbfd093acef9444e4d885", size = 62431, upload-time = "2025-06-01T07:48:15.664Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/0d/8adfeaa62945f90d19ddc461c55f4a50c258af7662d34b6a3d5d1f8646f6/uvicorn-0.34.3-py3-none-any.whl", hash = "sha256:16246631db62bdfbf069b0645177d6e8a77ba950cfedbfd093acef9444e4d885", size = 62431 },
 ]
 
 [package.optional-dependencies]
@@ -1231,32 +1421,32 @@ standard = [
 name = "uvloop"
 version = "0.22.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
-    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
-    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
-    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
-    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" },
-    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" },
-    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" },
-    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" },
-    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" },
-    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" },
-    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936 },
+    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769 },
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413 },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307 },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970 },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343 },
+    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611 },
+    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811 },
+    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562 },
+    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890 },
+    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472 },
+    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051 },
+    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067 },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423 },
+    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437 },
+    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101 },
+    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158 },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360 },
+    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790 },
+    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783 },
+    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548 },
+    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065 },
+    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384 },
+    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730 },
 ]
 
 [[package]]
@@ -1266,119 +1456,173 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" },
-    { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" },
-    { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" },
-    { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042, upload-time = "2025-10-14T15:04:59.046Z" },
-    { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" },
-    { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209, upload-time = "2025-10-14T15:05:01.168Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" },
-    { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" },
-    { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" },
-    { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" },
-    { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" },
-    { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" },
-    { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" },
-    { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" },
-    { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" },
-    { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" },
-    { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" },
-    { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" },
-    { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" },
-    { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" },
-    { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" },
-    { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" },
-    { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" },
-    { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" },
-    { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745 },
+    { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769 },
+    { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374 },
+    { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485 },
+    { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813 },
+    { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816 },
+    { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186 },
+    { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812 },
+    { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196 },
+    { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657 },
+    { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042 },
+    { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410 },
+    { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209 },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321 },
+    { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783 },
+    { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279 },
+    { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405 },
+    { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976 },
+    { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506 },
+    { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936 },
+    { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147 },
+    { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007 },
+    { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280 },
+    { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056 },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162 },
+    { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909 },
+    { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389 },
+    { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964 },
+    { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114 },
+    { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264 },
+    { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877 },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176 },
+    { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577 },
+    { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425 },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826 },
+    { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208 },
+    { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315 },
+    { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869 },
+    { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919 },
+    { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845 },
+    { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027 },
+    { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615 },
+    { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836 },
+    { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099 },
+    { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626 },
+    { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519 },
+    { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078 },
+    { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664 },
+    { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154 },
+    { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820 },
+    { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510 },
+    { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408 },
+    { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968 },
+    { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096 },
+    { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040 },
+    { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847 },
+    { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072 },
+    { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104 },
+    { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112 },
 ]
 
 [[package]]
 name = "wcwidth"
 version = "0.6.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684, upload-time = "2026-02-06T19:19:40.919Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" },
+    { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189 },
 ]
 
 [[package]]
 name = "websockets"
 version = "16.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" },
-    { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" },
-    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" },
-    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" },
-    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" },
-    { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261, upload-time = "2026-01-10T09:22:56.251Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693, upload-time = "2026-01-10T09:22:57.478Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" },
-    { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406, upload-time = "2026-01-10T09:23:12.178Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085, upload-time = "2026-01-10T09:23:13.511Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328, upload-time = "2026-01-10T09:23:14.727Z" },
-    { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044, upload-time = "2026-01-10T09:23:15.939Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279, upload-time = "2026-01-10T09:23:17.148Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711, upload-time = "2026-01-10T09:23:18.372Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982, upload-time = "2026-01-10T09:23:19.652Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915, upload-time = "2026-01-10T09:23:21.458Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381, upload-time = "2026-01-10T09:23:22.715Z" },
-    { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737, upload-time = "2026-01-10T09:23:24.523Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268, upload-time = "2026-01-10T09:23:25.781Z" },
-    { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486, upload-time = "2026-01-10T09:23:27.033Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331, upload-time = "2026-01-10T09:23:28.259Z" },
-    { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501, upload-time = "2026-01-10T09:23:29.449Z" },
-    { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062, upload-time = "2026-01-10T09:23:31.368Z" },
-    { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" },
+    { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365 },
+    { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038 },
+    { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328 },
+    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915 },
+    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152 },
+    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583 },
+    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880 },
+    { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261 },
+    { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693 },
+    { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364 },
+    { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039 },
+    { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323 },
+    { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975 },
+    { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203 },
+    { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653 },
+    { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920 },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255 },
+    { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689 },
+    { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406 },
+    { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085 },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328 },
+    { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044 },
+    { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279 },
+    { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711 },
+    { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982 },
+    { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915 },
+    { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381 },
+    { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737 },
+    { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268 },
+    { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486 },
+    { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331 },
+    { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501 },
+    { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062 },
+    { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356 },
+    { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085 },
+    { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531 },
+    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598 },
+]
+
+[[package]]
+name = "wrapt"
+version = "2.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/37/ae31f40bec90de2f88d9597d0b5281e23ffe85b893a47ca5d9c05c63a4f6/wrapt-2.1.1.tar.gz", hash = "sha256:5fdcb09bf6db023d88f312bd0767594b414655d58090fc1c46b3414415f67fac", size = 81329 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/cb/4d5255d19bbd12be7f8ee2c1fb4269dddec9cef777ef17174d357468efaa/wrapt-2.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab8e3793b239db021a18782a5823fcdea63b9fe75d0e340957f5828ef55fcc02", size = 61143 },
+    { url = "https://files.pythonhosted.org/packages/6f/07/7ed02daa35542023464e3c8b7cb937fa61f6c61c0361ecf8f5fecf8ad8da/wrapt-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7c0300007836373d1c2df105b40777986accb738053a92fe09b615a7a4547e9f", size = 61740 },
+    { url = "https://files.pythonhosted.org/packages/c4/60/a237a4e4a36f6d966061ccc9b017627d448161b19e0a3ab80a7c7c97f859/wrapt-2.1.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2b27c070fd1132ab23957bcd4ee3ba707a91e653a9268dc1afbd39b77b2799f7", size = 121327 },
+    { url = "https://files.pythonhosted.org/packages/ae/fe/9139058a3daa8818fc67e6460a2340e8bbcf3aef8b15d0301338bbe181ca/wrapt-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b0e36d845e8b6f50949b6b65fc6cd279f47a1944582ed4ec8258cd136d89a64", size = 122903 },
+    { url = "https://files.pythonhosted.org/packages/91/10/b8479202b4164649675846a531763531f0a6608339558b5a0a718fc49a8d/wrapt-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4aeea04a9889370fcfb1ef828c4cc583f36a875061505cd6cd9ba24d8b43cc36", size = 121333 },
+    { url = "https://files.pythonhosted.org/packages/5f/75/75fc793b791d79444aca2c03ccde64e8b99eda321b003f267d570b7b0985/wrapt-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d88b46bb0dce9f74b6817bc1758ff2125e1ca9e1377d62ea35b6896142ab6825", size = 120458 },
+    { url = "https://files.pythonhosted.org/packages/d7/8f/c3f30d511082ca6d947c405f9d8f6c8eaf83cfde527c439ec2c9a30eb5ea/wrapt-2.1.1-cp312-cp312-win32.whl", hash = "sha256:63decff76ca685b5c557082dfbea865f3f5f6d45766a89bff8dc61d336348833", size = 58086 },
+    { url = "https://files.pythonhosted.org/packages/0a/c8/37625b643eea2849f10c3b90f69c7462faa4134448d4443234adaf122ae5/wrapt-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:b828235d26c1e35aca4107039802ae4b1411be0fe0367dd5b7e4d90e562fcbcd", size = 60328 },
+    { url = "https://files.pythonhosted.org/packages/ce/79/56242f07572d5682ba8065a9d4d9c2218313f576e3c3471873c2a5355ffd/wrapt-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:75128507413a9f1bcbe2db88fd18fbdbf80f264b82fa33a6996cdeaf01c52352", size = 58722 },
+    { url = "https://files.pythonhosted.org/packages/f7/ca/3cf290212855b19af9fcc41b725b5620b32f470d6aad970c2593500817eb/wrapt-2.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ce9646e17fa7c3e2e7a87e696c7de66512c2b4f789a8db95c613588985a2e139", size = 61150 },
+    { url = "https://files.pythonhosted.org/packages/9d/33/5b8f89a82a9859ce82da4870c799ad11ce15648b6e1c820fec3e23f4a19f/wrapt-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:428cfc801925454395aa468ba7ddb3ed63dc0d881df7b81626cdd433b4e2b11b", size = 61743 },
+    { url = "https://files.pythonhosted.org/packages/1e/2f/60c51304fbdf47ce992d9eefa61fbd2c0e64feee60aaa439baf42ea6f40b/wrapt-2.1.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5797f65e4d58065a49088c3b32af5410751cd485e83ba89e5a45e2aa8905af98", size = 121341 },
+    { url = "https://files.pythonhosted.org/packages/ad/03/ce5256e66dd94e521ad5e753c78185c01b6eddbed3147be541f4d38c0cb7/wrapt-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a2db44a71202c5ae4bb5f27c6d3afbc5b23053f2e7e78aa29704541b5dad789", size = 122947 },
+    { url = "https://files.pythonhosted.org/packages/eb/ae/50ca8854b81b946a11a36fcd6ead32336e6db2c14b6e4a8b092b80741178/wrapt-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8d5350c3590af09c1703dd60ec78a7370c0186e11eaafb9dda025a30eee6492d", size = 121370 },
+    { url = "https://files.pythonhosted.org/packages/fb/d9/d6a7c654e0043319b4cc137a4caaf7aa16b46b51ee8df98d1060254705b7/wrapt-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2d9b076411bed964e752c01b49fd224cc385f3a96f520c797d38412d70d08359", size = 120465 },
+    { url = "https://files.pythonhosted.org/packages/55/90/65be41e40845d951f714b5a77e84f377a3787b1e8eee6555a680da6d0db5/wrapt-2.1.1-cp313-cp313-win32.whl", hash = "sha256:0bb7207130ce6486727baa85373503bf3334cc28016f6928a0fa7e19d7ecdc06", size = 58090 },
+    { url = "https://files.pythonhosted.org/packages/5f/66/6a09e0294c4fc8c26028a03a15191721c9271672467cc33e6617ee0d91d2/wrapt-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:cbfee35c711046b15147b0ae7db9b976f01c9520e6636d992cd9e69e5e2b03b1", size = 60341 },
+    { url = "https://files.pythonhosted.org/packages/7a/f0/20ceb8b701e9a71555c87a5ddecbed76ec16742cf1e4b87bbaf26735f998/wrapt-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:7d2756061022aebbf57ba14af9c16e8044e055c22d38de7bf40d92b565ecd2b0", size = 58731 },
+    { url = "https://files.pythonhosted.org/packages/80/b4/fe95beb8946700b3db371f6ce25115217e7075ca063663b8cca2888ba55c/wrapt-2.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4814a3e58bc6971e46baa910ecee69699110a2bf06c201e24277c65115a20c20", size = 62969 },
+    { url = "https://files.pythonhosted.org/packages/b8/89/477b0bdc784e3299edf69c279697372b8bd4c31d9c6966eae405442899df/wrapt-2.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:106c5123232ab9b9f4903692e1fa0bdc231510098f04c13c3081f8ad71c3d612", size = 63606 },
+    { url = "https://files.pythonhosted.org/packages/ed/55/9d0c1269ab76de87715b3b905df54dd25d55bbffd0b98696893eb613469f/wrapt-2.1.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1a40b83ff2535e6e56f190aff123821eea89a24c589f7af33413b9c19eb2c738", size = 152536 },
+    { url = "https://files.pythonhosted.org/packages/44/18/2004766030462f79ad86efaa62000b5e39b1ff001dcce86650e1625f40ae/wrapt-2.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:789cea26e740d71cf1882e3a42bb29052bc4ada15770c90072cb47bf73fb3dbf", size = 158697 },
+    { url = "https://files.pythonhosted.org/packages/e1/bb/0a880fa0f35e94ee843df4ee4dd52a699c9263f36881311cfb412c09c3e5/wrapt-2.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ba49c14222d5e5c0ee394495a8655e991dc06cbca5398153aefa5ac08cd6ccd7", size = 155563 },
+    { url = "https://files.pythonhosted.org/packages/42/ff/cd1b7c4846c8678fac359a6eb975dc7ab5bd606030adb22acc8b4a9f53f1/wrapt-2.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ac8cda531fe55be838a17c62c806824472bb962b3afa47ecbd59b27b78496f4e", size = 150161 },
+    { url = "https://files.pythonhosted.org/packages/38/ec/67c90a7082f452964b4621e4890e9a490f1add23cdeb7483cc1706743291/wrapt-2.1.1-cp313-cp313t-win32.whl", hash = "sha256:b8af75fe20d381dd5bcc9db2e86a86d7fcfbf615383a7147b85da97c1182225b", size = 59783 },
+    { url = "https://files.pythonhosted.org/packages/ec/08/466afe4855847d8febdfa2c57c87e991fc5820afbdef01a273683dfd15a0/wrapt-2.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:45c5631c9b6c792b78be2d7352129f776dd72c605be2c3a4e9be346be8376d83", size = 63082 },
+    { url = "https://files.pythonhosted.org/packages/9a/62/60b629463c28b15b1eeadb3a0691e17568622b12aa5bfa7ebe9b514bfbeb/wrapt-2.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:da815b9263947ac98d088b6414ac83507809a1d385e4632d9489867228d6d81c", size = 60251 },
+    { url = "https://files.pythonhosted.org/packages/95/a0/1c2396e272f91efe6b16a6a8bce7ad53856c8f9ae4f34ceaa711d63ec9e1/wrapt-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9aa1765054245bb01a37f615503290d4e207e3fd59226e78341afb587e9c1236", size = 61311 },
+    { url = "https://files.pythonhosted.org/packages/b0/9a/d2faba7e61072a7507b5722db63562fdb22f5a24e237d460d18755627f15/wrapt-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:feff14b63a6d86c1eee33a57f77573649f2550935981625be7ff3cb7342efe05", size = 61805 },
+    { url = "https://files.pythonhosted.org/packages/db/56/073989deb4b5d7d6e7ea424476a4ae4bda02140f2dbeaafb14ba4864dd60/wrapt-2.1.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:81fc5f22d5fcfdbabde96bb3f5379b9f4476d05c6d524d7259dc5dfb501d3281", size = 120308 },
+    { url = "https://files.pythonhosted.org/packages/d1/b6/84f37261295e38167a29eb82affaf1dc15948dc416925fe2091beee8e4ac/wrapt-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:951b228ecf66def855d22e006ab9a1fc12535111ae7db2ec576c728f8ddb39e8", size = 122688 },
+    { url = "https://files.pythonhosted.org/packages/ea/80/32db2eec6671f80c65b7ff175be61bc73d7f5223f6910b0c921bbc4bd11c/wrapt-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ddf582a95641b9a8c8bd643e83f34ecbbfe1b68bc3850093605e469ab680ae3", size = 121115 },
+    { url = "https://files.pythonhosted.org/packages/49/ef/dcd00383df0cd696614127902153bf067971a5aabcd3c9dcb2d8ef354b2a/wrapt-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:fc5c500966bf48913f795f1984704e6d452ba2414207b15e1f8c339a059d5b16", size = 119484 },
+    { url = "https://files.pythonhosted.org/packages/76/29/0630280cdd2bd8f86f35cb6854abee1c9d6d1a28a0c6b6417cd15d378325/wrapt-2.1.1-cp314-cp314-win32.whl", hash = "sha256:4aa4baadb1f94b71151b8e44a0c044f6af37396c3b8bcd474b78b49e2130a23b", size = 58514 },
+    { url = "https://files.pythonhosted.org/packages/db/19/5bed84f9089ed2065f6aeda5dfc4f043743f642bc871454b261c3d7d322b/wrapt-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:860e9d3fd81816a9f4e40812f28be4439ab01f260603c749d14be3c0a1170d19", size = 60763 },
+    { url = "https://files.pythonhosted.org/packages/e4/cb/b967f2f9669e4249b4fe82e630d2a01bc6b9e362b9b12ed91bbe23ae8df4/wrapt-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:3c59e103017a2c1ea0ddf589cbefd63f91081d7ce9d491d69ff2512bb1157e23", size = 59051 },
+    { url = "https://files.pythonhosted.org/packages/eb/19/6fed62be29f97eb8a56aff236c3f960a4b4a86e8379dc7046a8005901a97/wrapt-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9fa7c7e1bee9278fc4f5dd8275bc8d25493281a8ec6c61959e37cc46acf02007", size = 63059 },
+    { url = "https://files.pythonhosted.org/packages/0a/1c/b757fd0adb53d91547ed8fad76ba14a5932d83dde4c994846a2804596378/wrapt-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:39c35e12e8215628984248bd9c8897ce0a474be2a773db207eb93414219d8469", size = 63618 },
+    { url = "https://files.pythonhosted.org/packages/10/fe/e5ae17b1480957c7988d991b93df9f2425fc51f128cf88144d6a18d0eb12/wrapt-2.1.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:94ded4540cac9125eaa8ddf5f651a7ec0da6f5b9f248fe0347b597098f8ec14c", size = 152544 },
+    { url = "https://files.pythonhosted.org/packages/3e/cc/99aed210c6b547b8a6e4cb9d1425e4466727158a6aeb833aa7997e9e08dd/wrapt-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da0af328373f97ed9bdfea24549ac1b944096a5a71b30e41c9b8b53ab3eec04a", size = 158700 },
+    { url = "https://files.pythonhosted.org/packages/81/0e/d442f745f4957944d5f8ad38bc3a96620bfff3562533b87e486e979f3d99/wrapt-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4ad839b55f0bf235f8e337ce060572d7a06592592f600f3a3029168e838469d3", size = 155561 },
+    { url = "https://files.pythonhosted.org/packages/51/ac/9891816280e0018c48f8dfd61b136af7b0dcb4a088895db2531acde5631b/wrapt-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0d89c49356e5e2a50fa86b40e0510082abcd0530f926cbd71cf25bee6b9d82d7", size = 150188 },
+    { url = "https://files.pythonhosted.org/packages/24/98/e2f273b6d70d41f98d0739aa9a269d0b633684a5fb17b9229709375748d4/wrapt-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:f4c7dd22cf7f36aafe772f3d88656559205c3af1b7900adfccb70edeb0d2abc4", size = 60425 },
+    { url = "https://files.pythonhosted.org/packages/1e/06/b500bfc38a4f82d89f34a13069e748c82c5430d365d9e6b75afb3ab74457/wrapt-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f76bc12c583ab01e73ba0ea585465a41e48d968f6d1311b4daec4f8654e356e3", size = 63855 },
+    { url = "https://files.pythonhosted.org/packages/d9/cc/5f6193c32166faee1d2a613f278608e6f3b95b96589d020f0088459c46c9/wrapt-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7ea74fc0bec172f1ae5f3505b6655c541786a5cabe4bbc0d9723a56ac32eb9b9", size = 60443 },
+    { url = "https://files.pythonhosted.org/packages/c4/da/5a086bf4c22a41995312db104ec2ffeee2cf6accca9faaee5315c790377d/wrapt-2.1.1-py3-none-any.whl", hash = "sha256:3b0f4629eb954394a3d7c7a1c8cca25f0b07cefe6aa8545e862e9778152de5b7", size = 43886 },
 ]
-- 
2.49.1


From 9a7fa5004eb32285c2693a2bbfb3b291956ef7e8 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 13:47:23 +0100
Subject: [PATCH 24/38] refactor: extract pagination engine and publication
 upsert from ingestion service

Split app/services/ingestion/application.py (2,955 lines) into three
focused modules:

- page_fetch.py (219 lines): PageFetcher class for single-page fetch,
  parse-or-layout-error handling, and retry with backoff
- pagination.py (486 lines): PaginationEngine class for multi-page
  orchestration, loop state management, and short-circuit detection
- publication_upsert.py (239 lines): module-level functions for
  resolve_publication, upsert_profile_publications, and all
  find/create/update helpers

Also fixes two external import paths in portability/ that incorrectly
sourced normalize_title and build_publication_url from application.py
instead of fingerprints.py.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 DECOMPOSITION_SLICES.md                       | 212 +++++
 app/services/ingestion/application.py         | 889 +-----------------
 app/services/ingestion/page_fetch.py          | 217 +++++
 app/services/ingestion/pagination.py          | 486 ++++++++++
 app/services/ingestion/publication_upsert.py  | 239 +++++
 app/services/portability/normalize.py         |   2 +-
 .../portability/publication_import.py         |   2 +-
 .../test_run_lifecycle_consistency.py         |   7 +-
 8 files changed, 1169 insertions(+), 885 deletions(-)
 create mode 100644 DECOMPOSITION_SLICES.md
 create mode 100644 app/services/ingestion/page_fetch.py
 create mode 100644 app/services/ingestion/pagination.py
 create mode 100644 app/services/ingestion/publication_upsert.py

diff --git a/DECOMPOSITION_SLICES.md b/DECOMPOSITION_SLICES.md
new file mode 100644
index 0000000..8e22261
--- /dev/null
+++ b/DECOMPOSITION_SLICES.md
@@ -0,0 +1,212 @@
+# Scholarr Decomposition Slices
+
+## How to use this file
+
+This file contains self-contained decomposition prompts ("slices") to bring the codebase into compliance with `agents.md` file size rules. Each slice is an independent task for an LLM executor.
+
+**Rules from `agents.md`:**
+- File length: 400 lines target, 600 lines hard ceiling
+- Function length: 50 lines max
+- All business logic in `app/services/<domain>/`
+- Read `agents.md` fully before starting any slice
+
+**Execution protocol:**
+1. Pick the next incomplete slice in order (slices depend on prior ones)
+2. Read the prompt section — it contains everything you need
+3. Read all source files mentioned before making changes
+4. Make the changes described — no business logic changes, only file reorganization
+5. Verify: all imports resolve, all tests pass
+6. Commit with the specified message
+
+---
+
+## Progress
+
+| # | Slice | Status |
+|---|-------|--------|
+| 1 | Schema split | **DONE** |
+| 2 | Ingestion: pagination + publication upsert | **DONE** |
+| 3 | Ingestion: enrichment + scholar processing + run completion | pending |
+| 4 | Scholars service + PDF queue | pending |
+| 5 | Routers + scheduler | pending |
+
+---
+
+## Slice 1: Split `app/api/schemas.py` into domain packages — DONE
+
+Completed. The 945-line `app/api/schemas.py` was split into `app/api/schemas/` package:
+
+| File | Lines | Contents |
+|---|---|---|
+| `common.py` | 39 | `ApiMeta`, `ApiErrorData`, `ApiErrorEnvelope`, `MessageData`, `MessageEnvelope` |
+| `auth.py` | 73 | `SessionUserData`, `AuthMe*`, `CsrfBootstrap*`, `Login*`, `ChangePasswordRequest` |
+| `scholars.py` | 153 | `ScholarItem*`, `ScholarSearch*`, `ScholarExport*`, `DataExport*`, `DataImport*` |
+| `publications.py` | 151 | `DisplayIdentifierData`, `PublicationItem*`, `MarkAll*`, `MarkSelected*`, `RetryPublication*`, `TogglePublication*` |
+| `runs.py` | 226 | `RunListItem*`, `RunSummary*`, `RunDebug*`, `RunScholarResult*`, `RunDetail*`, `ManualRun*`, `Queue*`, `ScrapeSafety*` |
+| `admin.py` | 289 | All `Admin*` models including PDF queue, repair, near-duplicate schemas |
+| `settings.py` | 54 | `SettingsPolicy*`, `Settings*`, `SettingsUpdateRequest` |
+| `__init__.py` | 7 | Wildcard re-exports — all `from app.api.schemas import X` imports unchanged |
+
+---
+
+## Slice 2: Decompose `app/services/ingestion/application.py` — pagination + publication upsert — DONE
+
+Completed. Extracted three modules from `application.py` (2,955 → 2,084 lines):
+
+| File | Lines | Contents |
+|---|---|---|
+| `app/services/ingestion/page_fetch.py` | 219 | `PageFetcher` class — single-page fetch, parse-or-layout-error, retry with backoff |
+| `app/services/ingestion/pagination.py` | 486 | `PaginationEngine` class — multi-page orchestration, loop state, short-circuit, fingerprint checks |
+| `app/services/ingestion/publication_upsert.py` | 239 | Module-level functions — `resolve_publication`, `upsert_profile_publications`, find/create/update helpers |
+
+Also fixed two external import paths (`portability/normalize.py`, `portability/publication_import.py`) that imported `normalize_title`/`build_publication_url` from `application.py` — now correctly sourced from `fingerprints.py`. Updated one integration test to monkeypatch the new module-level function instead of the old instance method.
+
+---
+
+## Slice 3: Decompose `app/services/ingestion/application.py` — enrichment, scholar processing, run completion
+
+**Why:** Three remaining logical chunks. Extracting all three brings `application.py` down to ~500 lines (the orchestration spine).
+
+**Files to create:** `app/services/ingestion/enrichment.py`, `app/services/ingestion/scholar_processing.py`, `app/services/ingestion/run_completion.py`
+
+**Files to modify:** `app/services/ingestion/application.py`
+
+**Prompt:**
+
+You are working on the scholarr repository. Read `agents.md` for project conventions. Continue decomposing `app/services/ingestion/application.py` (slice 2 is complete — `page_fetch.py`, `pagination.py`, and `publication_upsert.py` already extracted). Extract three remaining chunks.
+
+**A. `app/services/ingestion/enrichment.py` (~300 lines)**
+
+Move these methods (post-run OpenAlex enrichment):
+
+- `_run_is_canceled`, `_enrich_pending_publications`, `_discover_identifiers_for_enrichment`
+- `_publish_identifier_update_event`, `_enrich_publications_with_openalex`
+
+Create an `EnrichmentRunner` class that receives service dependencies (OpenAlex client, identifier service, dedup service, DB session factory) in its constructor.
+
+**B. `app/services/ingestion/scholar_processing.py` (~400 lines)**
+
+Move these methods (per-scholar outcome resolution):
+
+- `_assert_valid_paged_parse_result`, `_apply_first_page_profile_metadata`, `_build_result_entry`
+- `_skipped_no_change_outcome`, `_upsert_publications_outcome`, `_upsert_success_or_exception`
+- `_upsert_success`, `_upsert_exception_outcome`, `_parse_failure_outcome`
+- `_sync_continuation_queue`, `_process_scholar`, `_process_scholar_inner`
+- `_fetch_and_prepare_scholar_result`, `_resolve_scholar_outcome`, `_unexpected_scholar_exception_outcome`
+
+These become methods on a `ScholarProcessor` class or module-level functions.
+
+**C. `app/services/ingestion/run_completion.py` (~300 lines)**
+
+Move these methods (run finalization + alerting):
+
+- `_classify_failure_bucket` (standalone function)
+- `_summarize_failures`, `_build_alert_summary`, `_apply_safety_outcome`, `_finalize_run_record`
+- `_resolve_run_status`, `_resolve_continuation_queue_target`, `_build_failure_debug_context`
+- `_complete_run_for_user`
+
+These become module-level functions accepting explicit parameters.
+
+**After all extractions, `application.py` should contain only:**
+
+- `ScholarIngestionService.__init__` and config helpers
+- Run lifecycle: `initialize_run`, `execute_run`, `run_for_user`
+- Scholar iteration orchestration: `_run_scholar_iteration`
+- Progress tracking: `_result_counters`, `_adjust_progress_counts`
+- Safety gate integration, background task management
+
+Target: `application.py` ≤ 500 lines. No new file exceeds 400 lines. All tests must pass unchanged.
+
+Commit message: `refactor: extract enrichment, scholar processing, and run completion from ingestion service`
+
+---
+
+## Slice 4: Decompose `app/services/scholars/application.py` (996 lines) and `app/services/publications/pdf_queue.py` (969 lines)
+
+**Why:** Two service files nearly 2x the hard ceiling. Each has clear internal seams.
+
+**Files to create:** `app/services/scholars/author_search.py`, `app/services/scholars/author_search_cache.py`, `app/services/publications/pdf_queue_queries.py`, `app/services/publications/pdf_queue_resolution.py`
+
+**Files to modify:** `app/services/scholars/application.py`, `app/services/publications/pdf_queue.py`
+
+**Prompt:**
+
+You are working on the scholarr repository. Read `agents.md` for project conventions. Two service files exceed the 600-line ceiling. Decompose both.
+
+**A. `app/services/scholars/application.py` (996 lines)**
+
+This file mixes scholar CRUD (~350 lines) with the entire author search pipeline (~650 lines). Split them:
+
+Create `app/services/scholars/author_search_cache.py` (~150 lines): Move all `_serialize_*` and `_deserialize_*` functions. Move `_cache_get_author_search_result`, `_cache_set_author_search_result`, `_prune_author_search_cache`. These are pure functions operating on the DB cache table.
+
+Create `app/services/scholars/author_search.py` (~500 lines): Move remaining author search functions — cooldown management, throttle logic, retry wrappers, circuit breaker, lock acquisition, and `search_author_candidates`. Import cache functions from `author_search_cache.py`. Accept DB session and settings as explicit parameters.
+
+Update `application.py`: Keep only scholar CRUD methods. Import and delegate to `search_author_candidates` from `author_search.py`. Target: ≤ 350 lines.
+
+**B. `app/services/publications/pdf_queue.py` (969 lines)**
+
+Three concerns in one file. Split by concern:
+
+Create `app/services/publications/pdf_queue_queries.py` (~330 lines): Move SQL query builders (`_tracked_queue_select_base`, `_tracked_queue_select`, etc.), result hydration (`_queue_item_from_row`, `_hydrated_queue_items`), listing/counting/pagination (`list_pdf_queue_items`, `count_pdf_queue_items`, `list_pdf_queue_page`), retry item builders and missing-PDF candidate queries.
+
+Create `app/services/publications/pdf_queue_resolution.py` (~300 lines): Move task execution (`_mark_attempt_started`, `_failed_outcome`, `_fetch_outcome_for_row`), outcome persistence (`_apply_publication_update`, `_apply_job_outcome`, `_persist_outcome`), scheduling (`_resolve_publication_row`, `_run_resolution_task`, `_register_task`, `_drop_finished_task`, `_schedule_rows`).
+
+Keep in `pdf_queue.py` (~340 lines): dataclasses, constants, enqueueing logic, public API.
+
+No file should exceed 500 lines. All tests must pass unchanged.
+
+Commit message: `refactor: decompose scholars service and pdf_queue into focused modules`
+
+---
+
+## Slice 5: Decompose router files and scheduler
+
+**Why:** Three files slightly over the 600-line ceiling. Each needs helper extraction.
+
+**Files to create:** `app/api/routers/run_serializers.py`, `app/api/routers/run_manual.py`, `app/api/routers/scholar_helpers.py`, `app/services/ingestion/queue_runner.py`
+
+**Files to modify:** `app/api/routers/runs.py` (875 → ~405), `app/api/routers/scholars.py` (616 → ~396), `app/services/ingestion/scheduler.py` (622 → ~280)
+
+**Prompt:**
+
+You are working on the scholarr repository. Read `agents.md` for project conventions. Three files are slightly over the 600-line ceiling. Extract helpers from each.
+
+**A. `app/api/routers/runs.py` (875 lines) → 3 files**
+
+Create `app/api/routers/run_serializers.py` (~250 lines): Move all `_serialize_*`, `_normalize_*`, `_int_value`, `_str_value`, `_bool_value` helper functions. Move `_manual_run_payload_from_run` and `_manual_run_success_payload`.
+
+Create `app/api/routers/run_manual.py` (~220 lines): Move `_load_safety_state`, `_raise_manual_runs_disabled`, `_reused_manual_run_payload`, `_run_ingestion_for_manual`, `_recover_integrity_error`, `_execute_manual_run`, `_raise_manual_blocked_safety`, `_raise_manual_failed`.
+
+Keep in `runs.py` (~405 lines): only route handler functions + imports.
+
+**B. `app/api/routers/scholars.py` (616 lines) → 2 files**
+
+Create `app/api/routers/scholar_helpers.py` (~220 lines): Move `_needs_metadata_hydration`, `_is_create_hydration_rate_limited`, `_auto_enqueue_new_scholar_enabled`, `_enqueue_initial_scrape_job_for_scholar`, `_uploaded_image_media_path`, `_serialize_scholar`, `_hydrate_scholar_metadata_if_needed`, `_search_kwargs`, `_search_response_data`, `_read_uploaded_image`, `_require_user_profile`.
+
+Keep in `scholars.py` (~396 lines): only route handlers.
+
+**C. `app/services/ingestion/scheduler.py` (622 lines) → 2 files**
+
+Create `app/services/ingestion/queue_runner.py` (~350 lines): Move all continuation-queue job processing — `_drain_continuation_queue`, `_drop_queue_job_if_max_attempts`, `_mark_queue_job_retrying`, `_queue_job_has_available_scholar`, all `_reschedule_*` methods, `_run_ingestion_for_queue_job`, `_finalize_queue_job_after_run`, `_run_queue_job`. Create a `QueueJobRunner` class receiving config params in constructor.
+
+Keep in `scheduler.py` (~280 lines): auto-run scheduling, `_run_loop`, `_tick_once`, candidate loading.
+
+All tests must pass unchanged after each extraction.
+
+Commit message: `refactor: extract helpers from oversized router and scheduler files`
+
+---
+
+## Verification (after all slices)
+
+```bash
+# No Python file exceeds 600 lines
+find app/ -name "*.py" -exec wc -l {} + | awk '$1 > 600 && !/total/ {print "FAIL:", $0}'
+
+# All tests pass
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app python -m pytest
+
+# Linting
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app ruff check .
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app ruff format --check .
+```
diff --git a/app/services/ingestion/application.py b/app/services/ingestion/application.py
index 9aa49b9..abe23a3 100644
--- a/app/services/ingestion/application.py
+++ b/app/services/ingestion/application.py
@@ -21,7 +21,6 @@ from app.db.models import (
 )
 from app.logging_utils import structured_log
 from app.services.arxiv.errors import ArxivRateLimitError
-from app.services.doi.normalize import first_doi_from_texts
 from app.services.ingestion import queue as queue_service
 from app.services.ingestion import safety as run_safety_service
 from app.services.ingestion.constants import (
@@ -37,16 +36,10 @@ from app.services.ingestion.constants import (
 )
 from app.services.ingestion.fingerprints import (
     _build_body_excerpt,
-    _dedupe_publication_candidates,
-    _next_cstart_value,
-    build_initial_page_fingerprint,
-    build_publication_fingerprint,
-    build_publication_url,
-    canonical_title_for_dedup,
-    normalize_title,
 )
+from app.services.ingestion.pagination import PaginationEngine
+from app.services.ingestion.publication_upsert import upsert_profile_publications
 from app.services.ingestion.types import (
-    PagedLoopState,
     PagedParseResult,
     RunAlertSummary,
     RunAlreadyInProgressError,
@@ -62,8 +55,6 @@ from app.services.scholar.parser import (
     ParsedProfilePage,
     ParseState,
     PublicationCandidate,
-    ScholarParserError,
-    parse_profile_page,
 )
 from app.services.scholar.source import FetchResult, ScholarSource
 from app.services.settings import application as user_settings_service
@@ -115,6 +106,7 @@ _background_tasks: set[asyncio.Task[Any]] = set()
 class ScholarIngestionService:
     def __init__(self, *, source: ScholarSource) -> None:
         self._source = source
+        self._pagination = PaginationEngine(source=source)
 
     @staticmethod
     def _effective_request_delay_seconds(value: int) -> int:
@@ -290,7 +282,9 @@ class ScholarIngestionService:
         paged_parse_result: PagedParseResult,
     ) -> None:
         parsed_page = paged_parse_result.parsed_page
-        if parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS} and any(code.startswith("layout_") for code in parsed_page.warnings):
+        if parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS} and any(
+            code.startswith("layout_") for code in parsed_page.warnings
+        ):
             raise RuntimeError(f"Layout warning marked as terminal for scholar_id={scholar_id}.")
         for publication in paged_parse_result.publications:
             if not publication.title.strip():
@@ -445,7 +439,7 @@ class ScholarIngestionService:
         has_partial_publication_set: bool,
     ) -> ScholarProcessingOutcome:
         # We no longer aggregate and upsert the publications here.
-        # Eager DB insertions have already saved and committed them inside `_fetch_and_parse_all_pages_with_retry` and `_paginate_loop`.
+        # Eager DB insertions have already saved and committed them inside `fetch_and_parse_all_pages` and `_paginate_loop`.
         discovered_count = paged_parse_result.discovered_publication_count
         is_partial = (
             paged_parse_result.has_more_remaining
@@ -683,7 +677,7 @@ class ScholarIngestionService:
         page_size: int,
     ) -> tuple[datetime, PagedParseResult, dict[str, Any]]:
         run_dt = datetime.now(UTC)
-        paged_parse_result = await self._fetch_and_parse_all_pages_with_retry(
+        paged_parse_result = await self._pagination.fetch_and_parse_all_pages(
             scholar=scholar,
             run=run,
             db_session=db_session,
@@ -696,6 +690,7 @@ class ScholarIngestionService:
             max_pages=max_pages_per_scholar,
             page_size=page_size,
             previous_initial_page_fingerprint_sha256=scholar.last_initial_page_fingerprint_sha256,
+            upsert_publications_fn=upsert_profile_publications,
         )
         self._assert_valid_paged_parse_result(scholar_id=scholar.scholar_id, paged_parse_result=paged_parse_result)
         self._apply_first_page_profile_metadata(scholar=scholar, paged_parse_result=paged_parse_result, run_dt=run_dt)
@@ -1701,650 +1696,6 @@ class ScholarIngestionService:
         )
         return self._run_execution_summary(run=run, scholars=scholars, progress=progress)
 
-    async def _fetch_profile_page(
-        self,
-        *,
-        scholar_id: str,
-        cstart: int,
-        page_size: int,
-    ) -> FetchResult:
-        try:
-            page_fetcher = getattr(self._source, "fetch_profile_page_html", None)
-            if callable(page_fetcher):
-                return await page_fetcher(
-                    scholar_id,
-                    cstart=cstart,
-                    pagesize=page_size,
-                )
-            if cstart <= 0:
-                return await self._source.fetch_profile_html(scholar_id)
-            return FetchResult(
-                requested_url=(
-                    f"https://scholar.google.com/citations?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
-                ),
-                status_code=None,
-                final_url=None,
-                body="",
-                error="source_does_not_support_pagination",
-            )
-        except Exception as exc:
-            logger.exception(
-                "ingestion.fetch_unexpected_error",
-                extra={
-                    "scholar_id": scholar_id,
-                    "cstart": cstart,
-                    "page_size": page_size,
-                },
-            )
-            return FetchResult(
-                requested_url=(
-                    f"https://scholar.google.com/citations?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
-                ),
-                status_code=None,
-                final_url=None,
-                body="",
-                error=str(exc),
-            )
-
-    @staticmethod
-    def _should_retry_page_fetch(
-        *,
-        parsed_page: ParsedProfilePage,
-        network_attempt_count: int,
-        rate_limit_attempt_count: int,
-        network_error_retries: int,
-        rate_limit_retries: int,
-    ) -> bool:
-        if parsed_page.state == ParseState.NETWORK_ERROR:
-            return network_attempt_count <= network_error_retries
-        if (
-            parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA
-            and parsed_page.state_reason == "blocked_http_429_rate_limited"
-        ):
-            return rate_limit_attempt_count <= rate_limit_retries
-        return False
-
-    @staticmethod
-    async def _sleep_retry_backoff(
-        *,
-        scholar_id: str,
-        cstart: int,
-        network_attempt_count: int,
-        rate_limit_attempt_count: int,
-        retry_backoff_seconds: float,
-        rate_limit_backoff_seconds: float,
-        state_reason: str,
-    ) -> None:
-        if state_reason == "blocked_http_429_rate_limited":
-            sleep_seconds = rate_limit_backoff_seconds * rate_limit_attempt_count
-            attempt_label = rate_limit_attempt_count
-        else:
-            sleep_seconds = retry_backoff_seconds * (2 ** (network_attempt_count - 1))
-            attempt_label = network_attempt_count
-
-        structured_log(
-            logger,
-            "warning",
-            "ingestion.scholar_retry_scheduled",
-            scholar_id=scholar_id,
-            cstart=cstart,
-            attempt_count=attempt_label,
-            sleep_seconds=sleep_seconds,
-            state_reason=state_reason,
-        )
-        if sleep_seconds > 0:
-            await asyncio.sleep(sleep_seconds)
-
-    async def _fetch_and_parse_page_with_retry(
-        self,
-        *,
-        scholar_id: str,
-        cstart: int,
-        page_size: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-    ) -> tuple[FetchResult, ParsedProfilePage, list[dict[str, Any]]]:
-        network_attempts = 0
-        rate_limit_attempts = 0
-        attempt_log: list[dict[str, Any]] = []
-        fetch_result: FetchResult | None = None
-        parsed_page: ParsedProfilePage | None = None
-
-        while True:
-            fetch_result = await self._fetch_profile_page(
-                scholar_id=scholar_id,
-                cstart=cstart,
-                page_size=page_size,
-            )
-            parsed_page = self._parse_profile_page_or_layout_error(fetch_result=fetch_result)
-
-            if parsed_page.state == ParseState.NETWORK_ERROR:
-                network_attempts += 1
-                total_attempts = network_attempts
-            elif (
-                parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA
-                and parsed_page.state_reason == "blocked_http_429_rate_limited"
-            ):
-                rate_limit_attempts += 1
-                total_attempts = rate_limit_attempts
-            else:
-                total_attempts = network_attempts + rate_limit_attempts + 1
-
-            attempt_log.append(
-                {
-                    "attempt": total_attempts,
-                    "cstart": cstart,
-                    "state": parsed_page.state.value,
-                    "state_reason": parsed_page.state_reason,
-                    "status_code": fetch_result.status_code,
-                    "fetch_error": fetch_result.error,
-                }
-            )
-
-            if not self._should_retry_page_fetch(
-                parsed_page=parsed_page,
-                network_attempt_count=network_attempts,
-                rate_limit_attempt_count=rate_limit_attempts,
-                network_error_retries=network_error_retries,
-                rate_limit_retries=rate_limit_retries,
-            ):
-                break
-
-            await self._sleep_retry_backoff(
-                scholar_id=scholar_id,
-                cstart=cstart,
-                network_attempt_count=network_attempts,
-                rate_limit_attempt_count=rate_limit_attempts,
-                retry_backoff_seconds=max(float(retry_backoff_seconds), 0.0),
-                rate_limit_backoff_seconds=max(float(rate_limit_backoff_seconds), 0.0),
-                state_reason=parsed_page.state_reason,
-            )
-
-        if fetch_result is None or parsed_page is None:
-            raise RuntimeError("Fetch-and-parse retry loop produced no result.")
-        return fetch_result, parsed_page, attempt_log
-
-    def _parse_profile_page_or_layout_error(
-        self,
-        *,
-        fetch_result: FetchResult,
-    ) -> ParsedProfilePage:
-        try:
-            return parse_profile_page(fetch_result)
-        except ScholarParserError as exc:
-            return self._parsed_page_from_parser_error(
-                fetch_result=fetch_result,
-                code=exc.code,
-            )
-
-    @staticmethod
-    def _parsed_page_from_parser_error(
-        *,
-        fetch_result: FetchResult,
-        code: str,
-    ) -> ParsedProfilePage:
-        return ParsedProfilePage(
-            state=ParseState.LAYOUT_CHANGED,
-            state_reason=code,
-            profile_name=None,
-            profile_image_url=None,
-            publications=[],
-            marker_counts={},
-            warnings=[code],
-            has_show_more_button=False,
-            has_operation_error_banner=False,
-            articles_range=None,
-        )
-
-    @staticmethod
-    def _should_skip_no_change(
-        *,
-        start_cstart: int,
-        first_page_fingerprint_sha256: str | None,
-        previous_initial_page_fingerprint_sha256: str | None,
-        parsed_page: ParsedProfilePage,
-    ) -> bool:
-        return (
-            start_cstart <= 0
-            and first_page_fingerprint_sha256 is not None
-            and previous_initial_page_fingerprint_sha256 is not None
-            and first_page_fingerprint_sha256 == previous_initial_page_fingerprint_sha256
-            and parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS}
-        )
-
-    @staticmethod
-    def _skip_no_change_result(
-        *,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        first_page_fingerprint_sha256: str | None,
-        attempt_log: list[dict[str, Any]],
-        page_logs: list[dict[str, Any]],
-    ) -> PagedParseResult:
-        return PagedParseResult(
-            fetch_result=fetch_result,
-            parsed_page=parsed_page,
-            first_page_fetch_result=fetch_result,
-            first_page_parsed_page=parsed_page,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-            publications=[],
-            attempt_log=attempt_log,
-            page_logs=page_logs,
-            pages_fetched=1,
-            pages_attempted=1,
-            has_more_remaining=False,
-            pagination_truncated_reason=None,
-            continuation_cstart=None,
-            skipped_no_change=True,
-            discovered_publication_count=0,
-        )
-
-    @staticmethod
-    def _initial_failure_result(
-        *,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        first_page_fingerprint_sha256: str | None,
-        start_cstart: int,
-        attempt_log: list[dict[str, Any]],
-        page_logs: list[dict[str, Any]],
-    ) -> PagedParseResult:
-        continuation_cstart = start_cstart if parsed_page.state == ParseState.NETWORK_ERROR else None
-        return PagedParseResult(
-            fetch_result=fetch_result,
-            parsed_page=parsed_page,
-            first_page_fetch_result=fetch_result,
-            first_page_parsed_page=parsed_page,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-            publications=[],
-            attempt_log=attempt_log,
-            page_logs=page_logs,
-            pages_fetched=0,
-            pages_attempted=1,
-            has_more_remaining=False,
-            pagination_truncated_reason=None,
-            continuation_cstart=continuation_cstart,
-            skipped_no_change=False,
-            discovered_publication_count=0,
-        )
-
-    @staticmethod
-    def _build_loop_state(
-        *,
-        start_cstart: int,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        attempt_log: list[dict[str, Any]],
-        page_logs: list[dict[str, Any]],
-    ) -> PagedLoopState:
-        next_cstart = _next_cstart_value(
-            articles_range=parsed_page.articles_range,
-            fallback=start_cstart + len(parsed_page.publications),
-        )
-        return PagedLoopState(
-            fetch_result=fetch_result,
-            parsed_page=parsed_page,
-            attempt_log=attempt_log,
-            page_logs=page_logs,
-            publications=list(parsed_page.publications),
-            pages_fetched=1,
-            pages_attempted=1,
-            current_cstart=start_cstart,
-            next_cstart=next_cstart,
-        )
-
-    @staticmethod
-    def _set_truncated_state(
-        *,
-        state: PagedLoopState,
-        reason: str,
-        continuation_cstart: int,
-    ) -> None:
-        state.has_more_remaining = True
-        state.pagination_truncated_reason = reason
-        state.continuation_cstart = continuation_cstart
-
-    def _should_stop_pagination(self, *, state: PagedLoopState, bounded_max_pages: int) -> bool:
-        if state.pages_fetched >= bounded_max_pages:
-            self._set_truncated_state(
-                state=state,
-                reason="max_pages_reached",
-                continuation_cstart=(
-                    state.next_cstart if state.next_cstart > state.current_cstart else state.current_cstart
-                ),
-            )
-            return True
-        if state.next_cstart <= state.current_cstart:
-            self._set_truncated_state(
-                state=state,
-                reason="pagination_cursor_stalled",
-                continuation_cstart=state.current_cstart,
-            )
-            return True
-        return False
-
-    async def _fetch_next_page(
-        self,
-        *,
-        scholar_id: str,
-        state: PagedLoopState,
-        request_delay_seconds: int,
-        bounded_page_size: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-    ) -> tuple[FetchResult, ParsedProfilePage, list[dict[str, Any]]]:
-        if request_delay_seconds > 0:
-            await asyncio.sleep(float(request_delay_seconds))
-        state.current_cstart = state.next_cstart
-        return await self._fetch_and_parse_page_with_retry(
-            scholar_id=scholar_id,
-            cstart=state.current_cstart,
-            page_size=bounded_page_size,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-        )
-
-    @staticmethod
-    def _record_next_page(
-        *,
-        state: PagedLoopState,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        page_attempt_log: list[dict[str, Any]],
-    ) -> None:
-        state.pages_attempted += 1
-        state.attempt_log.extend(page_attempt_log)
-        state.page_logs.append(
-            {
-                "page": state.pages_attempted,
-                "cstart": state.current_cstart,
-                "state": parsed_page.state.value,
-                "state_reason": parsed_page.state_reason,
-                "status_code": fetch_result.status_code,
-                "publication_count": len(parsed_page.publications),
-                "articles_range": parsed_page.articles_range,
-                "has_show_more_button": parsed_page.has_show_more_button,
-                "warning_codes": parsed_page.warnings,
-                "attempt_count": len(page_attempt_log),
-            }
-        )
-        state.fetch_result = fetch_result
-        state.parsed_page = parsed_page
-
-    @staticmethod
-    def _handle_page_state_transition(*, state: PagedLoopState) -> bool:
-        if state.parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}:
-            ScholarIngestionService._set_truncated_state(
-                state=state,
-                reason=f"page_state_{state.parsed_page.state.value}",
-                continuation_cstart=state.current_cstart,
-            )
-            return True
-        if state.parsed_page.state == ParseState.NO_RESULTS and len(state.parsed_page.publications) == 0:
-            state.pages_fetched += 1
-            return True
-        state.pages_fetched += 1
-        state.publications.extend(state.parsed_page.publications)
-        state.next_cstart = _next_cstart_value(
-            articles_range=state.parsed_page.articles_range,
-            fallback=state.current_cstart + len(state.parsed_page.publications),
-        )
-        return False
-
-    async def _fetch_initial_page_context(
-        self,
-        *,
-        scholar_id: str,
-        start_cstart: int,
-        bounded_page_size: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-    ) -> tuple[FetchResult, ParsedProfilePage, str | None, list[dict[str, Any]], list[dict[str, Any]]]:
-        fetch_result, parsed_page, first_attempt_log = await self._fetch_and_parse_page_with_retry(
-            scholar_id=scholar_id,
-            cstart=start_cstart,
-            page_size=bounded_page_size,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-        )
-        first_page_fingerprint_sha256 = build_initial_page_fingerprint(parsed_page)
-        attempt_log = list(first_attempt_log)
-        page_logs = [
-            {
-                "page": 1,
-                "cstart": start_cstart,
-                "state": parsed_page.state.value,
-                "state_reason": parsed_page.state_reason,
-                "status_code": fetch_result.status_code,
-                "publication_count": len(parsed_page.publications),
-                "articles_range": parsed_page.articles_range,
-                "has_show_more_button": parsed_page.has_show_more_button,
-                "warning_codes": parsed_page.warnings,
-                "attempt_count": len(first_attempt_log),
-            }
-        ]
-        return fetch_result, parsed_page, first_page_fingerprint_sha256, attempt_log, page_logs
-
-    async def _paginate_loop(
-        self,
-        *,
-        scholar: ScholarProfile,
-        run: CrawlRun,
-        db_session: AsyncSession,
-        state: PagedLoopState,
-        bounded_max_pages: int,
-        request_delay_seconds: int,
-        bounded_page_size: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-    ) -> None:
-        # Cross-page canonical dedup state; grows across all pages of this scholar.
-        seen_canonical: set[str] = set()
-
-        if state.parsed_page.publications:
-            deduped_first = _dedupe_publication_candidates(
-                list(state.parsed_page.publications), seen_canonical=seen_canonical
-            )
-            if deduped_first:
-                discovered_count = await self._upsert_profile_publications(
-                    db_session, run=run, scholar=scholar, publications=deduped_first
-                )
-                state.discovered_publication_count += discovered_count
-
-        while state.parsed_page.has_show_more_button:
-            await db_session.refresh(run)
-            if run.status == RunStatus.CANCELED:
-                structured_log(
-                    logger,
-                    "info",
-                    "ingestion.pagination_canceled",
-                    run_id=run.id,
-                )
-                self._set_truncated_state(
-                    state=state,
-                    reason="run_canceled",
-                    continuation_cstart=state.current_cstart,
-                )
-                return
-
-            if self._should_stop_pagination(state=state, bounded_max_pages=bounded_max_pages):
-                return
-            next_fetch_result, next_parsed_page, next_attempt_log = await self._fetch_next_page(
-                scholar_id=scholar.scholar_id,
-                state=state,
-                request_delay_seconds=request_delay_seconds,
-                bounded_page_size=bounded_page_size,
-                network_error_retries=network_error_retries,
-                retry_backoff_seconds=retry_backoff_seconds,
-                rate_limit_retries=rate_limit_retries,
-                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-            )
-            self._record_next_page(
-                state=state,
-                fetch_result=next_fetch_result,
-                parsed_page=next_parsed_page,
-                page_attempt_log=next_attempt_log,
-            )
-
-            # Deduplicate against all publications already committed this run,
-            # then immediately commit the surviving candidates to the DB.
-            if next_parsed_page.publications:
-                deduped_next = _dedupe_publication_candidates(
-                    list(next_parsed_page.publications), seen_canonical=seen_canonical
-                )
-                if deduped_next:
-                    discovered_count = await self._upsert_profile_publications(
-                        db_session, run=run, scholar=scholar, publications=deduped_next
-                    )
-                    state.discovered_publication_count += discovered_count
-
-            if self._handle_page_state_transition(state=state):
-                return
-
-    @staticmethod
-    def _result_from_pagination_state(
-        *,
-        state: PagedLoopState,
-        first_page_fetch_result: FetchResult,
-        first_page_parsed_page: ParsedProfilePage,
-        first_page_fingerprint_sha256: str | None,
-    ) -> PagedParseResult:
-        return PagedParseResult(
-            fetch_result=state.fetch_result,
-            parsed_page=state.parsed_page,
-            first_page_fetch_result=first_page_fetch_result,
-            first_page_parsed_page=first_page_parsed_page,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-            publications=_dedupe_publication_candidates(state.publications),
-            attempt_log=state.attempt_log,
-            page_logs=state.page_logs,
-            pages_fetched=state.pages_fetched,
-            pages_attempted=state.pages_attempted,
-            has_more_remaining=state.has_more_remaining,
-            pagination_truncated_reason=state.pagination_truncated_reason,
-            continuation_cstart=state.continuation_cstart,
-            skipped_no_change=False,
-            discovered_publication_count=state.discovered_publication_count,
-        )
-
-    def _short_circuit_initial_page(
-        self,
-        *,
-        start_cstart: int,
-        previous_initial_page_fingerprint_sha256: str | None,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        first_page_fingerprint_sha256: str | None,
-        attempt_log: list[dict[str, Any]],
-        page_logs: list[dict[str, Any]],
-    ) -> PagedParseResult | None:
-        if self._should_skip_no_change(
-            start_cstart=start_cstart,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-            previous_initial_page_fingerprint_sha256=previous_initial_page_fingerprint_sha256,
-            parsed_page=parsed_page,
-        ):
-            return self._skip_no_change_result(
-                fetch_result=fetch_result,
-                parsed_page=parsed_page,
-                first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-                attempt_log=attempt_log,
-                page_logs=page_logs,
-            )
-        if parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}:
-            return self._initial_failure_result(
-                fetch_result=fetch_result,
-                parsed_page=parsed_page,
-                first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-                start_cstart=start_cstart,
-                attempt_log=attempt_log,
-                page_logs=page_logs,
-            )
-        return None
-
-    async def _fetch_and_parse_all_pages_with_retry(
-        self,
-        *,
-        scholar: ScholarProfile,
-        run: CrawlRun,
-        db_session: AsyncSession,
-        start_cstart: int,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages: int,
-        page_size: int,
-        previous_initial_page_fingerprint_sha256: str | None = None,
-    ) -> PagedParseResult:
-        bounded_max_pages = max(1, int(max_pages))
-        bounded_page_size = max(1, int(page_size))
-        (
-            fetch_result,
-            parsed_page,
-            first_page_fingerprint_sha256,
-            attempt_log,
-            page_logs,
-        ) = await self._fetch_initial_page_context(
-            scholar_id=scholar.scholar_id,
-            start_cstart=start_cstart,
-            bounded_page_size=bounded_page_size,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-        )
-        shortcut_result = self._short_circuit_initial_page(
-            start_cstart=start_cstart,
-            previous_initial_page_fingerprint_sha256=previous_initial_page_fingerprint_sha256,
-            fetch_result=fetch_result,
-            parsed_page=parsed_page,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-            attempt_log=attempt_log,
-            page_logs=page_logs,
-        )
-        if shortcut_result is not None:
-            return shortcut_result
-        state = self._build_loop_state(
-            start_cstart=start_cstart,
-            fetch_result=fetch_result,
-            parsed_page=parsed_page,
-            attempt_log=attempt_log,
-            page_logs=page_logs,
-        )
-        await self._paginate_loop(
-            scholar=scholar,
-            run=run,
-            db_session=db_session,
-            state=state,
-            bounded_max_pages=bounded_max_pages,
-            request_delay_seconds=request_delay_seconds,
-            bounded_page_size=bounded_page_size,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-        )
-        return self._result_from_pagination_state(
-            state=state,
-            first_page_fetch_result=fetch_result,
-            first_page_parsed_page=parsed_page,
-            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
-        )
-
     async def _run_is_canceled(
         self,
         db_session: AsyncSession,
@@ -2641,228 +1992,6 @@ class ScholarIngestionService:
                     enriched.append(p)
         return enriched
 
-    async def _upsert_profile_publications(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        publications: list[PublicationCandidate],
-    ) -> int:
-        # We no longer enrich inline here. Enrichment is now deferred to the end of the run.
-        seen_publication_ids: set[int] = set()
-        discovered_count = 0
-
-        for candidate in publications:
-            publication = await self._resolve_publication(db_session, candidate)
-            if publication.id in seen_publication_ids:
-                continue
-            seen_publication_ids.add(publication.id)
-
-            link_result = await db_session.execute(
-                select(ScholarPublication).where(
-                    ScholarPublication.scholar_profile_id == scholar.id,
-                    ScholarPublication.publication_id == publication.id,
-                )
-            )
-            link = link_result.scalar_one_or_none()
-            if link is not None:
-                continue
-
-            link = ScholarPublication(
-                scholar_profile_id=scholar.id,
-                publication_id=publication.id,
-                is_read=False,
-                first_seen_run_id=run.id,
-            )
-            db_session.add(link)
-            discovered_count += 1
-
-            await self._commit_discovered_publication(
-                db_session,
-                run=run,
-                scholar=scholar,
-                publication=publication,
-            )
-
-        if not scholar.baseline_completed:
-            scholar.baseline_completed = True
-
-        return discovered_count
-
-    async def _commit_discovered_publication(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        publication: Publication,
-    ) -> None:
-        run.new_pub_count = int(run.new_pub_count or 0) + 1
-        await db_session.commit()
-        await run_events.publish(
-            run_id=run.id,
-            event_type="publication_discovered",
-            data={
-                "publication_id": publication.id,
-                "title": publication.title_raw,
-                "pub_url": publication.pub_url,
-                "scholar_profile_id": scholar.id,
-                "scholar_label": scholar.display_name or scholar.scholar_id,
-                "first_seen_at": datetime.now(UTC).isoformat(),
-                "new_publication_count": int(run.new_pub_count or 0),
-            },
-        )
-
-    @staticmethod
-    def _validate_publication_candidate(candidate: PublicationCandidate) -> None:
-        if not candidate.title.strip():
-            raise RuntimeError("Publication candidate is missing title.")
-        if candidate.citation_count is not None and int(candidate.citation_count) < 0:
-            raise RuntimeError("Publication candidate has negative citation_count.")
-
-    async def _find_publication_by_cluster(
-        self,
-        db_session: AsyncSession,
-        *,
-        cluster_id: str | None,
-    ) -> Publication | None:
-        if not cluster_id:
-            return None
-        result = await db_session.execute(select(Publication).where(Publication.cluster_id == cluster_id))
-        return result.scalar_one_or_none()
-
-    async def _find_publication_by_fingerprint(
-        self,
-        db_session: AsyncSession,
-        *,
-        fingerprint: str,
-    ) -> Publication | None:
-        result = await db_session.execute(select(Publication).where(Publication.fingerprint_sha256 == fingerprint))
-        return result.scalar_one_or_none()
-
-    @staticmethod
-    def _select_existing_publication(
-        *,
-        cluster_publication: Publication | None,
-        fingerprint_publication: Publication | None,
-    ) -> Publication | None:
-        if cluster_publication is not None:
-            return cluster_publication
-        return fingerprint_publication
-
-    @staticmethod
-    def _compute_canonical_title_hash(title: str) -> str:
-        canonical = canonical_title_for_dedup(title)
-        return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
-
-    async def _find_publication_by_canonical_title_hash(
-        self,
-        db_session: AsyncSession,
-        *,
-        canonical_title_hash: str,
-    ) -> Publication | None:
-        result = await db_session.execute(
-            select(Publication).where(Publication.canonical_title_hash == canonical_title_hash)
-        )
-        return result.scalar_one_or_none()
-
-    async def _create_publication(
-        self,
-        db_session: AsyncSession,
-        *,
-        candidate: PublicationCandidate,
-        fingerprint: str,
-    ) -> Publication:
-        publication = Publication(
-            cluster_id=candidate.cluster_id,
-            fingerprint_sha256=fingerprint,
-            title_raw=candidate.title,
-            title_normalized=normalize_title(candidate.title),
-            canonical_title_hash=self._compute_canonical_title_hash(candidate.title),
-            year=candidate.year,
-            citation_count=int(candidate.citation_count or 0),
-            author_text=candidate.authors_text,
-            venue_text=candidate.venue_text,
-            pub_url=build_publication_url(candidate.title_url),
-            pdf_url=None,
-        )
-        db_session.add(publication)
-        await db_session.flush()
-        return publication
-
-    @staticmethod
-    def _update_existing_publication(
-        *,
-        publication: Publication,
-        candidate: PublicationCandidate,
-    ) -> None:
-        if candidate.cluster_id and publication.cluster_id is None:
-            publication.cluster_id = candidate.cluster_id
-        publication.title_raw = candidate.title
-        publication.title_normalized = normalize_title(candidate.title)
-        if candidate.year is not None:
-            publication.year = candidate.year
-        if candidate.citation_count is not None:
-            publication.citation_count = int(candidate.citation_count)
-        if candidate.authors_text:
-            publication.author_text = candidate.authors_text
-        if candidate.venue_text:
-            publication.venue_text = candidate.venue_text
-        if candidate.title_url:
-            publication.pub_url = build_publication_url(candidate.title_url)
-        first_doi_from_texts(candidate.title_url, candidate.venue_text, candidate.title)
-
-    async def _resolve_publication(
-        self,
-        db_session: AsyncSession,
-        candidate: PublicationCandidate,
-    ) -> Publication:
-        self._validate_publication_candidate(candidate)
-        fingerprint = build_publication_fingerprint(candidate)
-        cluster_publication = await self._find_publication_by_cluster(
-            db_session,
-            cluster_id=candidate.cluster_id,
-        )
-        fingerprint_publication = await self._find_publication_by_fingerprint(
-            db_session,
-            fingerprint=fingerprint,
-        )
-        publication = self._select_existing_publication(
-            cluster_publication=cluster_publication,
-            fingerprint_publication=fingerprint_publication,
-        )
-        if publication is None:
-            # Fallback: canonical title hash — catches cross-scholar noise variants
-            # (e.g. "Adam preprint (2014)" vs "Adam arXiv 2017" → same normalized form)
-            canonical_hash = self._compute_canonical_title_hash(candidate.title)
-            publication = await self._find_publication_by_canonical_title_hash(
-                db_session,
-                canonical_title_hash=canonical_hash,
-            )
-        if publication is None:
-            created = await self._create_publication(
-                db_session,
-                candidate=candidate,
-                fingerprint=fingerprint,
-            )
-            # Sync identifiers from local fields only for fast UI response
-            await identifier_service.sync_identifiers_for_publication_fields(
-                db_session,
-                publication=created,
-            )
-            return created
-        self._update_existing_publication(
-            publication=publication,
-            candidate=candidate,
-        )
-        # Sync identifiers from local fields only for fast UI response
-        await identifier_service.sync_identifiers_for_publication_fields(
-            db_session,
-            publication=publication,
-        )
-        return publication
-
     def _resolve_run_status(
         self,
         *,
diff --git a/app/services/ingestion/page_fetch.py b/app/services/ingestion/page_fetch.py
new file mode 100644
index 0000000..008cb6b
--- /dev/null
+++ b/app/services/ingestion/page_fetch.py
@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from app.logging_utils import structured_log
+from app.services.scholar.parser import (
+    ParsedProfilePage,
+    ParseState,
+    ScholarParserError,
+    parse_profile_page,
+)
+from app.services.scholar.source import FetchResult, ScholarSource
+
+logger = logging.getLogger(__name__)
+
+
+class PageFetcher:
+    """Fetches and parses a single Google Scholar profile page with retry logic."""
+
+    def __init__(self, *, source: ScholarSource) -> None:
+        self._source = source
+
+    async def fetch_profile_page(
+        self,
+        *,
+        scholar_id: str,
+        cstart: int,
+        page_size: int,
+    ) -> FetchResult:
+        try:
+            page_fetcher = getattr(self._source, "fetch_profile_page_html", None)
+            if callable(page_fetcher):
+                return await page_fetcher(
+                    scholar_id,
+                    cstart=cstart,
+                    pagesize=page_size,
+                )
+            if cstart <= 0:
+                return await self._source.fetch_profile_html(scholar_id)
+            return FetchResult(
+                requested_url=(
+                    f"https://scholar.google.com/citations?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
+                ),
+                status_code=None,
+                final_url=None,
+                body="",
+                error="source_does_not_support_pagination",
+            )
+        except Exception as exc:
+            logger.exception(
+                "ingestion.fetch_unexpected_error",
+                extra={
+                    "scholar_id": scholar_id,
+                    "cstart": cstart,
+                    "page_size": page_size,
+                },
+            )
+            return FetchResult(
+                requested_url=(
+                    f"https://scholar.google.com/citations?hl=en&user={scholar_id}&cstart={cstart}&pagesize={page_size}"
+                ),
+                status_code=None,
+                final_url=None,
+                body="",
+                error=str(exc),
+            )
+
+    # ── Parse helpers ────────────────────────────────────────────────
+
+    def parse_page_or_layout_error(
+        self,
+        *,
+        fetch_result: FetchResult,
+    ) -> ParsedProfilePage:
+        try:
+            return parse_profile_page(fetch_result)
+        except ScholarParserError as exc:
+            return self._parsed_page_from_parser_error(code=exc.code)
+
+    @staticmethod
+    def _parsed_page_from_parser_error(*, code: str) -> ParsedProfilePage:
+        return ParsedProfilePage(
+            state=ParseState.LAYOUT_CHANGED,
+            state_reason=code,
+            profile_name=None,
+            profile_image_url=None,
+            publications=[],
+            marker_counts={},
+            warnings=[code],
+            has_show_more_button=False,
+            has_operation_error_banner=False,
+            articles_range=None,
+        )
+
+    # ── Retry logic ──────────────────────────────────────────────────
+
+    @staticmethod
+    def _should_retry(
+        *,
+        parsed_page: ParsedProfilePage,
+        network_attempt_count: int,
+        rate_limit_attempt_count: int,
+        network_error_retries: int,
+        rate_limit_retries: int,
+    ) -> bool:
+        if parsed_page.state == ParseState.NETWORK_ERROR:
+            return network_attempt_count <= network_error_retries
+        if (
+            parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA
+            and parsed_page.state_reason == "blocked_http_429_rate_limited"
+        ):
+            return rate_limit_attempt_count <= rate_limit_retries
+        return False
+
+    @staticmethod
+    async def _sleep_backoff(
+        *,
+        scholar_id: str,
+        cstart: int,
+        network_attempt_count: int,
+        rate_limit_attempt_count: int,
+        retry_backoff_seconds: float,
+        rate_limit_backoff_seconds: float,
+        state_reason: str,
+    ) -> None:
+        if state_reason == "blocked_http_429_rate_limited":
+            sleep_seconds = rate_limit_backoff_seconds * rate_limit_attempt_count
+            attempt_label = rate_limit_attempt_count
+        else:
+            sleep_seconds = retry_backoff_seconds * (2 ** (network_attempt_count - 1))
+            attempt_label = network_attempt_count
+
+        structured_log(
+            logger,
+            "warning",
+            "ingestion.scholar_retry_scheduled",
+            scholar_id=scholar_id,
+            cstart=cstart,
+            attempt_count=attempt_label,
+            sleep_seconds=sleep_seconds,
+            state_reason=state_reason,
+        )
+        if sleep_seconds > 0:
+            await asyncio.sleep(sleep_seconds)
+
+    async def fetch_and_parse_with_retry(
+        self,
+        *,
+        scholar_id: str,
+        cstart: int,
+        page_size: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+    ) -> tuple[FetchResult, ParsedProfilePage, list[dict[str, Any]]]:
+        network_attempts = 0
+        rate_limit_attempts = 0
+        attempt_log: list[dict[str, Any]] = []
+        fetch_result: FetchResult | None = None
+        parsed_page: ParsedProfilePage | None = None
+
+        while True:
+            fetch_result = await self.fetch_profile_page(
+                scholar_id=scholar_id,
+                cstart=cstart,
+                page_size=page_size,
+            )
+            parsed_page = self.parse_page_or_layout_error(fetch_result=fetch_result)
+
+            if parsed_page.state == ParseState.NETWORK_ERROR:
+                network_attempts += 1
+                total_attempts = network_attempts
+            elif (
+                parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA
+                and parsed_page.state_reason == "blocked_http_429_rate_limited"
+            ):
+                rate_limit_attempts += 1
+                total_attempts = rate_limit_attempts
+            else:
+                total_attempts = network_attempts + rate_limit_attempts + 1
+
+            attempt_log.append(
+                {
+                    "attempt": total_attempts,
+                    "cstart": cstart,
+                    "state": parsed_page.state.value,
+                    "state_reason": parsed_page.state_reason,
+                    "status_code": fetch_result.status_code,
+                    "fetch_error": fetch_result.error,
+                }
+            )
+
+            if not self._should_retry(
+                parsed_page=parsed_page,
+                network_attempt_count=network_attempts,
+                rate_limit_attempt_count=rate_limit_attempts,
+                network_error_retries=network_error_retries,
+                rate_limit_retries=rate_limit_retries,
+            ):
+                break
+
+            await self._sleep_backoff(
+                scholar_id=scholar_id,
+                cstart=cstart,
+                network_attempt_count=network_attempts,
+                rate_limit_attempt_count=rate_limit_attempts,
+                retry_backoff_seconds=max(float(retry_backoff_seconds), 0.0),
+                rate_limit_backoff_seconds=max(float(rate_limit_backoff_seconds), 0.0),
+                state_reason=parsed_page.state_reason,
+            )
+
+        if fetch_result is None or parsed_page is None:
+            raise RuntimeError("Fetch-and-parse retry loop produced no result.")
+        return fetch_result, parsed_page, attempt_log
diff --git a/app/services/ingestion/pagination.py b/app/services/ingestion/pagination.py
new file mode 100644
index 0000000..9e761b8
--- /dev/null
+++ b/app/services/ingestion/pagination.py
@@ -0,0 +1,486 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from app.db.models import CrawlRun, RunStatus, ScholarProfile
+from app.logging_utils import structured_log
+from app.services.ingestion.fingerprints import (
+    _dedupe_publication_candidates,
+    _next_cstart_value,
+    build_initial_page_fingerprint,
+)
+from app.services.ingestion.page_fetch import PageFetcher
+from app.services.ingestion.types import PagedLoopState, PagedParseResult
+from app.services.scholar.parser import ParsedProfilePage, ParseState
+from app.services.scholar.source import FetchResult, ScholarSource
+
+logger = logging.getLogger(__name__)
+
+
+class PaginationEngine:
+    """Fetches and paginates Google Scholar profile pages.
+
+    Pure HTTP + parsing — no DB writes except via the provided upsert callback.
+    """
+
+    def __init__(self, *, source: ScholarSource) -> None:
+        self._source = source
+        self._fetcher = PageFetcher(source=source)
+
+    # ── No-change / initial failure short-circuits ───────────────────
+
+    @staticmethod
+    def _should_skip_no_change(
+        *,
+        start_cstart: int,
+        first_page_fingerprint_sha256: str | None,
+        previous_initial_page_fingerprint_sha256: str | None,
+        parsed_page: ParsedProfilePage,
+    ) -> bool:
+        return (
+            start_cstart <= 0
+            and first_page_fingerprint_sha256 is not None
+            and previous_initial_page_fingerprint_sha256 is not None
+            and first_page_fingerprint_sha256 == previous_initial_page_fingerprint_sha256
+            and parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS}
+        )
+
+    @staticmethod
+    def _skip_no_change_result(
+        *,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        first_page_fingerprint_sha256: str | None,
+        attempt_log: list[dict[str, Any]],
+        page_logs: list[dict[str, Any]],
+    ) -> PagedParseResult:
+        return PagedParseResult(
+            fetch_result=fetch_result,
+            parsed_page=parsed_page,
+            first_page_fetch_result=fetch_result,
+            first_page_parsed_page=parsed_page,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+            publications=[],
+            attempt_log=attempt_log,
+            page_logs=page_logs,
+            pages_fetched=1,
+            pages_attempted=1,
+            has_more_remaining=False,
+            pagination_truncated_reason=None,
+            continuation_cstart=None,
+            skipped_no_change=True,
+            discovered_publication_count=0,
+        )
+
+    @staticmethod
+    def _initial_failure_result(
+        *,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        first_page_fingerprint_sha256: str | None,
+        start_cstart: int,
+        attempt_log: list[dict[str, Any]],
+        page_logs: list[dict[str, Any]],
+    ) -> PagedParseResult:
+        continuation_cstart = start_cstart if parsed_page.state == ParseState.NETWORK_ERROR else None
+        return PagedParseResult(
+            fetch_result=fetch_result,
+            parsed_page=parsed_page,
+            first_page_fetch_result=fetch_result,
+            first_page_parsed_page=parsed_page,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+            publications=[],
+            attempt_log=attempt_log,
+            page_logs=page_logs,
+            pages_fetched=0,
+            pages_attempted=1,
+            has_more_remaining=False,
+            pagination_truncated_reason=None,
+            continuation_cstart=continuation_cstart,
+            skipped_no_change=False,
+            discovered_publication_count=0,
+        )
+
+    # ── Loop state management ────────────────────────────────────────
+
+    @staticmethod
+    def _build_loop_state(
+        *,
+        start_cstart: int,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        attempt_log: list[dict[str, Any]],
+        page_logs: list[dict[str, Any]],
+    ) -> PagedLoopState:
+        next_cstart = _next_cstart_value(
+            articles_range=parsed_page.articles_range,
+            fallback=start_cstart + len(parsed_page.publications),
+        )
+        return PagedLoopState(
+            fetch_result=fetch_result,
+            parsed_page=parsed_page,
+            attempt_log=attempt_log,
+            page_logs=page_logs,
+            publications=list(parsed_page.publications),
+            pages_fetched=1,
+            pages_attempted=1,
+            current_cstart=start_cstart,
+            next_cstart=next_cstart,
+        )
+
+    @staticmethod
+    def _set_truncated_state(
+        *,
+        state: PagedLoopState,
+        reason: str,
+        continuation_cstart: int,
+    ) -> None:
+        state.has_more_remaining = True
+        state.pagination_truncated_reason = reason
+        state.continuation_cstart = continuation_cstart
+
+    def _should_stop_pagination(self, *, state: PagedLoopState, bounded_max_pages: int) -> bool:
+        if state.pages_fetched >= bounded_max_pages:
+            self._set_truncated_state(
+                state=state,
+                reason="max_pages_reached",
+                continuation_cstart=(
+                    state.next_cstart if state.next_cstart > state.current_cstart else state.current_cstart
+                ),
+            )
+            return True
+        if state.next_cstart <= state.current_cstart:
+            self._set_truncated_state(
+                state=state,
+                reason="pagination_cursor_stalled",
+                continuation_cstart=state.current_cstart,
+            )
+            return True
+        return False
+
+    # ── Multi-page fetch helpers ─────────────────────────────────────
+
+    async def _fetch_next_page(
+        self,
+        *,
+        scholar_id: str,
+        state: PagedLoopState,
+        request_delay_seconds: int,
+        bounded_page_size: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+    ) -> tuple[FetchResult, ParsedProfilePage, list[dict[str, Any]]]:
+        if request_delay_seconds > 0:
+            await asyncio.sleep(float(request_delay_seconds))
+        state.current_cstart = state.next_cstart
+        return await self._fetcher.fetch_and_parse_with_retry(
+            scholar_id=scholar_id,
+            cstart=state.current_cstart,
+            page_size=bounded_page_size,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+        )
+
+    @staticmethod
+    def _record_next_page(
+        *,
+        state: PagedLoopState,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        page_attempt_log: list[dict[str, Any]],
+    ) -> None:
+        state.pages_attempted += 1
+        state.attempt_log.extend(page_attempt_log)
+        state.page_logs.append(
+            {
+                "page": state.pages_attempted,
+                "cstart": state.current_cstart,
+                "state": parsed_page.state.value,
+                "state_reason": parsed_page.state_reason,
+                "status_code": fetch_result.status_code,
+                "publication_count": len(parsed_page.publications),
+                "articles_range": parsed_page.articles_range,
+                "has_show_more_button": parsed_page.has_show_more_button,
+                "warning_codes": parsed_page.warnings,
+                "attempt_count": len(page_attempt_log),
+            }
+        )
+        state.fetch_result = fetch_result
+        state.parsed_page = parsed_page
+
+    def _handle_page_state_transition(self, *, state: PagedLoopState) -> bool:
+        if state.parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}:
+            self._set_truncated_state(
+                state=state,
+                reason=f"page_state_{state.parsed_page.state.value}",
+                continuation_cstart=state.current_cstart,
+            )
+            return True
+        if state.parsed_page.state == ParseState.NO_RESULTS and len(state.parsed_page.publications) == 0:
+            state.pages_fetched += 1
+            return True
+        state.pages_fetched += 1
+        state.publications.extend(state.parsed_page.publications)
+        state.next_cstart = _next_cstart_value(
+            articles_range=state.parsed_page.articles_range,
+            fallback=state.current_cstart + len(state.parsed_page.publications),
+        )
+        return False
+
+    async def _fetch_initial_page_context(
+        self,
+        *,
+        scholar_id: str,
+        start_cstart: int,
+        bounded_page_size: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+    ) -> tuple[FetchResult, ParsedProfilePage, str | None, list[dict[str, Any]], list[dict[str, Any]]]:
+        fetch_result, parsed_page, first_attempt_log = await self._fetcher.fetch_and_parse_with_retry(
+            scholar_id=scholar_id,
+            cstart=start_cstart,
+            page_size=bounded_page_size,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+        )
+        first_page_fingerprint_sha256 = build_initial_page_fingerprint(parsed_page)
+        attempt_log = list(first_attempt_log)
+        page_logs = [
+            {
+                "page": 1,
+                "cstart": start_cstart,
+                "state": parsed_page.state.value,
+                "state_reason": parsed_page.state_reason,
+                "status_code": fetch_result.status_code,
+                "publication_count": len(parsed_page.publications),
+                "articles_range": parsed_page.articles_range,
+                "has_show_more_button": parsed_page.has_show_more_button,
+                "warning_codes": parsed_page.warnings,
+                "attempt_count": len(first_attempt_log),
+            }
+        ]
+        return fetch_result, parsed_page, first_page_fingerprint_sha256, attempt_log, page_logs
+
+    # ── Pagination loop ──────────────────────────────────────────────
+
+    async def _paginate_loop(
+        self,
+        *,
+        scholar: ScholarProfile,
+        run: CrawlRun,
+        db_session: Any,
+        state: PagedLoopState,
+        bounded_max_pages: int,
+        request_delay_seconds: int,
+        bounded_page_size: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+        upsert_publications_fn: Any,
+    ) -> None:
+        seen_canonical: set[str] = set()
+
+        if state.parsed_page.publications:
+            deduped_first = _dedupe_publication_candidates(
+                list(state.parsed_page.publications), seen_canonical=seen_canonical
+            )
+            if deduped_first:
+                discovered_count = await upsert_publications_fn(
+                    db_session, run=run, scholar=scholar, publications=deduped_first
+                )
+                state.discovered_publication_count += discovered_count
+
+        while state.parsed_page.has_show_more_button:
+            await db_session.refresh(run)
+            if run.status == RunStatus.CANCELED:
+                structured_log(
+                    logger,
+                    "info",
+                    "ingestion.pagination_canceled",
+                    run_id=run.id,
+                )
+                self._set_truncated_state(
+                    state=state,
+                    reason="run_canceled",
+                    continuation_cstart=state.current_cstart,
+                )
+                return
+
+            if self._should_stop_pagination(state=state, bounded_max_pages=bounded_max_pages):
+                return
+            next_fetch_result, next_parsed_page, next_attempt_log = await self._fetch_next_page(
+                scholar_id=scholar.scholar_id,
+                state=state,
+                request_delay_seconds=request_delay_seconds,
+                bounded_page_size=bounded_page_size,
+                network_error_retries=network_error_retries,
+                retry_backoff_seconds=retry_backoff_seconds,
+                rate_limit_retries=rate_limit_retries,
+                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+            )
+            self._record_next_page(
+                state=state,
+                fetch_result=next_fetch_result,
+                parsed_page=next_parsed_page,
+                page_attempt_log=next_attempt_log,
+            )
+
+            if next_parsed_page.publications:
+                deduped_next = _dedupe_publication_candidates(
+                    list(next_parsed_page.publications), seen_canonical=seen_canonical
+                )
+                if deduped_next:
+                    discovered_count = await upsert_publications_fn(
+                        db_session, run=run, scholar=scholar, publications=deduped_next
+                    )
+                    state.discovered_publication_count += discovered_count
+
+            if self._handle_page_state_transition(state=state):
+                return
+
+    @staticmethod
+    def _result_from_pagination_state(
+        *,
+        state: PagedLoopState,
+        first_page_fetch_result: FetchResult,
+        first_page_parsed_page: ParsedProfilePage,
+        first_page_fingerprint_sha256: str | None,
+    ) -> PagedParseResult:
+        return PagedParseResult(
+            fetch_result=state.fetch_result,
+            parsed_page=state.parsed_page,
+            first_page_fetch_result=first_page_fetch_result,
+            first_page_parsed_page=first_page_parsed_page,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+            publications=_dedupe_publication_candidates(state.publications),
+            attempt_log=state.attempt_log,
+            page_logs=state.page_logs,
+            pages_fetched=state.pages_fetched,
+            pages_attempted=state.pages_attempted,
+            has_more_remaining=state.has_more_remaining,
+            pagination_truncated_reason=state.pagination_truncated_reason,
+            continuation_cstart=state.continuation_cstart,
+            skipped_no_change=False,
+            discovered_publication_count=state.discovered_publication_count,
+        )
+
+    def _short_circuit_initial_page(
+        self,
+        *,
+        start_cstart: int,
+        previous_initial_page_fingerprint_sha256: str | None,
+        fetch_result: FetchResult,
+        parsed_page: ParsedProfilePage,
+        first_page_fingerprint_sha256: str | None,
+        attempt_log: list[dict[str, Any]],
+        page_logs: list[dict[str, Any]],
+    ) -> PagedParseResult | None:
+        if self._should_skip_no_change(
+            start_cstart=start_cstart,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+            previous_initial_page_fingerprint_sha256=previous_initial_page_fingerprint_sha256,
+            parsed_page=parsed_page,
+        ):
+            return self._skip_no_change_result(
+                fetch_result=fetch_result,
+                parsed_page=parsed_page,
+                first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+                attempt_log=attempt_log,
+                page_logs=page_logs,
+            )
+        if parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}:
+            return self._initial_failure_result(
+                fetch_result=fetch_result,
+                parsed_page=parsed_page,
+                first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+                start_cstart=start_cstart,
+                attempt_log=attempt_log,
+                page_logs=page_logs,
+            )
+        return None
+
+    # ── Public entry point ───────────────────────────────────────────
+
+    async def fetch_and_parse_all_pages(
+        self,
+        *,
+        scholar: ScholarProfile,
+        run: CrawlRun,
+        db_session: Any,
+        start_cstart: int,
+        request_delay_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        rate_limit_retries: int,
+        rate_limit_backoff_seconds: float,
+        max_pages: int,
+        page_size: int,
+        previous_initial_page_fingerprint_sha256: str | None = None,
+        upsert_publications_fn: Any = None,
+    ) -> PagedParseResult:
+        bounded_max_pages = max(1, int(max_pages))
+        bounded_page_size = max(1, int(page_size))
+        (
+            fetch_result,
+            parsed_page,
+            first_page_fingerprint_sha256,
+            attempt_log,
+            page_logs,
+        ) = await self._fetch_initial_page_context(
+            scholar_id=scholar.scholar_id,
+            start_cstart=start_cstart,
+            bounded_page_size=bounded_page_size,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+        )
+        shortcut_result = self._short_circuit_initial_page(
+            start_cstart=start_cstart,
+            previous_initial_page_fingerprint_sha256=previous_initial_page_fingerprint_sha256,
+            fetch_result=fetch_result,
+            parsed_page=parsed_page,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+            attempt_log=attempt_log,
+            page_logs=page_logs,
+        )
+        if shortcut_result is not None:
+            return shortcut_result
+        state = self._build_loop_state(
+            start_cstart=start_cstart,
+            fetch_result=fetch_result,
+            parsed_page=parsed_page,
+            attempt_log=attempt_log,
+            page_logs=page_logs,
+        )
+        await self._paginate_loop(
+            scholar=scholar,
+            run=run,
+            db_session=db_session,
+            state=state,
+            bounded_max_pages=bounded_max_pages,
+            request_delay_seconds=request_delay_seconds,
+            bounded_page_size=bounded_page_size,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+            upsert_publications_fn=upsert_publications_fn,
+        )
+        return self._result_from_pagination_state(
+            state=state,
+            first_page_fetch_result=fetch_result,
+            first_page_parsed_page=parsed_page,
+            first_page_fingerprint_sha256=first_page_fingerprint_sha256,
+        )
diff --git a/app/services/ingestion/publication_upsert.py b/app/services/ingestion/publication_upsert.py
new file mode 100644
index 0000000..9d1a6b7
--- /dev/null
+++ b/app/services/ingestion/publication_upsert.py
@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import hashlib
+import logging
+from datetime import UTC, datetime
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import CrawlRun, Publication, ScholarProfile, ScholarPublication
+from app.services.doi.normalize import first_doi_from_texts
+from app.services.ingestion.fingerprints import (
+    build_publication_fingerprint,
+    build_publication_url,
+    canonical_title_for_dedup,
+    normalize_title,
+)
+from app.services.publication_identifiers import application as identifier_service
+from app.services.runs.events import run_events
+from app.services.scholar.parser import PublicationCandidate
+
+logger = logging.getLogger(__name__)
+
+
+def validate_publication_candidate(candidate: PublicationCandidate) -> None:
+    if not candidate.title.strip():
+        raise RuntimeError("Publication candidate is missing title.")
+    if candidate.citation_count is not None and int(candidate.citation_count) < 0:
+        raise RuntimeError("Publication candidate has negative citation_count.")
+
+
+async def find_publication_by_cluster(
+    db_session: AsyncSession,
+    *,
+    cluster_id: str | None,
+) -> Publication | None:
+    if not cluster_id:
+        return None
+    result = await db_session.execute(select(Publication).where(Publication.cluster_id == cluster_id))
+    return result.scalar_one_or_none()
+
+
+async def find_publication_by_fingerprint(
+    db_session: AsyncSession,
+    *,
+    fingerprint: str,
+) -> Publication | None:
+    result = await db_session.execute(select(Publication).where(Publication.fingerprint_sha256 == fingerprint))
+    return result.scalar_one_or_none()
+
+
+def select_existing_publication(
+    *,
+    cluster_publication: Publication | None,
+    fingerprint_publication: Publication | None,
+) -> Publication | None:
+    if cluster_publication is not None:
+        return cluster_publication
+    return fingerprint_publication
+
+
+def compute_canonical_title_hash(title: str) -> str:
+    canonical = canonical_title_for_dedup(title)
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+async def find_publication_by_canonical_title_hash(
+    db_session: AsyncSession,
+    *,
+    canonical_title_hash: str,
+) -> Publication | None:
+    result = await db_session.execute(
+        select(Publication).where(Publication.canonical_title_hash == canonical_title_hash)
+    )
+    return result.scalar_one_or_none()
+
+
+async def create_publication(
+    db_session: AsyncSession,
+    *,
+    candidate: PublicationCandidate,
+    fingerprint: str,
+) -> Publication:
+    publication = Publication(
+        cluster_id=candidate.cluster_id,
+        fingerprint_sha256=fingerprint,
+        title_raw=candidate.title,
+        title_normalized=normalize_title(candidate.title),
+        canonical_title_hash=compute_canonical_title_hash(candidate.title),
+        year=candidate.year,
+        citation_count=int(candidate.citation_count or 0),
+        author_text=candidate.authors_text,
+        venue_text=candidate.venue_text,
+        pub_url=build_publication_url(candidate.title_url),
+        pdf_url=None,
+    )
+    db_session.add(publication)
+    await db_session.flush()
+    return publication
+
+
+def update_existing_publication(
+    *,
+    publication: Publication,
+    candidate: PublicationCandidate,
+) -> None:
+    if candidate.cluster_id and publication.cluster_id is None:
+        publication.cluster_id = candidate.cluster_id
+    publication.title_raw = candidate.title
+    publication.title_normalized = normalize_title(candidate.title)
+    if candidate.year is not None:
+        publication.year = candidate.year
+    if candidate.citation_count is not None:
+        publication.citation_count = int(candidate.citation_count)
+    if candidate.authors_text:
+        publication.author_text = candidate.authors_text
+    if candidate.venue_text:
+        publication.venue_text = candidate.venue_text
+    if candidate.title_url:
+        publication.pub_url = build_publication_url(candidate.title_url)
+    first_doi_from_texts(candidate.title_url, candidate.venue_text, candidate.title)
+
+
+async def resolve_publication(
+    db_session: AsyncSession,
+    candidate: PublicationCandidate,
+) -> Publication:
+    validate_publication_candidate(candidate)
+    fingerprint = build_publication_fingerprint(candidate)
+    cluster_publication = await find_publication_by_cluster(
+        db_session,
+        cluster_id=candidate.cluster_id,
+    )
+    fingerprint_publication = await find_publication_by_fingerprint(
+        db_session,
+        fingerprint=fingerprint,
+    )
+    publication = select_existing_publication(
+        cluster_publication=cluster_publication,
+        fingerprint_publication=fingerprint_publication,
+    )
+    if publication is None:
+        canonical_hash = compute_canonical_title_hash(candidate.title)
+        publication = await find_publication_by_canonical_title_hash(
+            db_session,
+            canonical_title_hash=canonical_hash,
+        )
+    if publication is None:
+        created = await create_publication(
+            db_session,
+            candidate=candidate,
+            fingerprint=fingerprint,
+        )
+        await identifier_service.sync_identifiers_for_publication_fields(
+            db_session,
+            publication=created,
+        )
+        return created
+    update_existing_publication(
+        publication=publication,
+        candidate=candidate,
+    )
+    await identifier_service.sync_identifiers_for_publication_fields(
+        db_session,
+        publication=publication,
+    )
+    return publication
+
+
+async def upsert_profile_publications(
+    db_session: AsyncSession,
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    publications: list[PublicationCandidate],
+) -> int:
+    seen_publication_ids: set[int] = set()
+    discovered_count = 0
+
+    for candidate in publications:
+        publication = await resolve_publication(db_session, candidate)
+        if publication.id in seen_publication_ids:
+            continue
+        seen_publication_ids.add(publication.id)
+
+        link_result = await db_session.execute(
+            select(ScholarPublication).where(
+                ScholarPublication.scholar_profile_id == scholar.id,
+                ScholarPublication.publication_id == publication.id,
+            )
+        )
+        link = link_result.scalar_one_or_none()
+        if link is not None:
+            continue
+
+        link = ScholarPublication(
+            scholar_profile_id=scholar.id,
+            publication_id=publication.id,
+            is_read=False,
+            first_seen_run_id=run.id,
+        )
+        db_session.add(link)
+        discovered_count += 1
+
+        await commit_discovered_publication(
+            db_session,
+            run=run,
+            scholar=scholar,
+            publication=publication,
+        )
+
+    if not scholar.baseline_completed:
+        scholar.baseline_completed = True
+
+    return discovered_count
+
+
+async def commit_discovered_publication(
+    db_session: AsyncSession,
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    publication: Publication,
+) -> None:
+    run.new_pub_count = int(run.new_pub_count or 0) + 1
+    await db_session.commit()
+    await run_events.publish(
+        run_id=run.id,
+        event_type="publication_discovered",
+        data={
+            "publication_id": publication.id,
+            "title": publication.title_raw,
+            "pub_url": publication.pub_url,
+            "scholar_profile_id": scholar.id,
+            "scholar_label": scholar.display_name or scholar.scholar_id,
+            "first_seen_at": datetime.now(UTC).isoformat(),
+            "new_publication_count": int(run.new_pub_count or 0),
+        },
+    )
diff --git a/app/services/portability/normalize.py b/app/services/portability/normalize.py
index 41e017f..9353d2a 100644
--- a/app/services/portability/normalize.py
+++ b/app/services/portability/normalize.py
@@ -3,7 +3,7 @@ from __future__ import annotations
 import hashlib
 from typing import Any
 
-from app.services.ingestion.application import normalize_title
+from app.services.ingestion.fingerprints import normalize_title
 from app.services.portability.constants import (
     MAX_IMPORT_PUBLICATIONS,
     MAX_IMPORT_SCHOLARS,
diff --git a/app/services/portability/publication_import.py b/app/services/portability/publication_import.py
index a347f4a..e2eb96a 100644
--- a/app/services/portability/publication_import.py
+++ b/app/services/portability/publication_import.py
@@ -7,7 +7,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import Publication, ScholarProfile, ScholarPublication
 from app.services.doi.normalize import normalize_doi
-from app.services.ingestion.application import build_publication_url, normalize_title
+from app.services.ingestion.fingerprints import build_publication_url, normalize_title
 from app.services.portability.normalize import (
     _normalize_citation_count,
     _normalize_optional_text,
diff --git a/tests/integration/test_run_lifecycle_consistency.py b/tests/integration/test_run_lifecycle_consistency.py
index 7592abf..f8239e4 100644
--- a/tests/integration/test_run_lifecycle_consistency.py
+++ b/tests/integration/test_run_lifecycle_consistency.py
@@ -326,7 +326,6 @@ async def test_partial_discovery_exception_keeps_new_pub_count_consistent(
     db_session.add_all([run, publication])
     await db_session.commit()
 
-    service = ScholarIngestionService(source=object())
     call_count = 0
 
     async def _resolve_publication_stub(*_args: Any, **_kwargs: Any) -> Publication:
@@ -336,7 +335,9 @@ async def test_partial_discovery_exception_keeps_new_pub_count_consistent(
             return publication
         raise RuntimeError("mid_page_failure")
 
-    monkeypatch.setattr(service, "_resolve_publication", _resolve_publication_stub)
+    from app.services.ingestion import publication_upsert
+
+    monkeypatch.setattr(publication_upsert, "resolve_publication", _resolve_publication_stub)
 
     from app.db.models import ScholarProfile
     from app.services.scholar.parser_types import PublicationCandidate
@@ -368,7 +369,7 @@ async def test_partial_discovery_exception_keeps_new_pub_count_consistent(
     ]
 
     with pytest.raises(RuntimeError, match="mid_page_failure"):
-        await service._upsert_profile_publications(
+        await publication_upsert.upsert_profile_publications(
             db_session,
             run=run,
             scholar=scholar,
-- 
2.49.1


From 6379c97e90ca20f2ffa18171e4baa656edd0ba55 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 14:19:39 +0100
Subject: [PATCH 25/38] decompose application.py into enrichment, scholar
 processing, run completion

---
 .env.example                                  |    4 +
 DECOMPOSITION_SLICES.md                       |   14 +-
 app/api/router.py                             |    3 +-
 app/api/routers/admin_settings.py             |  104 +
 app/api/schemas.py                            |  945 ---------
 app/api/schemas/__init__.py                   |    7 +
 app/api/schemas/admin.py                      |  314 +++
 app/api/schemas/auth.py                       |   73 +
 app/api/schemas/common.py                     |   39 +
 app/api/schemas/publications.py               |  151 ++
 app/api/schemas/runs.py                       |  226 +++
 app/api/schemas/scholars.py                   |  153 ++
 app/api/schemas/settings.py                   |   54 +
 app/services/ingestion/application.py         | 1749 ++---------------
 app/services/ingestion/enrichment.py          |  323 +++
 app/services/ingestion/run_completion.py      |  417 ++++
 app/services/ingestion/scholar_processing.py  |  614 ++++++
 app/services/scholar/source.py                |   70 +-
 app/services/scholar/state_detection.py       |   12 +-
 app/settings.py                               |    7 +
 frontend/src/features/settings/index.ts       |   24 +
 frontend/src/pages/SettingsPage.vue           |   87 +
 tests/integration/test_api_v1.py              |   55 +
 tests/integration/test_deferred_enrichment.py |    7 +-
 tests/unit/test_ingestion_arxiv_rate_limit.py |    8 +-
 .../unit/test_ingestion_progress_reporting.py |    8 +-
 tests/unit/test_scholar_parser.py             |   15 +
 tests/unit/test_scholar_source.py             |   75 +
 28 files changed, 2982 insertions(+), 2576 deletions(-)
 create mode 100644 app/api/routers/admin_settings.py
 delete mode 100644 app/api/schemas.py
 create mode 100644 app/api/schemas/__init__.py
 create mode 100644 app/api/schemas/admin.py
 create mode 100644 app/api/schemas/auth.py
 create mode 100644 app/api/schemas/common.py
 create mode 100644 app/api/schemas/publications.py
 create mode 100644 app/api/schemas/runs.py
 create mode 100644 app/api/schemas/scholars.py
 create mode 100644 app/api/schemas/settings.py
 create mode 100644 app/services/ingestion/enrichment.py
 create mode 100644 app/services/ingestion/run_completion.py
 create mode 100644 app/services/ingestion/scholar_processing.py

diff --git a/.env.example b/.env.example
index e2180ba..17e0363 100644
--- a/.env.example
+++ b/.env.example
@@ -115,6 +115,10 @@ SCHOLAR_NAME_SEARCH_COOLDOWN_BLOCK_THRESHOLD=1
 SCHOLAR_NAME_SEARCH_COOLDOWN_SECONDS=1800
 SCHOLAR_NAME_SEARCH_ALERT_RETRY_COUNT_THRESHOLD=2
 SCHOLAR_NAME_SEARCH_ALERT_COOLDOWN_REJECTIONS_THRESHOLD=3
+SCHOLAR_HTTP_USER_AGENT=
+SCHOLAR_HTTP_ROTATE_USER_AGENT=0
+SCHOLAR_HTTP_ACCEPT_LANGUAGE=en-US,en;q=0.9
+SCHOLAR_HTTP_COOKIE=
 
 # ------------------------------
 # OA Enrichment + PDF Resolution
diff --git a/DECOMPOSITION_SLICES.md b/DECOMPOSITION_SLICES.md
index 8e22261..87604ae 100644
--- a/DECOMPOSITION_SLICES.md
+++ b/DECOMPOSITION_SLICES.md
@@ -26,7 +26,7 @@ This file contains self-contained decomposition prompts ("slices") to bring the
 |---|-------|--------|
 | 1 | Schema split | **DONE** |
 | 2 | Ingestion: pagination + publication upsert | **DONE** |
-| 3 | Ingestion: enrichment + scholar processing + run completion | pending |
+| 3 | Ingestion: enrichment + scholar processing + run completion | **DONE** |
 | 4 | Scholars service + PDF queue | pending |
 | 5 | Routers + scheduler | pending |
 
@@ -63,7 +63,17 @@ Also fixed two external import paths (`portability/normalize.py`, `portability/p
 
 ---
 
-## Slice 3: Decompose `app/services/ingestion/application.py` — enrichment, scholar processing, run completion
+## Slice 3: Decompose `app/services/ingestion/application.py` — enrichment, scholar processing, run completion — DONE
+
+Completed. Extracted four logical chunks from `application.py` (2,085 → 635 lines):
+
+| File | Lines | Contents |
+|---|---|---|
+| `app/services/ingestion/enrichment.py` | 323 | `EnrichmentRunner` class — OpenAlex enrichment, identifier discovery, dedup sweep |
+| `app/services/ingestion/scholar_processing.py` | 614 | `process_scholar`, `run_scholar_iteration`, continuation queue, outcome resolution |
+| `app/services/ingestion/run_completion.py` | 417 | `complete_run_for_user`, failure summary, alert summary, safety outcome, progress tracking |
+
+Also updated two tests (`test_ingestion_arxiv_rate_limit.py`, `test_ingestion_progress_reporting.py`) and one integration test (`test_deferred_enrichment.py`) to import from new modules.
 
 **Why:** Three remaining logical chunks. Extracting all three brings `application.py` down to ~500 lines (the orchestration spine).
 
diff --git a/app/api/router.py b/app/api/router.py
index a11d98a..1b97d07 100644
--- a/app/api/router.py
+++ b/app/api/router.py
@@ -2,11 +2,12 @@ from __future__ import annotations
 
 from fastapi import APIRouter
 
-from app.api.routers import admin, admin_dbops, auth, publications, runs, scholars, settings
+from app.api.routers import admin, admin_dbops, admin_settings, auth, publications, runs, scholars, settings
 
 router = APIRouter(prefix="/api/v1")
 router.include_router(auth.router)
 router.include_router(admin.router)
+router.include_router(admin_settings.router)
 router.include_router(admin_dbops.router)
 router.include_router(scholars.router)
 router.include_router(settings.router)
diff --git a/app/api/routers/admin_settings.py b/app/api/routers/admin_settings.py
new file mode 100644
index 0000000..c909874
--- /dev/null
+++ b/app/api/routers/admin_settings.py
@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, Depends, Request
+
+from app.api.deps import get_api_admin_user
+from app.api.errors import ApiException
+from app.api.responses import success_payload
+from app.api.schemas import (
+    AdminScholarHttpSettingsEnvelope,
+    AdminScholarHttpSettingsUpdateRequest,
+)
+from app.db.models import User
+from app.logging_utils import structured_log
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/admin/settings", tags=["api-admin-settings"])
+_MAX_USER_AGENT_LENGTH = 512
+_MAX_ACCEPT_LANGUAGE_LENGTH = 128
+_MAX_COOKIE_LENGTH = 8192
+
+
+def _normalize_header_value(value: str, *, field_name: str, max_length: int) -> str:
+    normalized = value.strip()
+    if len(normalized) > max_length:
+        raise ApiException(
+            status_code=400,
+            code="invalid_admin_setting",
+            message=f"{field_name} must be {max_length} characters or fewer.",
+        )
+    return normalized
+
+
+def _serialize_scholar_http_settings() -> dict[str, object]:
+    return {
+        "user_agent": settings.scholar_http_user_agent,
+        "rotate_user_agent": bool(settings.scholar_http_rotate_user_agent),
+        "accept_language": settings.scholar_http_accept_language,
+        "cookie": settings.scholar_http_cookie,
+    }
+
+
+def _apply_scholar_http_settings(payload: AdminScholarHttpSettingsUpdateRequest) -> None:
+    user_agent = _normalize_header_value(
+        payload.user_agent,
+        field_name="user_agent",
+        max_length=_MAX_USER_AGENT_LENGTH,
+    )
+    accept_language = _normalize_header_value(
+        payload.accept_language,
+        field_name="accept_language",
+        max_length=_MAX_ACCEPT_LANGUAGE_LENGTH,
+    )
+    cookie = _normalize_header_value(
+        payload.cookie,
+        field_name="cookie",
+        max_length=_MAX_COOKIE_LENGTH,
+    )
+    object.__setattr__(settings, "scholar_http_user_agent", user_agent)
+    object.__setattr__(settings, "scholar_http_rotate_user_agent", bool(payload.rotate_user_agent))
+    object.__setattr__(settings, "scholar_http_accept_language", accept_language)
+    object.__setattr__(settings, "scholar_http_cookie", cookie)
+
+
+@router.get(
+    "/scholar-http",
+    response_model=AdminScholarHttpSettingsEnvelope,
+)
+async def get_scholar_http_settings(
+    request: Request,
+    admin_user: User = Depends(get_api_admin_user),
+):
+    structured_log(
+        logger,
+        "info",
+        "api.admin.settings.scholar_http_read",
+        admin_user_id=int(admin_user.id),
+    )
+    return success_payload(request, data=_serialize_scholar_http_settings())
+
+
+@router.put(
+    "/scholar-http",
+    response_model=AdminScholarHttpSettingsEnvelope,
+)
+async def update_scholar_http_settings(
+    payload: AdminScholarHttpSettingsUpdateRequest,
+    request: Request,
+    admin_user: User = Depends(get_api_admin_user),
+):
+    _apply_scholar_http_settings(payload)
+    structured_log(
+        logger,
+        "info",
+        "api.admin.settings.scholar_http_updated",
+        admin_user_id=int(admin_user.id),
+        rotate_user_agent=bool(settings.scholar_http_rotate_user_agent),
+        user_agent_set=bool(settings.scholar_http_user_agent.strip()),
+        cookie_set=bool(settings.scholar_http_cookie.strip()),
+    )
+    return success_payload(request, data=_serialize_scholar_http_settings())
diff --git a/app/api/schemas.py b/app/api/schemas.py
deleted file mode 100644
index 0b7db35..0000000
--- a/app/api/schemas.py
+++ /dev/null
@@ -1,945 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-from typing import Any, Literal
-
-from pydantic import BaseModel, ConfigDict, Field, model_validator
-
-
-class ApiMeta(BaseModel):
-    request_id: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ApiErrorData(BaseModel):
-    code: str
-    message: str
-    details: Any | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ApiErrorEnvelope(BaseModel):
-    error: ApiErrorData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MessageData(BaseModel):
-    message: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MessageEnvelope(BaseModel):
-    data: MessageData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class SessionUserData(BaseModel):
-    id: int
-    email: str
-    is_admin: bool
-    is_active: bool
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AuthMeData(BaseModel):
-    authenticated: bool
-    csrf_token: str
-    user: SessionUserData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AuthMeEnvelope(BaseModel):
-    data: AuthMeData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class CsrfBootstrapData(BaseModel):
-    csrf_token: str
-    authenticated: bool
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class CsrfBootstrapEnvelope(BaseModel):
-    data: CsrfBootstrapData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class LoginRequest(BaseModel):
-    email: str
-    password: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class LoginData(BaseModel):
-    authenticated: bool
-    csrf_token: str
-    user: SessionUserData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class LoginEnvelope(BaseModel):
-    data: LoginData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ChangePasswordRequest(BaseModel):
-    current_password: str
-    new_password: str
-    confirm_password: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarItemData(BaseModel):
-    id: int
-    scholar_id: str
-    display_name: str | None
-    profile_image_url: str | None
-    profile_image_source: str
-    is_enabled: bool
-    baseline_completed: bool
-    last_run_dt: datetime | None
-    last_run_status: str | None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarsListData(BaseModel):
-    scholars: list[ScholarItemData]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarsListEnvelope(BaseModel):
-    data: ScholarsListData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarCreateRequest(BaseModel):
-    scholar_id: str
-    profile_image_url: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarEnvelope(BaseModel):
-    data: ScholarItemData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarSearchCandidateData(BaseModel):
-    scholar_id: str
-    display_name: str
-    affiliation: str | None
-    email_domain: str | None
-    cited_by_count: int | None
-    interests: list[str] = Field(default_factory=list)
-    profile_url: str
-    profile_image_url: str | None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarSearchData(BaseModel):
-    query: str
-    state: str
-    state_reason: str
-    action_hint: str | None = None
-    candidates: list[ScholarSearchCandidateData]
-    warnings: list[str] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarSearchEnvelope(BaseModel):
-    data: ScholarSearchData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarImageUrlUpdateRequest(BaseModel):
-    image_url: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScholarExportItemData(BaseModel):
-    scholar_id: str
-    display_name: str | None = None
-    is_enabled: bool = True
-    profile_image_override_url: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class PublicationExportItemData(BaseModel):
-    scholar_id: str
-    cluster_id: str | None = None
-    fingerprint_sha256: str | None = None
-    title: str
-    year: int | None = None
-    citation_count: int = 0
-    author_text: str | None = None
-    venue_text: str | None = None
-    pub_url: str | None = None
-    pdf_url: str | None = None
-    is_read: bool = False
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DataExportData(BaseModel):
-    schema_version: int
-    exported_at: str
-    scholars: list[ScholarExportItemData]
-    publications: list[PublicationExportItemData]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DataExportEnvelope(BaseModel):
-    data: DataExportData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DataImportRequest(BaseModel):
-    schema_version: int | None = None
-    scholars: list[ScholarExportItemData] = Field(default_factory=list)
-    publications: list[PublicationExportItemData] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DataImportResultData(BaseModel):
-    scholars_created: int
-    scholars_updated: int
-    publications_created: int
-    publications_updated: int
-    links_created: int
-    links_updated: int
-    skipped_records: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DataImportEnvelope(BaseModel):
-    data: DataImportResultData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunListItemData(BaseModel):
-    id: int
-    trigger_type: str
-    status: str
-    start_dt: datetime
-    end_dt: datetime | None
-    scholar_count: int
-    new_publication_count: int
-    failed_count: int
-    partial_count: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunsListData(BaseModel):
-    runs: list[RunListItemData]
-    safety_state: ScrapeSafetyStateData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunsListEnvelope(BaseModel):
-    data: RunsListData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunSummaryData(BaseModel):
-    succeeded_count: int
-    failed_count: int
-    partial_count: int
-    failed_state_counts: dict[str, int] = Field(default_factory=dict)
-    failed_reason_counts: dict[str, int] = Field(default_factory=dict)
-    scrape_failure_counts: dict[str, int] = Field(default_factory=dict)
-    retry_counts: dict[str, int] = Field(default_factory=dict)
-    alert_thresholds: dict[str, int] = Field(default_factory=dict)
-    alert_flags: dict[str, bool] = Field(default_factory=dict)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScrapeSafetyCountersData(BaseModel):
-    consecutive_blocked_runs: int = 0
-    consecutive_network_runs: int = 0
-    cooldown_entry_count: int = 0
-    blocked_start_count: int = 0
-    last_blocked_failure_count: int = 0
-    last_network_failure_count: int = 0
-    last_evaluated_run_id: int | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ScrapeSafetyStateData(BaseModel):
-    cooldown_active: bool
-    cooldown_reason: str | None = None
-    cooldown_reason_label: str | None = None
-    cooldown_until: datetime | None = None
-    cooldown_remaining_seconds: int = 0
-    recommended_action: str | None = None
-    counters: ScrapeSafetyCountersData = Field(default_factory=ScrapeSafetyCountersData)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunAttemptLogData(BaseModel):
-    attempt: int
-    cstart: int
-    state: str | None = None
-    state_reason: str | None = None
-    status_code: int | None = None
-    fetch_error: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunPageLogData(BaseModel):
-    page: int
-    cstart: int
-    state: str
-    state_reason: str | None = None
-    status_code: int | None = None
-    publication_count: int = 0
-    attempt_count: int = 0
-    has_show_more_button: bool = False
-    articles_range: str | None = None
-    warning_codes: list[str] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunDebugData(BaseModel):
-    status_code: int | None = None
-    final_url: str | None = None
-    fetch_error: str | None = None
-    body_sha256: str | None = None
-    body_length: int | None = None
-    has_show_more_button: bool | None = None
-    articles_range: str | None = None
-    state_reason: str | None = None
-    warning_codes: list[str] = Field(default_factory=list)
-    marker_counts_nonzero: dict[str, int] = Field(default_factory=dict)
-    page_logs: list[RunPageLogData] = Field(default_factory=list)
-    attempt_log: list[RunAttemptLogData] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunScholarResultData(BaseModel):
-    scholar_profile_id: int
-    scholar_id: str
-    state: str
-    state_reason: str | None = None
-    outcome: str
-    attempt_count: int = 0
-    publication_count: int = 0
-    start_cstart: int = 0
-    continuation_cstart: int | None = None
-    continuation_enqueued: bool = False
-    continuation_cleared: bool = False
-    warnings: list[str] = Field(default_factory=list)
-    error: str | None = None
-    debug: RunDebugData | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunDetailData(BaseModel):
-    run: RunListItemData
-    summary: RunSummaryData
-    scholar_results: list[RunScholarResultData]
-    safety_state: ScrapeSafetyStateData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RunDetailEnvelope(BaseModel):
-    data: RunDetailData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ManualRunData(BaseModel):
-    run_id: int
-    status: str
-    scholar_count: int
-    succeeded_count: int
-    failed_count: int
-    partial_count: int
-    new_publication_count: int
-    reused_existing_run: bool
-    idempotency_key: str | None = None
-    safety_state: ScrapeSafetyStateData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ManualRunEnvelope(BaseModel):
-    data: ManualRunData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueItemData(BaseModel):
-    id: int
-    scholar_profile_id: int
-    scholar_label: str
-    status: str
-    reason: str
-    dropped_reason: str | None
-    attempt_count: int
-    resume_cstart: int
-    next_attempt_dt: datetime | None
-    updated_at: datetime
-    last_error: str | None
-    last_run_id: int | None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueListData(BaseModel):
-    queue_items: list[QueueItemData]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueListEnvelope(BaseModel):
-    data: QueueListData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueItemEnvelope(BaseModel):
-    data: QueueItemData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueClearData(BaseModel):
-    queue_item_id: int
-    previous_status: str
-    status: str
-    message: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class QueueClearEnvelope(BaseModel):
-    data: QueueClearData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUserData(BaseModel):
-    id: int
-    email: str
-    is_active: bool
-    is_admin: bool
-    created_at: datetime
-    updated_at: datetime
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUsersListData(BaseModel):
-    users: list[AdminUserData]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUsersListEnvelope(BaseModel):
-    data: AdminUsersListData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUserCreateRequest(BaseModel):
-    email: str
-    password: str
-    is_admin: bool = False
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUserActiveUpdateRequest(BaseModel):
-    is_active: bool
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminUserEnvelope(BaseModel):
-    data: AdminUserData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminResetPasswordRequest(BaseModel):
-    new_password: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbIntegrityCheckData(BaseModel):
-    name: str
-    count: int
-    severity: str
-    message: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbIntegrityData(BaseModel):
-    status: str
-    checked_at: datetime
-    failures: list[str] = Field(default_factory=list)
-    warnings: list[str] = Field(default_factory=list)
-    checks: list[AdminDbIntegrityCheckData] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbIntegrityEnvelope(BaseModel):
-    data: AdminDbIntegrityData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbRepairJobData(BaseModel):
-    id: int
-    job_name: str
-    requested_by: str | None
-    dry_run: bool
-    status: str
-    scope: dict[str, Any] = Field(default_factory=dict)
-    summary: dict[str, Any] = Field(default_factory=dict)
-    error_text: str | None
-    started_at: datetime | None
-    finished_at: datetime | None
-    created_at: datetime
-    updated_at: datetime
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbRepairJobsData(BaseModel):
-    jobs: list[AdminDbRepairJobData] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminDbRepairJobsEnvelope(BaseModel):
-    data: AdminDbRepairJobsData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class DisplayIdentifierData(BaseModel):
-    kind: str
-    value: str
-    label: str
-    url: str | None
-    confidence_score: float = Field(ge=0.0, le=1.0)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueItemData(BaseModel):
-    publication_id: int
-    title: str
-    display_identifier: DisplayIdentifierData | None = None
-    pdf_url: str | None
-    status: str
-    attempt_count: int
-    last_failure_reason: str | None
-    last_failure_detail: str | None
-    last_source: str | None
-    requested_by_user_id: int | None
-    requested_by_email: str | None
-    queued_at: datetime | None
-    last_attempt_at: datetime | None
-    resolved_at: datetime | None
-    updated_at: datetime
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueData(BaseModel):
-    items: list[AdminPdfQueueItemData] = Field(default_factory=list)
-    total_count: int = 0
-    page: int = 1
-    page_size: int = 100
-    has_next: bool = False
-    has_prev: bool = False
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueEnvelope(BaseModel):
-    data: AdminPdfQueueData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueRequeueData(BaseModel):
-    publication_id: int
-    queued: bool
-    status: str
-    message: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueRequeueEnvelope(BaseModel):
-    data: AdminPdfQueueRequeueData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueBulkEnqueueData(BaseModel):
-    requested_count: int
-    queued_count: int
-    message: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminPdfQueueBulkEnqueueEnvelope(BaseModel):
-    data: AdminPdfQueueBulkEnqueueData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminRepairPublicationLinksRequest(BaseModel):
-    scope_mode: Literal["single_user", "all_users"] = "single_user"
-    user_id: int | None = Field(default=None, ge=1)
-    scholar_profile_ids: list[int] = Field(default_factory=list, max_length=200)
-    dry_run: bool = True
-    gc_orphan_publications: bool = False
-    requested_by: str | None = None
-    confirmation_text: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-    @model_validator(mode="after")
-    def validate_scope(self) -> AdminRepairPublicationLinksRequest:
-        if self.scope_mode == "single_user" and self.user_id is None:
-            raise ValueError("user_id is required when scope_mode=single_user.")
-        if self.scope_mode == "all_users" and self.user_id is not None:
-            raise ValueError("user_id must be omitted when scope_mode=all_users.")
-        if not self.dry_run and self.scope_mode == "all_users":
-            expected = "REPAIR ALL USERS"
-            provided = (self.confirmation_text or "").strip()
-            if provided != expected:
-                raise ValueError("confirmation_text must equal 'REPAIR ALL USERS' when applying a repair to all users.")
-        return self
-
-
-class AdminRepairPublicationLinksResultData(BaseModel):
-    job_id: int
-    status: str
-    scope: dict[str, Any] = Field(default_factory=dict)
-    summary: dict[str, Any] = Field(default_factory=dict)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminRepairPublicationLinksEnvelope(BaseModel):
-    data: AdminRepairPublicationLinksResultData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminNearDuplicateClusterMemberData(BaseModel):
-    publication_id: int
-    title: str
-    year: int | None
-    citation_count: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminNearDuplicateClusterData(BaseModel):
-    cluster_key: str
-    winner_publication_id: int
-    member_count: int
-    similarity_score: float = Field(ge=0.0, le=1.0)
-    members: list[AdminNearDuplicateClusterMemberData] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminRepairPublicationNearDuplicatesRequest(BaseModel):
-    dry_run: bool = True
-    similarity_threshold: float = Field(default=0.78, ge=0.5, le=1.0)
-    min_shared_tokens: int = Field(default=3, ge=1, le=8)
-    max_year_delta: int = Field(default=1, ge=0, le=5)
-    max_clusters: int = Field(default=25, ge=1, le=200)
-    selected_cluster_keys: list[str] = Field(default_factory=list, max_length=200)
-    requested_by: str | None = None
-    confirmation_text: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-    @model_validator(mode="after")
-    def validate_apply_mode(self) -> AdminRepairPublicationNearDuplicatesRequest:
-        if self.dry_run:
-            return self
-        if not self.selected_cluster_keys:
-            raise ValueError("selected_cluster_keys is required when dry_run=false.")
-        expected = "MERGE SELECTED DUPLICATES"
-        provided = (self.confirmation_text or "").strip()
-        if provided != expected:
-            raise ValueError(
-                "confirmation_text must equal 'MERGE SELECTED DUPLICATES' when applying near-duplicate merges."
-            )
-        return self
-
-
-class AdminRepairPublicationNearDuplicatesResultData(BaseModel):
-    job_id: int
-    status: str
-    scope: dict[str, Any] = Field(default_factory=dict)
-    summary: dict[str, Any] = Field(default_factory=dict)
-    clusters: list[AdminNearDuplicateClusterData] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AdminRepairPublicationNearDuplicatesEnvelope(BaseModel):
-    data: AdminRepairPublicationNearDuplicatesResultData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class SettingsPolicyData(BaseModel):
-    min_run_interval_minutes: int
-    min_request_delay_seconds: int
-    automation_allowed: bool
-    manual_run_allowed: bool
-    blocked_failure_threshold: int
-    network_failure_threshold: int
-    cooldown_blocked_seconds: int
-    cooldown_network_seconds: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class SettingsData(BaseModel):
-    auto_run_enabled: bool
-    run_interval_minutes: int
-    request_delay_seconds: int
-    nav_visible_pages: list[str]
-    policy: SettingsPolicyData
-    safety_state: ScrapeSafetyStateData
-
-    openalex_api_key: str | None = None
-    crossref_api_token: str | None = None
-    crossref_api_mailto: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class SettingsEnvelope(BaseModel):
-    data: SettingsData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class SettingsUpdateRequest(BaseModel):
-    auto_run_enabled: bool
-    run_interval_minutes: int
-    request_delay_seconds: int
-    nav_visible_pages: list[str] | None = None
-
-    openalex_api_key: str | None = None
-    crossref_api_token: str | None = None
-    crossref_api_mailto: str | None = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class PublicationItemData(BaseModel):
-    publication_id: int
-    scholar_profile_id: int
-    scholar_label: str
-    title: str
-    year: int | None
-    citation_count: int
-    venue_text: str | None
-    pub_url: str | None
-    display_identifier: DisplayIdentifierData | None = None
-    pdf_url: str | None
-    pdf_status: str = "untracked"
-    pdf_attempt_count: int = 0
-    pdf_failure_reason: str | None = None
-    pdf_failure_detail: str | None = None
-    is_read: bool
-    is_favorite: bool = False
-    first_seen_at: datetime
-    is_new_in_latest_run: bool
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class PublicationsListData(BaseModel):
-    mode: str
-    favorite_only: bool = False
-    selected_scholar_profile_id: int | None
-    unread_count: int
-    favorites_count: int
-    latest_count: int
-    new_count: int
-    total_count: int
-    page: int
-    page_size: int
-    snapshot: str
-    has_next: bool = False
-    has_prev: bool = False
-    publications: list[PublicationItemData]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class PublicationsListEnvelope(BaseModel):
-    data: PublicationsListData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MarkAllReadData(BaseModel):
-    message: str
-    updated_count: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MarkAllReadEnvelope(BaseModel):
-    data: MarkAllReadData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class PublicationSelectionItem(BaseModel):
-    scholar_profile_id: int
-    publication_id: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MarkSelectedReadRequest(BaseModel):
-    selections: list[PublicationSelectionItem] = Field(min_length=1, max_length=500)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MarkSelectedReadData(BaseModel):
-    message: str
-    requested_count: int
-    updated_count: int
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class MarkSelectedReadEnvelope(BaseModel):
-    data: MarkSelectedReadData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RetryPublicationPdfRequest(BaseModel):
-    scholar_profile_id: int = Field(ge=1)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RetryPublicationPdfData(BaseModel):
-    message: str
-    queued: bool
-    resolved_pdf: bool
-    publication: PublicationItemData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class RetryPublicationPdfEnvelope(BaseModel):
-    data: RetryPublicationPdfData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class TogglePublicationFavoriteRequest(BaseModel):
-    scholar_profile_id: int = Field(ge=1)
-    is_favorite: bool
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class TogglePublicationFavoriteData(BaseModel):
-    message: str
-    publication: PublicationItemData
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class TogglePublicationFavoriteEnvelope(BaseModel):
-    data: TogglePublicationFavoriteData
-    meta: ApiMeta
-
-    model_config = ConfigDict(extra="forbid")
diff --git a/app/api/schemas/__init__.py b/app/api/schemas/__init__.py
new file mode 100644
index 0000000..4114e70
--- /dev/null
+++ b/app/api/schemas/__init__.py
@@ -0,0 +1,7 @@
+from app.api.schemas.admin import *  # noqa: F401, F403
+from app.api.schemas.auth import *  # noqa: F401, F403
+from app.api.schemas.common import *  # noqa: F401, F403
+from app.api.schemas.publications import *  # noqa: F401, F403
+from app.api.schemas.runs import *  # noqa: F401, F403
+from app.api.schemas.scholars import *  # noqa: F401, F403
+from app.api.schemas.settings import *  # noqa: F401, F403
diff --git a/app/api/schemas/admin.py b/app/api/schemas/admin.py
new file mode 100644
index 0000000..d9f2eb7
--- /dev/null
+++ b/app/api/schemas/admin.py
@@ -0,0 +1,314 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from app.api.schemas.common import ApiMeta
+from app.api.schemas.publications import DisplayIdentifierData
+
+
+class AdminUserData(BaseModel):
+    id: int
+    email: str
+    is_active: bool
+    is_admin: bool
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminUsersListData(BaseModel):
+    users: list[AdminUserData]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminUsersListEnvelope(BaseModel):
+    data: AdminUsersListData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminUserCreateRequest(BaseModel):
+    email: str
+    password: str
+    is_admin: bool = False
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminUserActiveUpdateRequest(BaseModel):
+    is_active: bool
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminUserEnvelope(BaseModel):
+    data: AdminUserData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminResetPasswordRequest(BaseModel):
+    new_password: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminScholarHttpSettingsData(BaseModel):
+    user_agent: str
+    rotate_user_agent: bool
+    accept_language: str
+    cookie: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminScholarHttpSettingsEnvelope(BaseModel):
+    data: AdminScholarHttpSettingsData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminScholarHttpSettingsUpdateRequest(BaseModel):
+    user_agent: str
+    rotate_user_agent: bool
+    accept_language: str
+    cookie: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbIntegrityCheckData(BaseModel):
+    name: str
+    count: int
+    severity: str
+    message: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbIntegrityData(BaseModel):
+    status: str
+    checked_at: datetime
+    failures: list[str] = Field(default_factory=list)
+    warnings: list[str] = Field(default_factory=list)
+    checks: list[AdminDbIntegrityCheckData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbIntegrityEnvelope(BaseModel):
+    data: AdminDbIntegrityData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbRepairJobData(BaseModel):
+    id: int
+    job_name: str
+    requested_by: str | None
+    dry_run: bool
+    status: str
+    scope: dict[str, Any] = Field(default_factory=dict)
+    summary: dict[str, Any] = Field(default_factory=dict)
+    error_text: str | None
+    started_at: datetime | None
+    finished_at: datetime | None
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbRepairJobsData(BaseModel):
+    jobs: list[AdminDbRepairJobData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminDbRepairJobsEnvelope(BaseModel):
+    data: AdminDbRepairJobsData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueItemData(BaseModel):
+    publication_id: int
+    title: str
+    display_identifier: DisplayIdentifierData | None = None
+    pdf_url: str | None
+    status: str
+    attempt_count: int
+    last_failure_reason: str | None
+    last_failure_detail: str | None
+    last_source: str | None
+    requested_by_user_id: int | None
+    requested_by_email: str | None
+    queued_at: datetime | None
+    last_attempt_at: datetime | None
+    resolved_at: datetime | None
+    updated_at: datetime
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueData(BaseModel):
+    items: list[AdminPdfQueueItemData] = Field(default_factory=list)
+    total_count: int = 0
+    page: int = 1
+    page_size: int = 100
+    has_next: bool = False
+    has_prev: bool = False
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueEnvelope(BaseModel):
+    data: AdminPdfQueueData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueRequeueData(BaseModel):
+    publication_id: int
+    queued: bool
+    status: str
+    message: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueRequeueEnvelope(BaseModel):
+    data: AdminPdfQueueRequeueData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueBulkEnqueueData(BaseModel):
+    requested_count: int
+    queued_count: int
+    message: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminPdfQueueBulkEnqueueEnvelope(BaseModel):
+    data: AdminPdfQueueBulkEnqueueData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminRepairPublicationLinksRequest(BaseModel):
+    scope_mode: Literal["single_user", "all_users"] = "single_user"
+    user_id: int | None = Field(default=None, ge=1)
+    scholar_profile_ids: list[int] = Field(default_factory=list, max_length=200)
+    dry_run: bool = True
+    gc_orphan_publications: bool = False
+    requested_by: str | None = None
+    confirmation_text: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+    @model_validator(mode="after")
+    def validate_scope(self) -> AdminRepairPublicationLinksRequest:
+        if self.scope_mode == "single_user" and self.user_id is None:
+            raise ValueError("user_id is required when scope_mode=single_user.")
+        if self.scope_mode == "all_users" and self.user_id is not None:
+            raise ValueError("user_id must be omitted when scope_mode=all_users.")
+        if not self.dry_run and self.scope_mode == "all_users":
+            expected = "REPAIR ALL USERS"
+            provided = (self.confirmation_text or "").strip()
+            if provided != expected:
+                raise ValueError("confirmation_text must equal 'REPAIR ALL USERS' when applying a repair to all users.")
+        return self
+
+
+class AdminRepairPublicationLinksResultData(BaseModel):
+    job_id: int
+    status: str
+    scope: dict[str, Any] = Field(default_factory=dict)
+    summary: dict[str, Any] = Field(default_factory=dict)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminRepairPublicationLinksEnvelope(BaseModel):
+    data: AdminRepairPublicationLinksResultData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminNearDuplicateClusterMemberData(BaseModel):
+    publication_id: int
+    title: str
+    year: int | None
+    citation_count: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminNearDuplicateClusterData(BaseModel):
+    cluster_key: str
+    winner_publication_id: int
+    member_count: int
+    similarity_score: float = Field(ge=0.0, le=1.0)
+    members: list[AdminNearDuplicateClusterMemberData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminRepairPublicationNearDuplicatesRequest(BaseModel):
+    dry_run: bool = True
+    similarity_threshold: float = Field(default=0.78, ge=0.5, le=1.0)
+    min_shared_tokens: int = Field(default=3, ge=1, le=8)
+    max_year_delta: int = Field(default=1, ge=0, le=5)
+    max_clusters: int = Field(default=25, ge=1, le=200)
+    selected_cluster_keys: list[str] = Field(default_factory=list, max_length=200)
+    requested_by: str | None = None
+    confirmation_text: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+    @model_validator(mode="after")
+    def validate_apply_mode(self) -> AdminRepairPublicationNearDuplicatesRequest:
+        if self.dry_run:
+            return self
+        if not self.selected_cluster_keys:
+            raise ValueError("selected_cluster_keys is required when dry_run=false.")
+        expected = "MERGE SELECTED DUPLICATES"
+        provided = (self.confirmation_text or "").strip()
+        if provided != expected:
+            raise ValueError(
+                "confirmation_text must equal 'MERGE SELECTED DUPLICATES' when applying near-duplicate merges."
+            )
+        return self
+
+
+class AdminRepairPublicationNearDuplicatesResultData(BaseModel):
+    job_id: int
+    status: str
+    scope: dict[str, Any] = Field(default_factory=dict)
+    summary: dict[str, Any] = Field(default_factory=dict)
+    clusters: list[AdminNearDuplicateClusterData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AdminRepairPublicationNearDuplicatesEnvelope(BaseModel):
+    data: AdminRepairPublicationNearDuplicatesResultData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
diff --git a/app/api/schemas/auth.py b/app/api/schemas/auth.py
new file mode 100644
index 0000000..174d0b7
--- /dev/null
+++ b/app/api/schemas/auth.py
@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+from app.api.schemas.common import ApiMeta
+
+
+class SessionUserData(BaseModel):
+    id: int
+    email: str
+    is_admin: bool
+    is_active: bool
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AuthMeData(BaseModel):
+    authenticated: bool
+    csrf_token: str
+    user: SessionUserData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AuthMeEnvelope(BaseModel):
+    data: AuthMeData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class CsrfBootstrapData(BaseModel):
+    csrf_token: str
+    authenticated: bool
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class CsrfBootstrapEnvelope(BaseModel):
+    data: CsrfBootstrapData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class LoginRequest(BaseModel):
+    email: str
+    password: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class LoginData(BaseModel):
+    authenticated: bool
+    csrf_token: str
+    user: SessionUserData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class LoginEnvelope(BaseModel):
+    data: LoginData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ChangePasswordRequest(BaseModel):
+    current_password: str
+    new_password: str
+    confirm_password: str
+
+    model_config = ConfigDict(extra="forbid")
diff --git a/app/api/schemas/common.py b/app/api/schemas/common.py
new file mode 100644
index 0000000..cc0805f
--- /dev/null
+++ b/app/api/schemas/common.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class ApiMeta(BaseModel):
+    request_id: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ApiErrorData(BaseModel):
+    code: str
+    message: str
+    details: Any | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ApiErrorEnvelope(BaseModel):
+    error: ApiErrorData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessageData(BaseModel):
+    message: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessageEnvelope(BaseModel):
+    data: MessageData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
diff --git a/app/api/schemas/publications.py b/app/api/schemas/publications.py
new file mode 100644
index 0000000..6ae7c2e
--- /dev/null
+++ b/app/api/schemas/publications.py
@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from app.api.schemas.common import ApiMeta
+
+
+class DisplayIdentifierData(BaseModel):
+    kind: str
+    value: str
+    label: str
+    url: str | None
+    confidence_score: float = Field(ge=0.0, le=1.0)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PublicationItemData(BaseModel):
+    publication_id: int
+    scholar_profile_id: int
+    scholar_label: str
+    title: str
+    year: int | None
+    citation_count: int
+    venue_text: str | None
+    pub_url: str | None
+    display_identifier: DisplayIdentifierData | None = None
+    pdf_url: str | None
+    pdf_status: str = "untracked"
+    pdf_attempt_count: int = 0
+    pdf_failure_reason: str | None = None
+    pdf_failure_detail: str | None = None
+    is_read: bool
+    is_favorite: bool = False
+    first_seen_at: datetime
+    is_new_in_latest_run: bool
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PublicationsListData(BaseModel):
+    mode: str
+    favorite_only: bool = False
+    selected_scholar_profile_id: int | None
+    unread_count: int
+    favorites_count: int
+    latest_count: int
+    new_count: int
+    total_count: int
+    page: int
+    page_size: int
+    snapshot: str
+    has_next: bool = False
+    has_prev: bool = False
+    publications: list[PublicationItemData]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PublicationsListEnvelope(BaseModel):
+    data: PublicationsListData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MarkAllReadData(BaseModel):
+    message: str
+    updated_count: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MarkAllReadEnvelope(BaseModel):
+    data: MarkAllReadData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PublicationSelectionItem(BaseModel):
+    scholar_profile_id: int
+    publication_id: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MarkSelectedReadRequest(BaseModel):
+    selections: list[PublicationSelectionItem] = Field(min_length=1, max_length=500)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MarkSelectedReadData(BaseModel):
+    message: str
+    requested_count: int
+    updated_count: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MarkSelectedReadEnvelope(BaseModel):
+    data: MarkSelectedReadData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RetryPublicationPdfRequest(BaseModel):
+    scholar_profile_id: int = Field(ge=1)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RetryPublicationPdfData(BaseModel):
+    message: str
+    queued: bool
+    resolved_pdf: bool
+    publication: PublicationItemData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RetryPublicationPdfEnvelope(BaseModel):
+    data: RetryPublicationPdfData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class TogglePublicationFavoriteRequest(BaseModel):
+    scholar_profile_id: int = Field(ge=1)
+    is_favorite: bool
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class TogglePublicationFavoriteData(BaseModel):
+    message: str
+    publication: PublicationItemData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class TogglePublicationFavoriteEnvelope(BaseModel):
+    data: TogglePublicationFavoriteData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
diff --git a/app/api/schemas/runs.py b/app/api/schemas/runs.py
new file mode 100644
index 0000000..e9e7791
--- /dev/null
+++ b/app/api/schemas/runs.py
@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from app.api.schemas.common import ApiMeta
+
+
+class RunListItemData(BaseModel):
+    id: int
+    trigger_type: str
+    status: str
+    start_dt: datetime
+    end_dt: datetime | None
+    scholar_count: int
+    new_publication_count: int
+    failed_count: int
+    partial_count: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScrapeSafetyCountersData(BaseModel):
+    consecutive_blocked_runs: int = 0
+    consecutive_network_runs: int = 0
+    cooldown_entry_count: int = 0
+    blocked_start_count: int = 0
+    last_blocked_failure_count: int = 0
+    last_network_failure_count: int = 0
+    last_evaluated_run_id: int | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScrapeSafetyStateData(BaseModel):
+    cooldown_active: bool
+    cooldown_reason: str | None = None
+    cooldown_reason_label: str | None = None
+    cooldown_until: datetime | None = None
+    cooldown_remaining_seconds: int = 0
+    recommended_action: str | None = None
+    counters: ScrapeSafetyCountersData = Field(default_factory=ScrapeSafetyCountersData)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunsListData(BaseModel):
+    runs: list[RunListItemData]
+    safety_state: ScrapeSafetyStateData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunsListEnvelope(BaseModel):
+    data: RunsListData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunSummaryData(BaseModel):
+    succeeded_count: int
+    failed_count: int
+    partial_count: int
+    failed_state_counts: dict[str, int] = Field(default_factory=dict)
+    failed_reason_counts: dict[str, int] = Field(default_factory=dict)
+    scrape_failure_counts: dict[str, int] = Field(default_factory=dict)
+    retry_counts: dict[str, int] = Field(default_factory=dict)
+    alert_thresholds: dict[str, int] = Field(default_factory=dict)
+    alert_flags: dict[str, bool] = Field(default_factory=dict)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunAttemptLogData(BaseModel):
+    attempt: int
+    cstart: int
+    state: str | None = None
+    state_reason: str | None = None
+    status_code: int | None = None
+    fetch_error: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunPageLogData(BaseModel):
+    page: int
+    cstart: int
+    state: str
+    state_reason: str | None = None
+    status_code: int | None = None
+    publication_count: int = 0
+    attempt_count: int = 0
+    has_show_more_button: bool = False
+    articles_range: str | None = None
+    warning_codes: list[str] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunDebugData(BaseModel):
+    status_code: int | None = None
+    final_url: str | None = None
+    fetch_error: str | None = None
+    body_sha256: str | None = None
+    body_length: int | None = None
+    has_show_more_button: bool | None = None
+    articles_range: str | None = None
+    state_reason: str | None = None
+    warning_codes: list[str] = Field(default_factory=list)
+    marker_counts_nonzero: dict[str, int] = Field(default_factory=dict)
+    page_logs: list[RunPageLogData] = Field(default_factory=list)
+    attempt_log: list[RunAttemptLogData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunScholarResultData(BaseModel):
+    scholar_profile_id: int
+    scholar_id: str
+    state: str
+    state_reason: str | None = None
+    outcome: str
+    attempt_count: int = 0
+    publication_count: int = 0
+    start_cstart: int = 0
+    continuation_cstart: int | None = None
+    continuation_enqueued: bool = False
+    continuation_cleared: bool = False
+    warnings: list[str] = Field(default_factory=list)
+    error: str | None = None
+    debug: RunDebugData | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunDetailData(BaseModel):
+    run: RunListItemData
+    summary: RunSummaryData
+    scholar_results: list[RunScholarResultData]
+    safety_state: ScrapeSafetyStateData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RunDetailEnvelope(BaseModel):
+    data: RunDetailData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ManualRunData(BaseModel):
+    run_id: int
+    status: str
+    scholar_count: int
+    succeeded_count: int
+    failed_count: int
+    partial_count: int
+    new_publication_count: int
+    reused_existing_run: bool
+    idempotency_key: str | None = None
+    safety_state: ScrapeSafetyStateData
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ManualRunEnvelope(BaseModel):
+    data: ManualRunData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueItemData(BaseModel):
+    id: int
+    scholar_profile_id: int
+    scholar_label: str
+    status: str
+    reason: str
+    dropped_reason: str | None
+    attempt_count: int
+    resume_cstart: int
+    next_attempt_dt: datetime | None
+    updated_at: datetime
+    last_error: str | None
+    last_run_id: int | None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueListData(BaseModel):
+    queue_items: list[QueueItemData]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueListEnvelope(BaseModel):
+    data: QueueListData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueItemEnvelope(BaseModel):
+    data: QueueItemData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueClearData(BaseModel):
+    queue_item_id: int
+    previous_status: str
+    status: str
+    message: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QueueClearEnvelope(BaseModel):
+    data: QueueClearData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
diff --git a/app/api/schemas/scholars.py b/app/api/schemas/scholars.py
new file mode 100644
index 0000000..dda8329
--- /dev/null
+++ b/app/api/schemas/scholars.py
@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from app.api.schemas.common import ApiMeta
+
+
+class ScholarItemData(BaseModel):
+    id: int
+    scholar_id: str
+    display_name: str | None
+    profile_image_url: str | None
+    profile_image_source: str
+    is_enabled: bool
+    baseline_completed: bool
+    last_run_dt: datetime | None
+    last_run_status: str | None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarsListData(BaseModel):
+    scholars: list[ScholarItemData]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarsListEnvelope(BaseModel):
+    data: ScholarsListData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarCreateRequest(BaseModel):
+    scholar_id: str
+    profile_image_url: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarEnvelope(BaseModel):
+    data: ScholarItemData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarSearchCandidateData(BaseModel):
+    scholar_id: str
+    display_name: str
+    affiliation: str | None
+    email_domain: str | None
+    cited_by_count: int | None
+    interests: list[str] = Field(default_factory=list)
+    profile_url: str
+    profile_image_url: str | None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarSearchData(BaseModel):
+    query: str
+    state: str
+    state_reason: str
+    action_hint: str | None = None
+    candidates: list[ScholarSearchCandidateData]
+    warnings: list[str] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarSearchEnvelope(BaseModel):
+    data: ScholarSearchData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarImageUrlUpdateRequest(BaseModel):
+    image_url: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ScholarExportItemData(BaseModel):
+    scholar_id: str
+    display_name: str | None = None
+    is_enabled: bool = True
+    profile_image_override_url: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PublicationExportItemData(BaseModel):
+    scholar_id: str
+    cluster_id: str | None = None
+    fingerprint_sha256: str | None = None
+    title: str
+    year: int | None = None
+    citation_count: int = 0
+    author_text: str | None = None
+    venue_text: str | None = None
+    pub_url: str | None = None
+    pdf_url: str | None = None
+    is_read: bool = False
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DataExportData(BaseModel):
+    schema_version: int
+    exported_at: str
+    scholars: list[ScholarExportItemData]
+    publications: list[PublicationExportItemData]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DataExportEnvelope(BaseModel):
+    data: DataExportData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DataImportRequest(BaseModel):
+    schema_version: int | None = None
+    scholars: list[ScholarExportItemData] = Field(default_factory=list)
+    publications: list[PublicationExportItemData] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DataImportResultData(BaseModel):
+    scholars_created: int
+    scholars_updated: int
+    publications_created: int
+    publications_updated: int
+    links_created: int
+    links_updated: int
+    skipped_records: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DataImportEnvelope(BaseModel):
+    data: DataImportResultData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
diff --git a/app/api/schemas/settings.py b/app/api/schemas/settings.py
new file mode 100644
index 0000000..cc06ee8
--- /dev/null
+++ b/app/api/schemas/settings.py
@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+from app.api.schemas.common import ApiMeta
+from app.api.schemas.runs import ScrapeSafetyStateData
+
+
+class SettingsPolicyData(BaseModel):
+    min_run_interval_minutes: int
+    min_request_delay_seconds: int
+    automation_allowed: bool
+    manual_run_allowed: bool
+    blocked_failure_threshold: int
+    network_failure_threshold: int
+    cooldown_blocked_seconds: int
+    cooldown_network_seconds: int
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SettingsData(BaseModel):
+    auto_run_enabled: bool
+    run_interval_minutes: int
+    request_delay_seconds: int
+    nav_visible_pages: list[str]
+    policy: SettingsPolicyData
+    safety_state: ScrapeSafetyStateData
+
+    openalex_api_key: str | None = None
+    crossref_api_token: str | None = None
+    crossref_api_mailto: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SettingsEnvelope(BaseModel):
+    data: SettingsData
+    meta: ApiMeta
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SettingsUpdateRequest(BaseModel):
+    auto_run_enabled: bool
+    run_interval_minutes: int
+    request_delay_seconds: int
+    nav_visible_pages: list[str] | None = None
+
+    openalex_api_key: str | None = None
+    crossref_api_token: str | None = None
+    crossref_api_mailto: str | None = None
+
+    model_config = ConfigDict(extra="forbid")
diff --git a/app/services/ingestion/application.py b/app/services/ingestion/application.py
index abe23a3..f1a906e 100644
--- a/app/services/ingestion/application.py
+++ b/app/services/ingestion/application.py
@@ -1,68 +1,48 @@
 from __future__ import annotations
 
 import asyncio
-import hashlib
 import logging
-import re
-from datetime import UTC, datetime, timedelta
+from datetime import UTC, datetime
 from typing import Any
 
-from sqlalchemy import or_, select, text
+from sqlalchemy import select, text
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import (
     CrawlRun,
-    Publication,
     RunStatus,
     RunTriggerType,
     ScholarProfile,
-    ScholarPublication,
 )
 from app.logging_utils import structured_log
-from app.services.arxiv.errors import ArxivRateLimitError
 from app.services.ingestion import queue as queue_service
 from app.services.ingestion import safety as run_safety_service
-from app.services.ingestion.constants import (
-    FAILED_STATES,
-    FAILURE_BUCKET_BLOCKED,
-    FAILURE_BUCKET_INGESTION,
-    FAILURE_BUCKET_LAYOUT,
-    FAILURE_BUCKET_NETWORK,
-    FAILURE_BUCKET_OTHER,
-    RESUMABLE_PARTIAL_REASON_PREFIXES,
-    RESUMABLE_PARTIAL_REASONS,
-    RUN_LOCK_NAMESPACE,
-)
-from app.services.ingestion.fingerprints import (
-    _build_body_excerpt,
-)
+from app.services.ingestion.constants import RUN_LOCK_NAMESPACE
+from app.services.ingestion.enrichment import EnrichmentRunner
 from app.services.ingestion.pagination import PaginationEngine
-from app.services.ingestion.publication_upsert import upsert_profile_publications
+from app.services.ingestion.run_completion import (
+    _int_or_default,
+    complete_run_for_user,
+    run_execution_summary,
+)
+from app.services.ingestion.scholar_processing import run_scholar_iteration
 from app.services.ingestion.types import (
-    PagedParseResult,
     RunAlertSummary,
     RunAlreadyInProgressError,
     RunBlockedBySafetyPolicyError,
-    RunExecutionSummary,
     RunFailureSummary,
     RunProgress,
-    ScholarProcessingOutcome,
 )
-from app.services.publication_identifiers import application as identifier_service
-from app.services.runs.events import run_events
-from app.services.scholar.parser import (
-    ParsedProfilePage,
-    ParseState,
-    PublicationCandidate,
-)
-from app.services.scholar.source import FetchResult, ScholarSource
+from app.services.scholar.source import ScholarSource
 from app.services.settings import application as user_settings_service
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
 ACTIVE_RUN_INDEX_NAME = "uq_crawl_runs_user_active"
 
+_background_tasks: set[asyncio.Task[Any]] = set()
+
 
 def _is_active_run_integrity_error(exc: IntegrityError) -> bool:
     original_error = getattr(exc, "orig", None)
@@ -78,35 +58,77 @@ def _is_active_run_integrity_error(exc: IntegrityError) -> bool:
     return getattr(diagnostics, "constraint_name", None) == ACTIVE_RUN_INDEX_NAME
 
 
-def _int_or_default(value: Any, default: int = 0) -> int:
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        return default
+def _resolve_paging_kwargs(
+    *,
+    request_delay_seconds: int,
+    network_error_retries: int,
+    retry_backoff_seconds: float,
+    rate_limit_retries: int | None,
+    rate_limit_backoff_seconds: float | None,
+    max_pages_per_scholar: int,
+    page_size: int,
+) -> dict[str, Any]:
+    return {
+        "request_delay_seconds": request_delay_seconds,
+        "network_error_retries": network_error_retries,
+        "retry_backoff_seconds": retry_backoff_seconds,
+        "rate_limit_retries": rate_limit_retries
+        if rate_limit_retries is not None
+        else settings.ingestion_rate_limit_retries,
+        "rate_limit_backoff_seconds": rate_limit_backoff_seconds
+        if rate_limit_backoff_seconds is not None
+        else settings.ingestion_rate_limit_backoff_seconds,
+        "max_pages_per_scholar": max_pages_per_scholar,
+        "page_size": page_size,
+    }
 
 
-def _classify_failure_bucket(*, state: str, state_reason: str) -> str:
-    reason = state_reason.strip().lower()
-    normalized_state = state.strip().lower()
-
-    if normalized_state == ParseState.BLOCKED_OR_CAPTCHA.value or reason.startswith("blocked_"):
-        return FAILURE_BUCKET_BLOCKED
-    if normalized_state == ParseState.NETWORK_ERROR.value or reason.startswith("network_"):
-        return FAILURE_BUCKET_NETWORK
-    if normalized_state == ParseState.LAYOUT_CHANGED.value:
-        return FAILURE_BUCKET_LAYOUT
-    if normalized_state == "ingestion_error":
-        return FAILURE_BUCKET_INGESTION
-    return FAILURE_BUCKET_OTHER
+def _threshold_kwargs(
+    *,
+    alert_blocked_failure_threshold: int,
+    alert_network_failure_threshold: int,
+    alert_retry_scheduled_threshold: int,
+) -> dict[str, Any]:
+    return {
+        "alert_blocked_failure_threshold": alert_blocked_failure_threshold,
+        "alert_network_failure_threshold": alert_network_failure_threshold,
+        "alert_retry_scheduled_threshold": alert_retry_scheduled_threshold,
+    }
 
 
-_background_tasks: set[asyncio.Task[Any]] = set()
+def _log_run_completed(
+    *,
+    run: CrawlRun,
+    user_id: int,
+    scholars: list[ScholarProfile],
+    progress: RunProgress,
+    failure_summary: RunFailureSummary,
+    alert_summary: RunAlertSummary,
+) -> None:
+    structured_log(
+        logger,
+        "info",
+        "ingestion.run_completed",
+        user_id=user_id,
+        crawl_run_id=run.id,
+        status=run.status.value,
+        scholar_count=len(scholars),
+        succeeded_count=progress.succeeded_count,
+        failed_count=progress.failed_count,
+        partial_count=progress.partial_count,
+        new_publication_count=run.new_pub_count,
+        blocked_failure_count=alert_summary.blocked_failure_count,
+        network_failure_count=alert_summary.network_failure_count,
+        retries_scheduled_count=failure_summary.retries_scheduled_count,
+        alert_flags=alert_summary.alert_flags,
+    )
 
 
 class ScholarIngestionService:
     def __init__(self, *, source: ScholarSource) -> None:
         self._source = source
         self._pagination = PaginationEngine(source=source)
+        self._enrichment = EnrichmentRunner()
 
     @staticmethod
     def _effective_request_delay_seconds(value: int) -> int:
@@ -122,15 +144,9 @@ class ScholarIngestionService:
         user_id: int,
         trigger_type: RunTriggerType,
     ):
-        user_settings = await user_settings_service.get_or_create_settings(
-            db_session,
-            user_id=user_id,
-        )
+        user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=user_id)
         await self._enforce_safety_gate(
-            db_session,
-            user_settings=user_settings,
-            user_id=user_id,
-            trigger_type=trigger_type,
+            db_session, user_settings=user_settings, user_id=user_id, trigger_type=trigger_type
         )
         return user_settings
 
@@ -174,10 +190,7 @@ class ScholarIngestionService:
         trigger_type: RunTriggerType,
         now_utc: datetime,
     ) -> None:
-        safety_state = run_safety_service.register_cooldown_blocked_start(
-            user_settings,
-            now_utc=now_utc,
-        )
+        safety_state = run_safety_service.register_cooldown_blocked_start(user_settings, now_utc=now_utc)
         await db_session.commit()
         structured_log(
             logger,
@@ -196,18 +209,6 @@ class ScholarIngestionService:
             safety_state=safety_state,
         )
 
-    @staticmethod
-    def _normalize_run_targets(
-        *,
-        scholar_profile_ids: set[int] | None,
-        start_cstart_by_scholar_id: dict[int, int] | None,
-    ) -> tuple[set[int] | None, dict[int, int]]:
-        filtered_scholar_ids = (
-            {int(value) for value in scholar_profile_ids} if scholar_profile_ids is not None else None
-        )
-        start_cstart_map = {int(key): max(0, int(value)) for key, value in (start_cstart_by_scholar_id or {}).items()}
-        return filtered_scholar_ids, start_cstart_map
-
     async def _load_target_scholars(
         self,
         db_session: AsyncSession,
@@ -224,844 +225,12 @@ class ScholarIngestionService:
             scholars_stmt = scholars_stmt.where(ScholarProfile.id.in_(filtered_scholar_ids))
         scholars_result = await db_session.execute(scholars_stmt)
         scholars = list(scholars_result.scalars().all())
-        await self._clear_missing_filtered_jobs(
-            db_session,
-            user_id=user_id,
-            filtered_scholar_ids=filtered_scholar_ids,
-            scholars=scholars,
-        )
+        if filtered_scholar_ids is not None:
+            found_ids = {int(s.id) for s in scholars}
+            for sid in filtered_scholar_ids - found_ids:
+                await queue_service.clear_job_for_scholar(db_session, user_id=user_id, scholar_profile_id=sid)
         return scholars
 
-    async def _clear_missing_filtered_jobs(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_id: int,
-        filtered_scholar_ids: set[int] | None,
-        scholars: list[ScholarProfile],
-    ) -> None:
-        if filtered_scholar_ids is None:
-            return
-        found_ids = {int(scholar.id) for scholar in scholars}
-        missing_ids = filtered_scholar_ids - found_ids
-        for scholar_profile_id in missing_ids:
-            await queue_service.clear_job_for_scholar(
-                db_session,
-                user_id=user_id,
-                scholar_profile_id=scholar_profile_id,
-            )
-
-    @staticmethod
-    def _create_running_run(
-        *,
-        user_id: int,
-        trigger_type: RunTriggerType,
-        scholar_count: int,
-        idempotency_key: str | None,
-    ) -> CrawlRun:
-        return CrawlRun(
-            user_id=user_id,
-            trigger_type=trigger_type,
-            status=RunStatus.RUNNING,
-            scholar_count=scholar_count,
-            new_pub_count=0,
-            idempotency_key=idempotency_key,
-            error_log={},
-        )
-
-    @staticmethod
-    async def _wait_between_scholars(*, index: int, request_delay_seconds: int) -> None:
-        if index <= 0 or request_delay_seconds <= 0:
-            return
-        await asyncio.sleep(float(request_delay_seconds))
-
-    @staticmethod
-    def _assert_valid_paged_parse_result(
-        *,
-        scholar_id: str,
-        paged_parse_result: PagedParseResult,
-    ) -> None:
-        parsed_page = paged_parse_result.parsed_page
-        if parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS} and any(
-            code.startswith("layout_") for code in parsed_page.warnings
-        ):
-            raise RuntimeError(f"Layout warning marked as terminal for scholar_id={scholar_id}.")
-        for publication in paged_parse_result.publications:
-            if not publication.title.strip():
-                raise RuntimeError(f"Malformed publication title for scholar_id={scholar_id}.")
-            if publication.citation_count is not None and int(publication.citation_count) < 0:
-                raise RuntimeError(f"Negative citation count for scholar_id={scholar_id}.")
-
-    @staticmethod
-    def _apply_first_page_profile_metadata(
-        *,
-        scholar: ScholarProfile,
-        paged_parse_result: PagedParseResult,
-        run_dt: datetime,
-    ) -> None:
-        first_page = paged_parse_result.first_page_parsed_page
-        if first_page.profile_name and not (scholar.display_name or "").strip():
-            scholar.display_name = first_page.profile_name
-        if first_page.profile_image_url:
-            scholar.profile_image_url = first_page.profile_image_url
-        scholar.last_initial_page_checked_at = run_dt
-
-    @staticmethod
-    def _build_result_entry(
-        *,
-        scholar: ScholarProfile,
-        start_cstart: int,
-        paged_parse_result: PagedParseResult,
-    ) -> dict[str, Any]:
-        parsed_page = paged_parse_result.parsed_page
-        return {
-            "scholar_profile_id": scholar.id,
-            "scholar_id": scholar.scholar_id,
-            "state": parsed_page.state.value,
-            "state_reason": parsed_page.state_reason,
-            "outcome": "failed",
-            "attempt_count": len(paged_parse_result.attempt_log),
-            "publication_count": len(paged_parse_result.publications),
-            "start_cstart": start_cstart,
-            "articles_range": parsed_page.articles_range,
-            "warnings": parsed_page.warnings,
-            "has_show_more_button": parsed_page.has_show_more_button,
-            "pages_fetched": paged_parse_result.pages_fetched,
-            "pages_attempted": paged_parse_result.pages_attempted,
-            "has_more_remaining": paged_parse_result.has_more_remaining,
-            "pagination_truncated_reason": paged_parse_result.pagination_truncated_reason,
-            "continuation_cstart": paged_parse_result.continuation_cstart,
-            "skipped_no_change": paged_parse_result.skipped_no_change,
-            "initial_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
-        }
-
-    def _skipped_no_change_outcome(
-        self,
-        *,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-    ) -> ScholarProcessingOutcome:
-        first_page = paged_parse_result.first_page_parsed_page
-        scholar.last_run_status = RunStatus.SUCCESS
-        scholar.last_run_dt = run_dt
-        result_entry["state"] = first_page.state.value
-        result_entry["state_reason"] = "no_change_initial_page_signature"
-        result_entry["outcome"] = "success"
-        result_entry["publication_count"] = 0
-        result_entry["warnings"] = first_page.warnings
-        result_entry["debug"] = {
-            "state_reason": "no_change_initial_page_signature",
-            "first_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
-            "attempt_log": paged_parse_result.attempt_log,
-            "page_logs": paged_parse_result.page_logs,
-        }
-        return ScholarProcessingOutcome(
-            result_entry=result_entry,
-            succeeded_count_delta=1,
-            failed_count_delta=0,
-            partial_count_delta=0,
-            discovered_publication_count=0,
-        )
-
-    async def _upsert_publications_outcome(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-    ) -> ScholarProcessingOutcome:
-        parsed_page = paged_parse_result.parsed_page
-        publications = paged_parse_result.publications
-        had_page_failure = parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}
-        has_partial_set = len(publications) > 0 and had_page_failure
-        if (not had_page_failure) or has_partial_set:
-            return await self._upsert_success_or_exception(
-                db_session,
-                run=run,
-                scholar=scholar,
-                run_dt=run_dt,
-                paged_parse_result=paged_parse_result,
-                result_entry=result_entry,
-                has_partial_publication_set=has_partial_set,
-            )
-        return self._parse_failure_outcome(
-            scholar=scholar,
-            run_dt=run_dt,
-            paged_parse_result=paged_parse_result,
-            result_entry=result_entry,
-        )
-
-    async def _upsert_success_or_exception(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-        has_partial_publication_set: bool,
-    ) -> ScholarProcessingOutcome:
-        try:
-            return await self._upsert_success(
-                db_session,
-                run=run,
-                scholar=scholar,
-                run_dt=run_dt,
-                paged_parse_result=paged_parse_result,
-                result_entry=result_entry,
-                has_partial_publication_set=has_partial_publication_set,
-            )
-        except Exception as exc:
-            return self._upsert_exception_outcome(
-                run=run,
-                scholar=scholar,
-                run_dt=run_dt,
-                paged_parse_result=paged_parse_result,
-                result_entry=result_entry,
-                exc=exc,
-            )
-
-    async def _upsert_success(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-        has_partial_publication_set: bool,
-    ) -> ScholarProcessingOutcome:
-        # We no longer aggregate and upsert the publications here.
-        # Eager DB insertions have already saved and committed them inside `fetch_and_parse_all_pages` and `_paginate_loop`.
-        discovered_count = paged_parse_result.discovered_publication_count
-        is_partial = (
-            paged_parse_result.has_more_remaining
-            or paged_parse_result.pagination_truncated_reason is not None
-            or has_partial_publication_set
-        )
-        scholar.last_run_status = RunStatus.PARTIAL_FAILURE if is_partial else RunStatus.SUCCESS
-        scholar.last_run_dt = run_dt
-        if not is_partial and paged_parse_result.first_page_fingerprint_sha256:
-            scholar.last_initial_page_fingerprint_sha256 = paged_parse_result.first_page_fingerprint_sha256
-        result_entry["outcome"] = "partial" if is_partial else "success"
-        if is_partial:
-            result_entry["debug"] = self._build_failure_debug_context(
-                fetch_result=paged_parse_result.fetch_result,
-                parsed_page=paged_parse_result.parsed_page,
-                attempt_log=paged_parse_result.attempt_log,
-                page_logs=paged_parse_result.page_logs,
-            )
-        return ScholarProcessingOutcome(
-            result_entry=result_entry,
-            succeeded_count_delta=1,
-            failed_count_delta=0,
-            partial_count_delta=1 if is_partial else 0,
-            discovered_publication_count=discovered_count,
-        )
-
-    def _upsert_exception_outcome(
-        self,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-        exc: Exception,
-    ) -> ScholarProcessingOutcome:
-        scholar.last_run_status = RunStatus.FAILED
-        scholar.last_run_dt = run_dt
-        result_entry["state"] = "ingestion_error"
-        result_entry["state_reason"] = "publication_upsert_exception"
-        result_entry["outcome"] = "failed"
-        result_entry["error"] = str(exc)
-        result_entry["debug"] = self._build_failure_debug_context(
-            fetch_result=paged_parse_result.fetch_result,
-            parsed_page=paged_parse_result.parsed_page,
-            attempt_log=paged_parse_result.attempt_log,
-            page_logs=paged_parse_result.page_logs,
-            exception=exc,
-        )
-        logger.exception(
-            "ingestion.scholar_failed",
-            extra={
-                "crawl_run_id": run.id,
-                "scholar_profile_id": scholar.id,
-                "scholar_id": scholar.scholar_id,
-            },
-        )
-        return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
-
-    def _parse_failure_outcome(
-        self,
-        *,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-    ) -> ScholarProcessingOutcome:
-        scholar.last_run_status = RunStatus.FAILED
-        scholar.last_run_dt = run_dt
-        result_entry["debug"] = self._build_failure_debug_context(
-            fetch_result=paged_parse_result.fetch_result,
-            parsed_page=paged_parse_result.parsed_page,
-            attempt_log=paged_parse_result.attempt_log,
-            page_logs=paged_parse_result.page_logs,
-        )
-        structured_log(
-            logger,
-            "warning",
-            "ingestion.scholar_parse_failed",
-            scholar_profile_id=scholar.id,
-            scholar_id=scholar.scholar_id,
-            state=paged_parse_result.parsed_page.state.value,
-            state_reason=paged_parse_result.parsed_page.state_reason,
-            status_code=paged_parse_result.fetch_result.status_code,
-        )
-        return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
-
-    async def _sync_continuation_queue(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_id: int,
-        scholar: ScholarProfile,
-        run: CrawlRun,
-        start_cstart: int,
-        result_entry: dict[str, Any],
-        paged_parse_result: PagedParseResult,
-        auto_queue_continuations: bool,
-        queue_delay_seconds: int,
-    ) -> None:
-        queue_reason, queue_cstart = self._resolve_continuation_queue_target(
-            outcome=str(result_entry.get("outcome", "")),
-            state=str(result_entry.get("state", "")),
-            pagination_truncated_reason=paged_parse_result.pagination_truncated_reason,
-            continuation_cstart=paged_parse_result.continuation_cstart,
-            fallback_cstart=start_cstart,
-        )
-        if auto_queue_continuations and queue_reason is not None:
-            await queue_service.upsert_job(
-                db_session,
-                user_id=user_id,
-                scholar_profile_id=scholar.id,
-                resume_cstart=queue_cstart,
-                reason=queue_reason,
-                run_id=run.id,
-                delay_seconds=queue_delay_seconds,
-            )
-            result_entry["continuation_enqueued"] = True
-            result_entry["continuation_reason"] = queue_reason
-            result_entry["continuation_cstart"] = queue_cstart
-            return
-        if await queue_service.clear_job_for_scholar(db_session, user_id=user_id, scholar_profile_id=scholar.id):
-            result_entry["continuation_cleared"] = True
-
-    async def _process_scholar(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        user_id: int,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-        start_cstart: int,
-        auto_queue_continuations: bool,
-        queue_delay_seconds: int,
-    ) -> ScholarProcessingOutcome:
-        try:
-            return await self._process_scholar_inner(
-                db_session,
-                run=run,
-                scholar=scholar,
-                user_id=user_id,
-                request_delay_seconds=request_delay_seconds,
-                network_error_retries=network_error_retries,
-                retry_backoff_seconds=retry_backoff_seconds,
-                rate_limit_retries=rate_limit_retries,
-                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-                max_pages_per_scholar=max_pages_per_scholar,
-                page_size=page_size,
-                start_cstart=start_cstart,
-                auto_queue_continuations=auto_queue_continuations,
-                queue_delay_seconds=queue_delay_seconds,
-            )
-        except Exception as exc:
-            return self._unexpected_scholar_exception_outcome(
-                run=run,
-                scholar=scholar,
-                start_cstart=start_cstart,
-                exc=exc,
-            )
-
-    async def _process_scholar_inner(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        user_id: int,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-        start_cstart: int,
-        auto_queue_continuations: bool,
-        queue_delay_seconds: int,
-    ) -> ScholarProcessingOutcome:
-        run_dt, paged_parse_result, result_entry = await self._fetch_and_prepare_scholar_result(
-            db_session,
-            run=run,
-            scholar=scholar,
-            user_id=user_id,
-            start_cstart=start_cstart,
-            request_delay_seconds=request_delay_seconds,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-            max_pages_per_scholar=max_pages_per_scholar,
-            page_size=page_size,
-        )
-        outcome = await self._resolve_scholar_outcome(
-            db_session,
-            run=run,
-            scholar=scholar,
-            run_dt=run_dt,
-            paged_parse_result=paged_parse_result,
-            result_entry=result_entry,
-        )
-        await self._sync_continuation_queue(
-            db_session,
-            user_id=user_id,
-            scholar=scholar,
-            run=run,
-            start_cstart=start_cstart,
-            result_entry=outcome.result_entry,
-            paged_parse_result=paged_parse_result,
-            auto_queue_continuations=auto_queue_continuations,
-            queue_delay_seconds=queue_delay_seconds,
-        )
-        return outcome
-
-    async def _fetch_and_prepare_scholar_result(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        user_id: int,
-        start_cstart: int,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-    ) -> tuple[datetime, PagedParseResult, dict[str, Any]]:
-        run_dt = datetime.now(UTC)
-        paged_parse_result = await self._pagination.fetch_and_parse_all_pages(
-            scholar=scholar,
-            run=run,
-            db_session=db_session,
-            start_cstart=start_cstart,
-            request_delay_seconds=request_delay_seconds,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-            max_pages=max_pages_per_scholar,
-            page_size=page_size,
-            previous_initial_page_fingerprint_sha256=scholar.last_initial_page_fingerprint_sha256,
-            upsert_publications_fn=upsert_profile_publications,
-        )
-        self._assert_valid_paged_parse_result(scholar_id=scholar.scholar_id, paged_parse_result=paged_parse_result)
-        self._apply_first_page_profile_metadata(scholar=scholar, paged_parse_result=paged_parse_result, run_dt=run_dt)
-        parsed_page = paged_parse_result.parsed_page
-        structured_log(
-            logger,
-            "info",
-            "ingestion.scholar_parsed",
-            user_id=user_id,
-            crawl_run_id=run.id,
-            scholar_profile_id=scholar.id,
-            scholar_id=scholar.scholar_id,
-            state=parsed_page.state.value,
-            publication_count=len(paged_parse_result.publications),
-            has_show_more_button=parsed_page.has_show_more_button,
-            pages_fetched=paged_parse_result.pages_fetched,
-            pages_attempted=paged_parse_result.pages_attempted,
-            has_more_remaining=paged_parse_result.has_more_remaining,
-            pagination_truncated_reason=paged_parse_result.pagination_truncated_reason,
-            warning_count=len(parsed_page.warnings),
-            skipped_no_change=paged_parse_result.skipped_no_change,
-        )
-        result_entry = self._build_result_entry(
-            scholar=scholar,
-            start_cstart=start_cstart,
-            paged_parse_result=paged_parse_result,
-        )
-        return run_dt, paged_parse_result, result_entry
-
-    async def _resolve_scholar_outcome(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        run_dt: datetime,
-        paged_parse_result: PagedParseResult,
-        result_entry: dict[str, Any],
-    ) -> ScholarProcessingOutcome:
-        if paged_parse_result.skipped_no_change:
-            return self._skipped_no_change_outcome(
-                scholar=scholar,
-                run_dt=run_dt,
-                paged_parse_result=paged_parse_result,
-                result_entry=result_entry,
-            )
-        return await self._upsert_publications_outcome(
-            db_session,
-            run=run,
-            scholar=scholar,
-            run_dt=run_dt,
-            paged_parse_result=paged_parse_result,
-            result_entry=result_entry,
-        )
-
-    @staticmethod
-    def _result_counters(result_entry: dict[str, Any]) -> tuple[int, int, int]:
-        outcome = str(result_entry.get("outcome", "")).strip().lower()
-        if outcome == "success":
-            return 1, 0, 0
-        if outcome == "partial":
-            return 1, 0, 1
-        if outcome == "failed":
-            return 0, 1, 0
-        raise RuntimeError(f"Unexpected scholar outcome label: {outcome!r}")
-
-    @staticmethod
-    def _find_scholar_result_index(
-        *,
-        scholar_results: list[dict[str, Any]],
-        scholar_profile_id: int,
-    ) -> int | None:
-        for index, result_entry in enumerate(scholar_results):
-            current_scholar_id = _int_or_default(result_entry.get("scholar_profile_id"), 0)
-            if current_scholar_id == scholar_profile_id:
-                return index
-        return None
-
-    @staticmethod
-    def _adjust_progress_counts(
-        *,
-        progress: RunProgress,
-        succeeded_delta: int,
-        failed_delta: int,
-        partial_delta: int,
-    ) -> None:
-        progress.succeeded_count += succeeded_delta
-        progress.failed_count += failed_delta
-        progress.partial_count += partial_delta
-        if progress.succeeded_count < 0 or progress.failed_count < 0 or progress.partial_count < 0:
-            raise RuntimeError("RunProgress counters entered invalid negative state.")
-
-    @staticmethod
-    def _apply_outcome_to_progress(
-        *,
-        progress: RunProgress,
-        outcome: ScholarProcessingOutcome,
-    ) -> None:
-        scholar_profile_id = _int_or_default(outcome.result_entry.get("scholar_profile_id"), 0)
-        if scholar_profile_id <= 0:
-            raise RuntimeError("Scholar outcome missing valid scholar_profile_id.")
-        prior_index = ScholarIngestionService._find_scholar_result_index(
-            scholar_results=progress.scholar_results,
-            scholar_profile_id=scholar_profile_id,
-        )
-        next_succeeded, next_failed, next_partial = ScholarIngestionService._result_counters(outcome.result_entry)
-        if prior_index is None:
-            progress.scholar_results.append(outcome.result_entry)
-            ScholarIngestionService._adjust_progress_counts(
-                progress=progress,
-                succeeded_delta=next_succeeded,
-                failed_delta=next_failed,
-                partial_delta=next_partial,
-            )
-            return
-        previous_entry = progress.scholar_results[prior_index]
-        prev_succeeded, prev_failed, prev_partial = ScholarIngestionService._result_counters(previous_entry)
-        progress.scholar_results[prior_index] = outcome.result_entry
-        ScholarIngestionService._adjust_progress_counts(
-            progress=progress,
-            succeeded_delta=next_succeeded - prev_succeeded,
-            failed_delta=next_failed - prev_failed,
-            partial_delta=next_partial - prev_partial,
-        )
-
-    def _unexpected_scholar_exception_outcome(
-        self,
-        *,
-        run: CrawlRun,
-        scholar: ScholarProfile,
-        start_cstart: int,
-        exc: Exception,
-    ) -> ScholarProcessingOutcome:
-        scholar.last_run_status = RunStatus.FAILED
-        scholar.last_run_dt = datetime.now(UTC)
-        logger.exception(
-            "ingestion.scholar_unexpected_failure",
-            extra={
-                "crawl_run_id": run.id,
-                "scholar_profile_id": scholar.id,
-                "scholar_id": scholar.scholar_id,
-            },
-        )
-        return ScholarProcessingOutcome(
-            result_entry={
-                "scholar_profile_id": scholar.id,
-                "scholar_id": scholar.scholar_id,
-                "state": "ingestion_error",
-                "state_reason": "scholar_processing_exception",
-                "outcome": "failed",
-                "attempt_count": 0,
-                "publication_count": 0,
-                "start_cstart": start_cstart,
-                "warnings": [],
-                "error": str(exc),
-                "debug": {"exception_type": type(exc).__name__, "exception_message": str(exc)},
-            },
-            succeeded_count_delta=0,
-            failed_count_delta=1,
-            partial_count_delta=0,
-            discovered_publication_count=0,
-        )
-
-    @staticmethod
-    def _summarize_failures(
-        *,
-        scholar_results: list[dict[str, Any]],
-    ) -> RunFailureSummary:
-        failed_state_counts: dict[str, int] = {}
-        failed_reason_counts: dict[str, int] = {}
-        scrape_failure_counts: dict[str, int] = {}
-        retries_scheduled_count = 0
-        scholars_with_retries_count = 0
-        retry_exhausted_count = 0
-        for entry in scholar_results:
-            retries_for_entry = max(0, _int_or_default(entry.get("attempt_count"), 0) - 1)
-            if retries_for_entry > 0:
-                retries_scheduled_count += retries_for_entry
-                scholars_with_retries_count += 1
-            if str(entry.get("outcome", "")) != "failed":
-                continue
-            state = str(entry.get("state", "")).strip()
-            if state not in FAILED_STATES:
-                continue
-            failed_state_counts[state] = failed_state_counts.get(state, 0) + 1
-            reason = str(entry.get("state_reason", "")).strip()
-            if reason:
-                failed_reason_counts[reason] = failed_reason_counts.get(reason, 0) + 1
-            bucket = _classify_failure_bucket(state=state, state_reason=reason)
-            scrape_failure_counts[bucket] = scrape_failure_counts.get(bucket, 0) + 1
-            if state == ParseState.NETWORK_ERROR.value and retries_for_entry > 0:
-                retry_exhausted_count += 1
-        return RunFailureSummary(
-            failed_state_counts=failed_state_counts,
-            failed_reason_counts=failed_reason_counts,
-            scrape_failure_counts=scrape_failure_counts,
-            retries_scheduled_count=retries_scheduled_count,
-            scholars_with_retries_count=scholars_with_retries_count,
-            retry_exhausted_count=retry_exhausted_count,
-        )
-
-    @staticmethod
-    def _build_alert_summary(
-        *,
-        failure_summary: RunFailureSummary,
-        alert_blocked_failure_threshold: int,
-        alert_network_failure_threshold: int,
-        alert_retry_scheduled_threshold: int,
-    ) -> RunAlertSummary:
-        blocked_failure_count = int(failure_summary.scrape_failure_counts.get(FAILURE_BUCKET_BLOCKED, 0))
-        network_failure_count = int(failure_summary.scrape_failure_counts.get(FAILURE_BUCKET_NETWORK, 0))
-        blocked_threshold = max(1, int(alert_blocked_failure_threshold))
-        network_threshold = max(1, int(alert_network_failure_threshold))
-        retry_threshold = max(1, int(alert_retry_scheduled_threshold))
-        alert_flags = {
-            "blocked_failure_threshold_exceeded": blocked_failure_count >= blocked_threshold,
-            "network_failure_threshold_exceeded": network_failure_count >= network_threshold,
-            "retry_scheduled_threshold_exceeded": failure_summary.retries_scheduled_count >= retry_threshold,
-        }
-        return RunAlertSummary(
-            blocked_failure_count=blocked_failure_count,
-            network_failure_count=network_failure_count,
-            blocked_failure_threshold=blocked_threshold,
-            network_failure_threshold=network_threshold,
-            retry_scheduled_threshold=retry_threshold,
-            alert_flags=alert_flags,
-        )
-
-    @staticmethod
-    def _apply_safety_outcome(
-        *,
-        user_settings,
-        run: CrawlRun,
-        user_id: int,
-        alert_summary: RunAlertSummary,
-    ) -> None:
-        pre_apply_state = run_safety_service.get_safety_event_context(
-            user_settings,
-            now_utc=datetime.now(UTC),
-        )
-        safety_state, cooldown_trigger_reason = run_safety_service.apply_run_safety_outcome(
-            user_settings,
-            run_id=int(run.id),
-            blocked_failure_count=alert_summary.blocked_failure_count,
-            network_failure_count=alert_summary.network_failure_count,
-            blocked_failure_threshold=alert_summary.blocked_failure_threshold,
-            network_failure_threshold=alert_summary.network_failure_threshold,
-            blocked_cooldown_seconds=settings.ingestion_safety_cooldown_blocked_seconds,
-            network_cooldown_seconds=settings.ingestion_safety_cooldown_network_seconds,
-            now_utc=datetime.now(UTC),
-        )
-        if cooldown_trigger_reason is not None:
-            structured_log(
-                logger,
-                "warning",
-                "ingestion.safety_cooldown_entered",
-                user_id=user_id,
-                crawl_run_id=int(run.id),
-                reason=cooldown_trigger_reason,
-                blocked_failure_count=alert_summary.blocked_failure_count,
-                network_failure_count=alert_summary.network_failure_count,
-                blocked_failure_threshold=alert_summary.blocked_failure_threshold,
-                network_failure_threshold=alert_summary.network_failure_threshold,
-                cooldown_until=safety_state.get("cooldown_until"),
-                cooldown_remaining_seconds=safety_state.get("cooldown_remaining_seconds"),
-                safety_counters=safety_state.get("counters", {}),
-            )
-        elif pre_apply_state.get("cooldown_active") and not safety_state.get("cooldown_active"):
-            structured_log(
-                logger,
-                "info",
-                "ingestion.cooldown_cleared",
-                user_id=user_id,
-                crawl_run_id=int(run.id),
-                reason=pre_apply_state.get("cooldown_reason"),
-                cooldown_until=pre_apply_state.get("cooldown_until"),
-            )
-
-    def _finalize_run_record(
-        self,
-        *,
-        run: CrawlRun,
-        scholars: list[ScholarProfile],
-        progress: RunProgress,
-        failure_summary: RunFailureSummary,
-        alert_summary: RunAlertSummary,
-        idempotency_key: str | None,
-    ) -> None:
-        run.end_dt = datetime.now(UTC)
-        if run.status != RunStatus.CANCELED:
-            run.status = self._resolve_run_status(
-                scholar_count=len(scholars),
-                succeeded_count=progress.succeeded_count,
-                failed_count=progress.failed_count,
-                partial_count=progress.partial_count,
-            )
-        run.error_log = {
-            "scholar_results": progress.scholar_results,
-            "summary": {
-                "succeeded_count": progress.succeeded_count,
-                "failed_count": progress.failed_count,
-                "partial_count": progress.partial_count,
-                "failed_state_counts": failure_summary.failed_state_counts,
-                "failed_reason_counts": failure_summary.failed_reason_counts,
-                "scrape_failure_counts": failure_summary.scrape_failure_counts,
-                "retry_counts": {
-                    "retries_scheduled_count": failure_summary.retries_scheduled_count,
-                    "scholars_with_retries_count": failure_summary.scholars_with_retries_count,
-                    "retry_exhausted_count": failure_summary.retry_exhausted_count,
-                },
-                "alert_thresholds": {
-                    "blocked_failure_threshold": alert_summary.blocked_failure_threshold,
-                    "network_failure_threshold": alert_summary.network_failure_threshold,
-                    "retry_scheduled_threshold": alert_summary.retry_scheduled_threshold,
-                },
-                "alert_flags": alert_summary.alert_flags,
-            },
-            "meta": {"idempotency_key": idempotency_key} if idempotency_key else {},
-        }
-
-    @staticmethod
-    def _paging_kwargs(
-        *,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-    ) -> dict[str, Any]:
-        return {
-            "request_delay_seconds": request_delay_seconds,
-            "network_error_retries": network_error_retries,
-            "retry_backoff_seconds": retry_backoff_seconds,
-            "rate_limit_retries": rate_limit_retries,
-            "rate_limit_backoff_seconds": rate_limit_backoff_seconds,
-            "max_pages_per_scholar": max_pages_per_scholar,
-            "page_size": page_size,
-        }
-
-    @staticmethod
-    def _threshold_kwargs(
-        *,
-        alert_blocked_failure_threshold: int,
-        alert_network_failure_threshold: int,
-        alert_retry_scheduled_threshold: int,
-    ) -> dict[str, Any]:
-        return {
-            "alert_blocked_failure_threshold": alert_blocked_failure_threshold,
-            "alert_network_failure_threshold": alert_network_failure_threshold,
-            "alert_retry_scheduled_threshold": alert_retry_scheduled_threshold,
-        }
-
-    @staticmethod
-    def _run_execution_summary(
-        *,
-        run: CrawlRun,
-        scholars: list[ScholarProfile],
-        progress: RunProgress,
-    ) -> RunExecutionSummary:
-        return RunExecutionSummary(
-            crawl_run_id=run.id,
-            status=run.status,
-            scholar_count=len(scholars),
-            succeeded_count=progress.succeeded_count,
-            failed_count=progress.failed_count,
-            partial_count=progress.partial_count,
-            new_publication_count=run.new_pub_count,
-        )
-
     async def _initialize_run_for_user(
         self,
         db_session: AsyncSession,
@@ -1070,17 +239,9 @@ class ScholarIngestionService:
         trigger_type: RunTriggerType,
         scholar_profile_ids: set[int] | None,
         start_cstart_by_scholar_id: dict[int, int] | None,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
+        paging_kwargs: dict[str, Any],
+        threshold_kwargs: dict[str, Any],
         idempotency_key: str | None,
-        alert_blocked_failure_threshold: int,
-        alert_network_failure_threshold: int,
-        alert_retry_scheduled_threshold: int,
     ) -> tuple[Any, CrawlRun, list[ScholarProfile], dict[int, int]]:
         user_settings = await self._load_user_settings_for_run(
             db_session,
@@ -1089,34 +250,26 @@ class ScholarIngestionService:
         )
         if not await self._try_acquire_user_lock(db_session, user_id=user_id):
             raise RunAlreadyInProgressError(f"Run already in progress for user_id={user_id}.")
-        filtered_scholar_ids, start_cstart_map = self._normalize_run_targets(
-            scholar_profile_ids=scholar_profile_ids,
-            start_cstart_by_scholar_id=start_cstart_by_scholar_id,
-        )
+        filtered_scholar_ids = {int(v) for v in scholar_profile_ids} if scholar_profile_ids is not None else None
+        start_cstart_map = {int(k): max(0, int(v)) for k, v in (start_cstart_by_scholar_id or {}).items()}
         scholars = await self._load_target_scholars(
             db_session,
             user_id=user_id,
             filtered_scholar_ids=filtered_scholar_ids,
         )
-        run = await self._start_run_record_for_targets(
+        run = await self._start_run_record(
             db_session,
             user_id=user_id,
             trigger_type=trigger_type,
             scholars=scholars,
             filtered=filtered_scholar_ids is not None,
-            request_delay_seconds=request_delay_seconds,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            max_pages_per_scholar=max_pages_per_scholar,
-            page_size=page_size,
             idempotency_key=idempotency_key,
-            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
-            alert_network_failure_threshold=alert_network_failure_threshold,
-            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+            paging_kwargs=paging_kwargs,
+            threshold_kwargs=threshold_kwargs,
         )
         return user_settings, run, scholars, start_cstart_map
 
-    async def _start_run_record_for_targets(
+    async def _start_run_record(
         self,
         db_session: AsyncSession,
         *,
@@ -1124,15 +277,9 @@ class ScholarIngestionService:
         trigger_type: RunTriggerType,
         scholars: list[ScholarProfile],
         filtered: bool,
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
         idempotency_key: str | None,
-        alert_blocked_failure_threshold: int,
-        alert_network_failure_threshold: int,
-        alert_retry_scheduled_threshold: int,
+        paging_kwargs: dict[str, Any],
+        threshold_kwargs: dict[str, Any],
     ) -> CrawlRun:
         structured_log(
             logger,
@@ -1142,21 +289,18 @@ class ScholarIngestionService:
             trigger_type=trigger_type.value,
             scholar_count=len(scholars),
             is_filtered_run=filtered,
-            request_delay_seconds=request_delay_seconds,
-            network_error_retries=network_error_retries,
-            retry_backoff_seconds=retry_backoff_seconds,
-            max_pages_per_scholar=max_pages_per_scholar,
-            page_size=page_size,
             idempotency_key=idempotency_key,
-            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
-            alert_network_failure_threshold=alert_network_failure_threshold,
-            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+            **paging_kwargs,
+            **threshold_kwargs,
         )
-        run = self._create_running_run(
+        run = CrawlRun(
             user_id=user_id,
             trigger_type=trigger_type,
+            status=RunStatus.RUNNING,
             scholar_count=len(scholars),
+            new_pub_count=0,
             idempotency_key=idempotency_key,
+            error_log={},
         )
         db_session.add(run)
         try:
@@ -1168,165 +312,6 @@ class ScholarIngestionService:
             raise
         return run
 
-    async def _run_scholar_iteration(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        scholars: list[ScholarProfile],
-        user_id: int,
-        start_cstart_map: dict[int, int],
-        request_delay_seconds: int,
-        network_error_retries: int,
-        retry_backoff_seconds: float,
-        rate_limit_retries: int,
-        rate_limit_backoff_seconds: float,
-        max_pages_per_scholar: int,
-        page_size: int,
-        auto_queue_continuations: bool,
-        queue_delay_seconds: int,
-    ) -> RunProgress:
-        progress = RunProgress()
-
-        # ── Pass 1: first page of every scholar (breadth-first) ──────────
-        # This ensures all scholars have visible publications as quickly as
-        # possible, rather than fully paginating one scholar before the next.
-        first_pass_cstarts: dict[int, int] = {}
-        for index, scholar in enumerate(scholars):
-            await db_session.refresh(run)
-            if run.status == RunStatus.CANCELED:
-                structured_log(
-                    logger,
-                    "info",
-                    "ingestion.run_canceled",
-                    run_id=run.id,
-                    user_id=user_id,
-                )
-                return progress
-            await self._wait_between_scholars(index=index, request_delay_seconds=request_delay_seconds)
-            start_cstart = int(start_cstart_map.get(int(scholar.id), 0))
-            outcome = await self._process_scholar(
-                db_session,
-                run=run,
-                scholar=scholar,
-                user_id=user_id,
-                request_delay_seconds=request_delay_seconds,
-                network_error_retries=network_error_retries,
-                retry_backoff_seconds=retry_backoff_seconds,
-                rate_limit_retries=rate_limit_retries,
-                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-                max_pages_per_scholar=1,
-                page_size=page_size,
-                start_cstart=start_cstart,
-                auto_queue_continuations=False,
-                queue_delay_seconds=queue_delay_seconds,
-            )
-            self._apply_outcome_to_progress(progress=progress, outcome=outcome)
-            # Track where to resume from for the deep pass
-            resume_cstart = outcome.result_entry.get("continuation_cstart")
-            if resume_cstart is not None and int(resume_cstart) > start_cstart:
-                first_pass_cstarts[int(scholar.id)] = int(resume_cstart)
-
-        # ── Pass 2: remaining pages for each scholar (depth) ─────────────
-        remaining_max = max(max_pages_per_scholar - 1, 0)
-        if remaining_max <= 0:
-            return progress
-
-        for index, scholar in enumerate(scholars):
-            resume_cstart = first_pass_cstarts.get(int(scholar.id))
-            if resume_cstart is None:
-                continue  # first page failed, had no continuation, or was skipped
-            await db_session.refresh(run)
-            if run.status == RunStatus.CANCELED:
-                structured_log(
-                    logger,
-                    "info",
-                    "ingestion.run_canceled",
-                    run_id=run.id,
-                    user_id=user_id,
-                )
-                break
-            await self._wait_between_scholars(index=index, request_delay_seconds=request_delay_seconds)
-            outcome = await self._process_scholar(
-                db_session,
-                run=run,
-                scholar=scholar,
-                user_id=user_id,
-                request_delay_seconds=request_delay_seconds,
-                network_error_retries=network_error_retries,
-                retry_backoff_seconds=retry_backoff_seconds,
-                rate_limit_retries=rate_limit_retries,
-                rate_limit_backoff_seconds=rate_limit_backoff_seconds,
-                max_pages_per_scholar=remaining_max,
-                page_size=page_size,
-                start_cstart=resume_cstart,
-                auto_queue_continuations=auto_queue_continuations,
-                queue_delay_seconds=queue_delay_seconds,
-            )
-            self._apply_outcome_to_progress(progress=progress, outcome=outcome)
-        return progress
-
-    def _complete_run_for_user(
-        self,
-        *,
-        user_settings: Any,
-        run: CrawlRun,
-        scholars: list[ScholarProfile],
-        user_id: int,
-        progress: RunProgress,
-        idempotency_key: str | None,
-        alert_blocked_failure_threshold: int,
-        alert_network_failure_threshold: int,
-        alert_retry_scheduled_threshold: int,
-    ) -> tuple[RunFailureSummary, RunAlertSummary]:
-        failure_summary = self._summarize_failures(scholar_results=progress.scholar_results)
-        alert_summary = self._build_alert_summary(
-            failure_summary=failure_summary,
-            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
-            alert_network_failure_threshold=alert_network_failure_threshold,
-            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
-        )
-        if alert_summary.alert_flags["blocked_failure_threshold_exceeded"]:
-            structured_log(
-                logger,
-                "warning",
-                "ingestion.alert_blocked_failure_threshold_exceeded",
-                user_id=user_id,
-                crawl_run_id=int(run.id),
-                blocked_failure_count=alert_summary.blocked_failure_count,
-                threshold=alert_summary.blocked_failure_threshold,
-            )
-        if alert_summary.alert_flags["network_failure_threshold_exceeded"]:
-            structured_log(
-                logger,
-                "warning",
-                "ingestion.alert_network_failure_threshold_exceeded",
-                user_id=user_id,
-                crawl_run_id=int(run.id),
-                network_failure_count=alert_summary.network_failure_count,
-                threshold=alert_summary.network_failure_threshold,
-            )
-        if alert_summary.alert_flags["retry_scheduled_threshold_exceeded"]:
-            structured_log(
-                logger,
-                "warning",
-                "ingestion.alert_retry_scheduled_threshold_exceeded",
-                user_id=user_id,
-                crawl_run_id=int(run.id),
-                retries_scheduled_count=failure_summary.retries_scheduled_count,
-                threshold=alert_summary.retry_scheduled_threshold,
-            )
-        self._apply_safety_outcome(user_settings=user_settings, run=run, user_id=user_id, alert_summary=alert_summary)
-        self._finalize_run_record(
-            run=run,
-            scholars=scholars,
-            progress=progress,
-            failure_summary=failure_summary,
-            alert_summary=alert_summary,
-            idempotency_key=idempotency_key,
-        )
-        return failure_summary, alert_summary
-
     async def initialize_run(
         self,
         db_session: AsyncSession,
@@ -1360,26 +345,20 @@ class ScholarIngestionService:
                     settings.ingestion_min_request_delay_seconds
                 ),
             )
-
-        paging_kwargs = self._paging_kwargs(
+        paging = _resolve_paging_kwargs(
             request_delay_seconds=effective_delay,
             network_error_retries=network_error_retries,
             retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries
-            if rate_limit_retries is not None
-            else settings.ingestion_rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds
-            if rate_limit_backoff_seconds is not None
-            else settings.ingestion_rate_limit_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
             max_pages_per_scholar=max_pages_per_scholar,
             page_size=page_size,
         )
-        threshold_kwargs = self._threshold_kwargs(
+        thresholds = _threshold_kwargs(
             alert_blocked_failure_threshold=alert_blocked_failure_threshold,
             alert_network_failure_threshold=alert_network_failure_threshold,
             alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
         )
-
         _, run, scholars, start_cstart_map = await self._initialize_run_for_user(
             db_session,
             user_id=user_id,
@@ -1387,8 +366,8 @@ class ScholarIngestionService:
             scholar_profile_ids=scholar_profile_ids,
             start_cstart_by_scholar_id=start_cstart_by_scholar_id,
             idempotency_key=idempotency_key,
-            **paging_kwargs,
-            **threshold_kwargs,
+            paging_kwargs=paging,
+            threshold_kwargs=thresholds,
         )
         return run, scholars, start_cstart_map
 
@@ -1414,78 +393,57 @@ class ScholarIngestionService:
         alert_retry_scheduled_threshold: int = 3,
         idempotency_key: str | None = None,
     ) -> None:
+        paging = _resolve_paging_kwargs(
+            request_delay_seconds=request_delay_seconds,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+            max_pages_per_scholar=max_pages_per_scholar,
+            page_size=page_size,
+        )
+        thresholds = _threshold_kwargs(
+            alert_blocked_failure_threshold=alert_blocked_failure_threshold,
+            alert_network_failure_threshold=alert_network_failure_threshold,
+            alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+        )
         async with session_factory() as db_session:
             try:
-                # Re-fetch everything to ensure attachment to the new session
                 run, user_settings, attached_scholars = await self._prepare_execute_run(
                     db_session, run_id=run_id, user_id=user_id, scholars=scholars
                 )
-
-                paging_kwargs = self._paging_kwargs(
-                    request_delay_seconds=request_delay_seconds,
-                    network_error_retries=network_error_retries,
-                    retry_backoff_seconds=retry_backoff_seconds,
-                    rate_limit_retries=rate_limit_retries
-                    if rate_limit_retries is not None
-                    else settings.ingestion_rate_limit_retries,
-                    rate_limit_backoff_seconds=rate_limit_backoff_seconds
-                    if rate_limit_backoff_seconds is not None
-                    else settings.ingestion_rate_limit_backoff_seconds,
-                    max_pages_per_scholar=max_pages_per_scholar,
-                    page_size=page_size,
-                )
-                threshold_kwargs = self._threshold_kwargs(
-                    alert_blocked_failure_threshold=alert_blocked_failure_threshold,
-                    alert_network_failure_threshold=alert_network_failure_threshold,
-                    alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
-                )
-
-                progress = await self._run_scholar_iteration(
+                progress = await run_scholar_iteration(
                     db_session,
+                    pagination=self._pagination,
                     run=run,
                     scholars=attached_scholars,
                     user_id=user_id,
                     start_cstart_map=start_cstart_map,
                     auto_queue_continuations=auto_queue_continuations,
                     queue_delay_seconds=queue_delay_seconds,
-                    **paging_kwargs,
+                    **paging,
                 )
-
-                failure_summary, alert_summary = self._complete_run_for_user(
+                failure_summary, alert_summary = complete_run_for_user(
                     user_settings=user_settings,
                     run=run,
                     scholars=attached_scholars,
                     user_id=user_id,
                     progress=progress,
                     idempotency_key=idempotency_key,
-                    **threshold_kwargs,
+                    **thresholds,
                 )
-
-                # Capture the final status that _finalize_run_record computed,
-                # then set RESOLVING so the UI shows enrichment is in progress.
                 intended_final_status = run.status
                 if intended_final_status not in (RunStatus.CANCELED,):
                     run.status = RunStatus.RESOLVING
                 await db_session.commit()
-                structured_log(
-                    logger,
-                    "info",
-                    "ingestion.run_completed",
+                _log_run_completed(
+                    run=run,
                     user_id=user_id,
-                    crawl_run_id=run.id,
-                    status=run.status.value,
-                    scholar_count=len(attached_scholars),
-                    succeeded_count=progress.succeeded_count,
-                    failed_count=progress.failed_count,
-                    partial_count=progress.partial_count,
-                    new_publication_count=run.new_pub_count,
-                    blocked_failure_count=alert_summary.blocked_failure_count,
-                    network_failure_count=alert_summary.network_failure_count,
-                    retries_scheduled_count=failure_summary.retries_scheduled_count,
-                    alert_flags=alert_summary.alert_flags,
+                    scholars=attached_scholars,
+                    progress=progress,
+                    failure_summary=failure_summary,
+                    alert_summary=alert_summary,
                 )
-
-                # Fire-and-forget enrichment in a separate background task
                 if intended_final_status not in (RunStatus.CANCELED,):
                     task = asyncio.create_task(
                         self._background_enrich(
@@ -1513,7 +471,6 @@ class ScholarIngestionService:
         run_result = await db_session.execute(select(CrawlRun).where(CrawlRun.id == run_id))
         run = run_result.scalar_one()
         user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=user_id)
-
         scholar_ids = [s.id for s in scholars]
         scholars_result = await db_session.execute(
             select(ScholarProfile)
@@ -1539,10 +496,9 @@ class ScholarIngestionService:
         intended_final_status: RunStatus,
         openalex_api_key: str | None = None,
     ) -> None:
-        """Run enrichment independently — failures don't affect run status."""
         try:
             async with session_factory() as session:
-                await self._enrich_pending_publications(
+                await self._enrichment.enrich_pending_publications(
                     session,
                     run_id=run_id,
                     openalex_api_key=openalex_api_key,
@@ -1556,11 +512,7 @@ class ScholarIngestionService:
                     extra={"run_id": run_id, "final_status": str(intended_final_status)},
                 )
         except Exception:
-            logger.exception(
-                "ingestion.background_enrichment_failed",
-                extra={"run_id": run_id},
-            )
-            # Still transition out of RESOLVING so the run doesn't stay stuck.
+            logger.exception("ingestion.background_enrichment_failed", extra={"run_id": run_id})
             try:
                 async with session_factory() as fallback_session:
                     run = await fallback_session.get(CrawlRun, run_id)
@@ -1568,10 +520,7 @@ class ScholarIngestionService:
                         run.status = intended_final_status
                     await fallback_session.commit()
             except Exception:
-                logger.exception(
-                    "ingestion.background_enrichment_fallback_failed",
-                    extra={"run_id": run_id},
-                )
+                logger.exception("ingestion.background_enrichment_fallback_failed", extra={"run_id": run_id})
 
     async def run_for_user(
         self,
@@ -1594,8 +543,7 @@ class ScholarIngestionService:
         alert_blocked_failure_threshold: int = 1,
         alert_network_failure_threshold: int = 2,
         alert_retry_scheduled_threshold: int = 3,
-    ) -> RunExecutionSummary:
-        # Legacy/Synchronous trigger (used by tests or older flows)
+    ):
         run, scholars, start_cstart_map = await self.initialize_run(
             db_session,
             user_id=user_id,
@@ -1614,459 +562,65 @@ class ScholarIngestionService:
             alert_network_failure_threshold=alert_network_failure_threshold,
             alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
         )
-
-        paging_kwargs = self._paging_kwargs(
+        paging = _resolve_paging_kwargs(
             request_delay_seconds=self._effective_request_delay_seconds(request_delay_seconds),
             network_error_retries=network_error_retries,
             retry_backoff_seconds=retry_backoff_seconds,
-            rate_limit_retries=rate_limit_retries
-            if rate_limit_retries is not None
-            else settings.ingestion_rate_limit_retries,
-            rate_limit_backoff_seconds=rate_limit_backoff_seconds
-            if rate_limit_backoff_seconds is not None
-            else settings.ingestion_rate_limit_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
             max_pages_per_scholar=max_pages_per_scholar,
             page_size=page_size,
         )
-
-        threshold_kwargs = self._threshold_kwargs(
+        thresholds = _threshold_kwargs(
             alert_blocked_failure_threshold=alert_blocked_failure_threshold,
             alert_network_failure_threshold=alert_network_failure_threshold,
             alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
         )
-
-        progress = await self._run_scholar_iteration(
+        progress = await run_scholar_iteration(
             db_session,
+            pagination=self._pagination,
             run=run,
             scholars=scholars,
             user_id=user_id,
             start_cstart_map=start_cstart_map,
             auto_queue_continuations=auto_queue_continuations,
             queue_delay_seconds=queue_delay_seconds,
-            **paging_kwargs,
+            **paging,
         )
-
         user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=user_id)
-        failure_summary, alert_summary = self._complete_run_for_user(
+        failure_summary, alert_summary = complete_run_for_user(
             user_settings=user_settings,
             run=run,
             scholars=scholars,
             user_id=user_id,
             progress=progress,
             idempotency_key=idempotency_key,
-            **threshold_kwargs,
+            **thresholds,
         )
-
-        # Set RESOLVING during enrichment (synchronous path).
         intended_final_status = run.status
         if intended_final_status not in (RunStatus.CANCELED,):
             run.status = RunStatus.RESOLVING
         await db_session.commit()
-
         try:
-            await self._enrich_pending_publications(
+            await self._enrichment.enrich_pending_publications(
                 db_session,
                 run_id=run.id,
                 openalex_api_key=getattr(user_settings, "openalex_api_key", None),
             )
         except Exception:
             logger.exception("ingestion.enrichment_failed", extra={"run_id": run.id})
-
-        # Finalize to the intended status unless the run was canceled during resolving.
         if run.status == RunStatus.RESOLVING:
             run.status = intended_final_status
         await db_session.commit()
-
-        structured_log(
-            logger,
-            "info",
-            "ingestion.run_completed",
+        _log_run_completed(
+            run=run,
             user_id=user_id,
-            crawl_run_id=run.id,
-            status=run.status.value,
-            scholar_count=len(scholars),
-            succeeded_count=progress.succeeded_count,
-            failed_count=progress.failed_count,
-            partial_count=progress.partial_count,
-            new_publication_count=run.new_pub_count,
-            blocked_failure_count=alert_summary.blocked_failure_count,
-            network_failure_count=alert_summary.network_failure_count,
-            retries_scheduled_count=failure_summary.retries_scheduled_count,
-            alert_flags=alert_summary.alert_flags,
+            scholars=scholars,
+            progress=progress,
+            failure_summary=failure_summary,
+            alert_summary=alert_summary,
         )
-        return self._run_execution_summary(run=run, scholars=scholars, progress=progress)
-
-    async def _run_is_canceled(
-        self,
-        db_session: AsyncSession,
-        *,
-        run_id: int,
-    ) -> bool:
-        check_result = await db_session.execute(select(CrawlRun.status).where(CrawlRun.id == run_id))
-        status = check_result.scalar_one_or_none()
-        if status is None:
-            raise RuntimeError(f"Missing crawl_run for run_id={run_id}.")
-        return status == RunStatus.CANCELED
-
-    async def _enrich_pending_publications(
-        self,
-        db_session: AsyncSession,
-        *,
-        run_id: int,
-        openalex_api_key: str | None = None,
-    ) -> None:
-        """Enrich unenriched publications with OpenAlex data.
-
-        Stops immediately on budget exhaustion (429 with $0 remaining).
-        Sleeps 60s and continues on transient rate limits.
-        """
-        from app.services.openalex.client import (
-            OpenAlexBudgetExhaustedError,
-            OpenAlexClient,
-            OpenAlexRateLimitError,
-        )
-        from app.services.openalex.matching import find_best_match
-
-        run_result = await db_session.execute(select(CrawlRun.user_id).where(CrawlRun.id == run_id))
-        user_id = run_result.scalar_one()
-
-        now = datetime.now(UTC)
-        cooldown_threshold = now - timedelta(days=7)
-
-        stmt = (
-            select(Publication)
-            .join(ScholarPublication)
-            .join(ScholarProfile, ScholarPublication.scholar_profile_id == ScholarProfile.id)
-            .where(
-                ScholarProfile.user_id == user_id,
-                Publication.openalex_enriched.is_(False),
-                or_(
-                    Publication.openalex_last_attempt_at.is_(None),
-                    Publication.openalex_last_attempt_at < cooldown_threshold,
-                ),
-            )
-            .distinct()
-        )
-        result = await db_session.execute(stmt)
-        publications = list(result.scalars().all())
-
-        if not publications:
-            return
-
-        resolved_key = openalex_api_key or settings.openalex_api_key
-        client = OpenAlexClient(api_key=resolved_key, mailto=settings.crossref_api_mailto)
-        batch_size = 25
-        arxiv_lookup_allowed = True
-
-        for i in range(0, len(publications), batch_size):
-            if await self._run_is_canceled(db_session, run_id=run_id):
-                logger.info("ingestion.enrichment_aborted", extra={"run_id": run_id})
-                return
-            batch = publications[i : i + batch_size]
-            titles = [
-                " ".join(re.sub(r"[^\w\s]", " ", p.title_raw).split())
-                for p in batch
-                if p.title_raw and p.title_raw.strip()
-            ]
-
-            if not titles:
-                continue
-
-            try:
-                openalex_works = await client.get_works_by_filter(
-                    {"title.search": "|".join(titles)}, limit=batch_size * 3
-                )
-            except OpenAlexBudgetExhaustedError:
-                structured_log(
-                    logger,
-                    "warning",
-                    "ingestion.openalex_budget_exhausted",
-                    run_id=run_id,
-                )
-                break  # Stop all enrichment — budget won't reset until midnight UTC
-            except OpenAlexRateLimitError:
-                structured_log(
-                    logger,
-                    "warning",
-                    "ingestion.openalex_rate_limited",
-                    run_id=run_id,
-                )
-                await asyncio.sleep(60)
-                continue
-            except Exception as e:
-                structured_log(
-                    logger,
-                    "warning",
-                    "ingestion.openalex_enrichment_failed",
-                    error=str(e),
-                    run_id=run_id,
-                )
-                continue
-
-            for p in batch:
-                # Check for cancellation periodically within the batch
-                if await self._run_is_canceled(db_session, run_id=run_id):
-                    logger.info("ingestion.enrichment_aborted", extra={"run_id": run_id})
-                    return
-
-                p.openalex_last_attempt_at = now
-                arxiv_lookup_allowed = await self._discover_identifiers_for_enrichment(
-                    db_session,
-                    publication=p,
-                    run_id=run_id,
-                    allow_arxiv_lookup=arxiv_lookup_allowed,
-                )
-
-                match = find_best_match(
-                    target_title=p.title_raw,
-                    target_year=p.year,
-                    target_authors=p.author_text or "",
-                    candidates=openalex_works,
-                )
-                if match:
-                    p.year = match.publication_year or p.year
-                    p.citation_count = match.cited_by_count or p.citation_count
-                    p.pdf_url = match.oa_url or p.pdf_url
-                    p.openalex_enriched = True
-
-        await db_session.flush()
-
-        from app.services.publications.dedup import sweep_identifier_duplicates
-
-        merge_count = await sweep_identifier_duplicates(db_session)
-        if merge_count:
-            structured_log(
-                logger,
-                "info",
-                "ingestion.identifier_dedup_sweep",
-                merged_count=merge_count,
-                run_id=run_id,
-            )
-
-    async def _discover_identifiers_for_enrichment(
-        self,
-        db_session: AsyncSession,
-        *,
-        publication: Publication,
-        run_id: int,
-        allow_arxiv_lookup: bool,
-    ) -> bool:
-        if not allow_arxiv_lookup:
-            await identifier_service.sync_identifiers_for_publication_fields(
-                db_session,
-                publication=publication,
-            )
-            await self._publish_identifier_update_event(
-                db_session,
-                run_id=run_id,
-                publication_id=int(publication.id),
-            )
-            return False
-        try:
-            await identifier_service.discover_and_sync_identifiers_for_publication(
-                db_session,
-                publication=publication,
-                scholar_label=publication.author_text or "",
-            )
-            await self._publish_identifier_update_event(
-                db_session,
-                run_id=run_id,
-                publication_id=int(publication.id),
-            )
-            return True
-        except ArxivRateLimitError:
-            structured_log(
-                logger,
-                "warning",
-                "ingestion.arxiv_rate_limited",
-                run_id=run_id,
-                publication_id=int(publication.id),
-                detail="arXiv temporarily disabled for remaining enrichment pass",
-            )
-            await identifier_service.sync_identifiers_for_publication_fields(
-                db_session,
-                publication=publication,
-            )
-            await self._publish_identifier_update_event(
-                db_session,
-                run_id=run_id,
-                publication_id=int(publication.id),
-            )
-            return False
-
-    async def _publish_identifier_update_event(
-        self,
-        db_session: AsyncSession,
-        *,
-        run_id: int,
-        publication_id: int,
-    ) -> None:
-        display = await identifier_service.display_identifier_for_publication_id(
-            db_session,
-            publication_id=publication_id,
-        )
-        if display is None:
-            return
-        await run_events.publish(
-            run_id=run_id,
-            event_type="identifier_updated",
-            data={
-                "publication_id": int(publication_id),
-                "display_identifier": {
-                    "kind": display.kind,
-                    "value": display.value,
-                    "label": display.label,
-                    "url": display.url,
-                    "confidence_score": float(display.confidence_score),
-                },
-            },
-        )
-
-    async def _enrich_publications_with_openalex(
-        self,
-        scholar: ScholarProfile,
-        publications: list[PublicationCandidate],
-    ) -> list[PublicationCandidate]:
-        if not publications:
-            return publications
-
-        from app.services.openalex.client import OpenAlexClient
-        from app.services.openalex.matching import find_best_match
-
-        client = OpenAlexClient(api_key=settings.openalex_api_key, mailto=settings.crossref_api_mailto)
-
-        # Batch requests by 25 to stay within URL length limits
-        batch_size = 25
-        enriched: list[PublicationCandidate] = []
-
-        import re
-
-        for i in range(0, len(publications), batch_size):
-            batch = publications[i : i + batch_size]
-
-            titles = []
-            for p in batch:
-                if not p.title:
-                    continue
-                # Strip all non-alphanumeric words to prevent OpenAlex API injection crashes
-                # and minimize punctuation-based duplicate misses.
-                safe_title = re.sub(r"[^\w\s]", " ", p.title)
-                safe_title = " ".join(safe_title.split())
-                if safe_title:
-                    titles.append(safe_title)
-
-            if not titles:
-                enriched.extend(batch)
-                continue
-
-            query = "|".join(t for t in titles)
-            try:
-                openalex_works = await client.get_works_by_filter({"title.search": query}, limit=batch_size * 3)
-            except Exception as e:
-                logger.warning(
-                    "ingestion.openalex_enrichment_failed",
-                    extra={"error": str(e), "batch_size": len(batch), "scholar_id": scholar.id},
-                )
-                openalex_works = []
-
-            for p in batch:
-                match = find_best_match(
-                    target_title=p.title,
-                    target_year=p.year,
-                    target_authors=p.authors_text or (scholar.display_name or scholar.scholar_id),
-                    candidates=openalex_works,
-                )
-                if match:
-                    new_p = PublicationCandidate(
-                        title=p.title,
-                        title_url=p.title_url,
-                        cluster_id=p.cluster_id,
-                        year=match.publication_year or p.year,
-                        citation_count=match.cited_by_count,
-                        authors_text=p.authors_text,
-                        venue_text=p.venue_text,
-                        pdf_url=match.oa_url or p.pdf_url,
-                    )
-                    enriched.append(new_p)
-                else:
-                    enriched.append(p)
-        return enriched
-
-    def _resolve_run_status(
-        self,
-        *,
-        scholar_count: int,
-        succeeded_count: int,
-        failed_count: int,
-        partial_count: int,
-    ) -> RunStatus:
-        if scholar_count == 0:
-            return RunStatus.SUCCESS
-        if failed_count == scholar_count:
-            return RunStatus.FAILED
-        if failed_count > 0 or partial_count > 0:
-            return RunStatus.PARTIAL_FAILURE
-        if succeeded_count > 0:
-            return RunStatus.SUCCESS
-        return RunStatus.FAILED
-
-    def _resolve_continuation_queue_target(
-        self,
-        *,
-        outcome: str,
-        state: str,
-        pagination_truncated_reason: str | None,
-        continuation_cstart: int | None,
-        fallback_cstart: int,
-    ) -> tuple[str | None, int]:
-        if outcome == "partial":
-            reason = (pagination_truncated_reason or "").strip()
-            if reason in RESUMABLE_PARTIAL_REASONS or reason.startswith(RESUMABLE_PARTIAL_REASON_PREFIXES):
-                return reason, queue_service.normalize_cstart(
-                    continuation_cstart if continuation_cstart is not None else fallback_cstart
-                )
-            return None, queue_service.normalize_cstart(fallback_cstart)
-
-        if outcome == "failed" and state == ParseState.NETWORK_ERROR.value:
-            return "network_error_retry", queue_service.normalize_cstart(
-                continuation_cstart if continuation_cstart is not None else fallback_cstart
-            )
-
-        return None, queue_service.normalize_cstart(fallback_cstart)
-
-    def _build_failure_debug_context(
-        self,
-        *,
-        fetch_result: FetchResult,
-        parsed_page: ParsedProfilePage,
-        attempt_log: list[dict[str, Any]],
-        page_logs: list[dict[str, Any]] | None = None,
-        exception: Exception | None = None,
-    ) -> dict[str, Any]:
-        context: dict[str, Any] = {
-            "requested_url": fetch_result.requested_url,
-            "final_url": fetch_result.final_url,
-            "status_code": fetch_result.status_code,
-            "fetch_error": fetch_result.error,
-            "state_reason": parsed_page.state_reason,
-            "profile_name": parsed_page.profile_name,
-            "profile_image_url": parsed_page.profile_image_url,
-            "articles_range": parsed_page.articles_range,
-            "has_show_more_button": parsed_page.has_show_more_button,
-            "has_operation_error_banner": parsed_page.has_operation_error_banner,
-            "warning_codes": parsed_page.warnings,
-            "marker_counts_nonzero": {key: value for key, value in parsed_page.marker_counts.items() if value > 0},
-            "body_length": len(fetch_result.body),
-            "body_sha256": hashlib.sha256(fetch_result.body.encode("utf-8")).hexdigest() if fetch_result.body else None,
-            "body_excerpt": _build_body_excerpt(fetch_result.body),
-            "attempt_log": attempt_log,
-        }
-        if page_logs:
-            context["page_logs"] = page_logs
-        if exception is not None:
-            context["exception_type"] = type(exception).__name__
-            context["exception_message"] = str(exception)
-        return context
+        return run_execution_summary(run=run, scholars=scholars, progress=progress)
 
     async def _try_acquire_user_lock(
         self,
@@ -2076,9 +630,6 @@ class ScholarIngestionService:
     ) -> bool:
         result = await db_session.execute(
             text("SELECT pg_try_advisory_xact_lock(:namespace, :user_key)"),
-            {
-                "namespace": RUN_LOCK_NAMESPACE,
-                "user_key": int(user_id),
-            },
+            {"namespace": RUN_LOCK_NAMESPACE, "user_key": int(user_id)},
         )
         return bool(result.scalar_one())
diff --git a/app/services/ingestion/enrichment.py b/app/services/ingestion/enrichment.py
new file mode 100644
index 0000000..e63a6aa
--- /dev/null
+++ b/app/services/ingestion/enrichment.py
@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from datetime import UTC, datetime, timedelta
+
+from sqlalchemy import or_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import (
+    CrawlRun,
+    Publication,
+    RunStatus,
+    ScholarProfile,
+    ScholarPublication,
+)
+from app.logging_utils import structured_log
+from app.services.arxiv.errors import ArxivRateLimitError
+from app.services.publication_identifiers import application as identifier_service
+from app.services.runs.events import run_events
+from app.services.scholar.parser import PublicationCandidate
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+class EnrichmentRunner:
+    """Post-run OpenAlex enrichment logic.
+
+    Receives service dependencies at construction so it can be tested
+    independently of ``ScholarIngestionService``.
+    """
+
+    async def run_is_canceled(
+        self,
+        db_session: AsyncSession,
+        *,
+        run_id: int,
+    ) -> bool:
+        check_result = await db_session.execute(select(CrawlRun.status).where(CrawlRun.id == run_id))
+        status = check_result.scalar_one_or_none()
+        if status is None:
+            raise RuntimeError(f"Missing crawl_run for run_id={run_id}.")
+        return status == RunStatus.CANCELED
+
+    async def enrich_pending_publications(
+        self,
+        db_session: AsyncSession,
+        *,
+        run_id: int,
+        openalex_api_key: str | None = None,
+    ) -> None:
+        """Enrich unenriched publications with OpenAlex data.
+
+        Stops immediately on budget exhaustion (429 with $0 remaining).
+        Sleeps 60s and continues on transient rate limits.
+        """
+        from app.services.openalex.client import (
+            OpenAlexBudgetExhaustedError,
+            OpenAlexClient,
+            OpenAlexRateLimitError,
+        )
+        from app.services.openalex.matching import find_best_match
+
+        run_result = await db_session.execute(select(CrawlRun.user_id).where(CrawlRun.id == run_id))
+        user_id = run_result.scalar_one()
+
+        now = datetime.now(UTC)
+        cooldown_threshold = now - timedelta(days=7)
+
+        stmt = (
+            select(Publication)
+            .join(ScholarPublication)
+            .join(ScholarProfile, ScholarPublication.scholar_profile_id == ScholarProfile.id)
+            .where(
+                ScholarProfile.user_id == user_id,
+                Publication.openalex_enriched.is_(False),
+                or_(
+                    Publication.openalex_last_attempt_at.is_(None),
+                    Publication.openalex_last_attempt_at < cooldown_threshold,
+                ),
+            )
+            .distinct()
+        )
+        result = await db_session.execute(stmt)
+        publications = list(result.scalars().all())
+
+        if not publications:
+            return
+
+        resolved_key = openalex_api_key or settings.openalex_api_key
+        client = OpenAlexClient(api_key=resolved_key, mailto=settings.crossref_api_mailto)
+        batch_size = 25
+        arxiv_lookup_allowed = True
+
+        for i in range(0, len(publications), batch_size):
+            if await self.run_is_canceled(db_session, run_id=run_id):
+                logger.info("ingestion.enrichment_aborted", extra={"run_id": run_id})
+                return
+            batch = publications[i : i + batch_size]
+            titles = [
+                " ".join(re.sub(r"[^\w\s]", " ", p.title_raw).split())
+                for p in batch
+                if p.title_raw and p.title_raw.strip()
+            ]
+
+            if not titles:
+                continue
+
+            try:
+                openalex_works = await client.get_works_by_filter(
+                    {"title.search": "|".join(titles)}, limit=batch_size * 3
+                )
+            except OpenAlexBudgetExhaustedError:
+                structured_log(
+                    logger,
+                    "warning",
+                    "ingestion.openalex_budget_exhausted",
+                    run_id=run_id,
+                )
+                break
+            except OpenAlexRateLimitError:
+                structured_log(
+                    logger,
+                    "warning",
+                    "ingestion.openalex_rate_limited",
+                    run_id=run_id,
+                )
+                await asyncio.sleep(60)
+                continue
+            except Exception as e:
+                structured_log(
+                    logger,
+                    "warning",
+                    "ingestion.openalex_enrichment_failed",
+                    error=str(e),
+                    run_id=run_id,
+                )
+                continue
+
+            for p in batch:
+                if await self.run_is_canceled(db_session, run_id=run_id):
+                    logger.info("ingestion.enrichment_aborted", extra={"run_id": run_id})
+                    return
+
+                p.openalex_last_attempt_at = now
+                arxiv_lookup_allowed = await self._discover_identifiers_for_enrichment(
+                    db_session,
+                    publication=p,
+                    run_id=run_id,
+                    allow_arxiv_lookup=arxiv_lookup_allowed,
+                )
+
+                match = find_best_match(
+                    target_title=p.title_raw,
+                    target_year=p.year,
+                    target_authors=p.author_text or "",
+                    candidates=openalex_works,
+                )
+                if match:
+                    p.year = match.publication_year or p.year
+                    p.citation_count = match.cited_by_count or p.citation_count
+                    p.pdf_url = match.oa_url or p.pdf_url
+                    p.openalex_enriched = True
+
+        await db_session.flush()
+
+        from app.services.publications.dedup import sweep_identifier_duplicates
+
+        merge_count = await sweep_identifier_duplicates(db_session)
+        if merge_count:
+            structured_log(
+                logger,
+                "info",
+                "ingestion.identifier_dedup_sweep",
+                merged_count=merge_count,
+                run_id=run_id,
+            )
+
+    async def _discover_identifiers_for_enrichment(
+        self,
+        db_session: AsyncSession,
+        *,
+        publication: Publication,
+        run_id: int,
+        allow_arxiv_lookup: bool,
+    ) -> bool:
+        if not allow_arxiv_lookup:
+            await identifier_service.sync_identifiers_for_publication_fields(
+                db_session,
+                publication=publication,
+            )
+            await self._publish_identifier_update_event(
+                db_session,
+                run_id=run_id,
+                publication_id=int(publication.id),
+            )
+            return False
+        try:
+            await identifier_service.discover_and_sync_identifiers_for_publication(
+                db_session,
+                publication=publication,
+                scholar_label=publication.author_text or "",
+            )
+            await self._publish_identifier_update_event(
+                db_session,
+                run_id=run_id,
+                publication_id=int(publication.id),
+            )
+            return True
+        except ArxivRateLimitError:
+            structured_log(
+                logger,
+                "warning",
+                "ingestion.arxiv_rate_limited",
+                run_id=run_id,
+                publication_id=int(publication.id),
+                detail="arXiv temporarily disabled for remaining enrichment pass",
+            )
+            await identifier_service.sync_identifiers_for_publication_fields(
+                db_session,
+                publication=publication,
+            )
+            await self._publish_identifier_update_event(
+                db_session,
+                run_id=run_id,
+                publication_id=int(publication.id),
+            )
+            return False
+
+    async def _publish_identifier_update_event(
+        self,
+        db_session: AsyncSession,
+        *,
+        run_id: int,
+        publication_id: int,
+    ) -> None:
+        display = await identifier_service.display_identifier_for_publication_id(
+            db_session,
+            publication_id=publication_id,
+        )
+        if display is None:
+            return
+        await run_events.publish(
+            run_id=run_id,
+            event_type="identifier_updated",
+            data={
+                "publication_id": int(publication_id),
+                "display_identifier": {
+                    "kind": display.kind,
+                    "value": display.value,
+                    "label": display.label,
+                    "url": display.url,
+                    "confidence_score": float(display.confidence_score),
+                },
+            },
+        )
+
+    async def enrich_publications_with_openalex(
+        self,
+        scholar: ScholarProfile,
+        publications: list[PublicationCandidate],
+    ) -> list[PublicationCandidate]:
+        if not publications:
+            return publications
+
+        from app.services.openalex.client import OpenAlexClient
+        from app.services.openalex.matching import find_best_match
+
+        client = OpenAlexClient(api_key=settings.openalex_api_key, mailto=settings.crossref_api_mailto)
+
+        batch_size = 25
+        enriched: list[PublicationCandidate] = []
+
+        for i in range(0, len(publications), batch_size):
+            batch = publications[i : i + batch_size]
+
+            titles = []
+            for p in batch:
+                if not p.title:
+                    continue
+                safe_title = re.sub(r"[^\w\s]", " ", p.title)
+                safe_title = " ".join(safe_title.split())
+                if safe_title:
+                    titles.append(safe_title)
+
+            if not titles:
+                enriched.extend(batch)
+                continue
+
+            query = "|".join(t for t in titles)
+            try:
+                openalex_works = await client.get_works_by_filter({"title.search": query}, limit=batch_size * 3)
+            except Exception as e:
+                logger.warning(
+                    "ingestion.openalex_enrichment_failed",
+                    extra={"error": str(e), "batch_size": len(batch), "scholar_id": scholar.id},
+                )
+                openalex_works = []
+
+            for p in batch:
+                match = find_best_match(
+                    target_title=p.title,
+                    target_year=p.year,
+                    target_authors=p.authors_text or (scholar.display_name or scholar.scholar_id),
+                    candidates=openalex_works,
+                )
+                if match:
+                    new_p = PublicationCandidate(
+                        title=p.title,
+                        title_url=p.title_url,
+                        cluster_id=p.cluster_id,
+                        year=match.publication_year or p.year,
+                        citation_count=match.cited_by_count,
+                        authors_text=p.authors_text,
+                        venue_text=p.venue_text,
+                        pdf_url=match.oa_url or p.pdf_url,
+                    )
+                    enriched.append(new_p)
+                else:
+                    enriched.append(p)
+        return enriched
diff --git a/app/services/ingestion/run_completion.py b/app/services/ingestion/run_completion.py
new file mode 100644
index 0000000..450550d
--- /dev/null
+++ b/app/services/ingestion/run_completion.py
@@ -0,0 +1,417 @@
+from __future__ import annotations
+
+import hashlib
+import logging
+from datetime import UTC, datetime
+from typing import Any
+
+from app.db.models import (
+    CrawlRun,
+    RunStatus,
+    ScholarProfile,
+)
+from app.logging_utils import structured_log
+from app.services.ingestion import safety as run_safety_service
+from app.services.ingestion.constants import (
+    FAILED_STATES,
+    FAILURE_BUCKET_BLOCKED,
+    FAILURE_BUCKET_INGESTION,
+    FAILURE_BUCKET_LAYOUT,
+    FAILURE_BUCKET_NETWORK,
+    FAILURE_BUCKET_OTHER,
+)
+from app.services.ingestion.fingerprints import _build_body_excerpt
+from app.services.ingestion.types import (
+    RunAlertSummary,
+    RunExecutionSummary,
+    RunFailureSummary,
+    RunProgress,
+    ScholarProcessingOutcome,
+)
+from app.services.scholar.parser import ParsedProfilePage, ParseState
+from app.services.scholar.source import FetchResult
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+def _int_or_default(value: Any, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def classify_failure_bucket(*, state: str, state_reason: str) -> str:
+    reason = state_reason.strip().lower()
+    normalized_state = state.strip().lower()
+
+    if normalized_state == ParseState.BLOCKED_OR_CAPTCHA.value or reason.startswith("blocked_"):
+        return FAILURE_BUCKET_BLOCKED
+    if normalized_state == ParseState.NETWORK_ERROR.value or reason.startswith("network_"):
+        return FAILURE_BUCKET_NETWORK
+    if normalized_state == ParseState.LAYOUT_CHANGED.value:
+        return FAILURE_BUCKET_LAYOUT
+    if normalized_state == "ingestion_error":
+        return FAILURE_BUCKET_INGESTION
+    return FAILURE_BUCKET_OTHER
+
+
+def summarize_failures(
+    *,
+    scholar_results: list[dict[str, Any]],
+) -> RunFailureSummary:
+    failed_state_counts: dict[str, int] = {}
+    failed_reason_counts: dict[str, int] = {}
+    scrape_failure_counts: dict[str, int] = {}
+    retries_scheduled_count = 0
+    scholars_with_retries_count = 0
+    retry_exhausted_count = 0
+    for entry in scholar_results:
+        retries_for_entry = max(0, _int_or_default(entry.get("attempt_count"), 0) - 1)
+        if retries_for_entry > 0:
+            retries_scheduled_count += retries_for_entry
+            scholars_with_retries_count += 1
+        if str(entry.get("outcome", "")) != "failed":
+            continue
+        state = str(entry.get("state", "")).strip()
+        if state not in FAILED_STATES:
+            continue
+        failed_state_counts[state] = failed_state_counts.get(state, 0) + 1
+        reason = str(entry.get("state_reason", "")).strip()
+        if reason:
+            failed_reason_counts[reason] = failed_reason_counts.get(reason, 0) + 1
+        bucket = classify_failure_bucket(state=state, state_reason=reason)
+        scrape_failure_counts[bucket] = scrape_failure_counts.get(bucket, 0) + 1
+        if state == ParseState.NETWORK_ERROR.value and retries_for_entry > 0:
+            retry_exhausted_count += 1
+    return RunFailureSummary(
+        failed_state_counts=failed_state_counts,
+        failed_reason_counts=failed_reason_counts,
+        scrape_failure_counts=scrape_failure_counts,
+        retries_scheduled_count=retries_scheduled_count,
+        scholars_with_retries_count=scholars_with_retries_count,
+        retry_exhausted_count=retry_exhausted_count,
+    )
+
+
+def build_alert_summary(
+    *,
+    failure_summary: RunFailureSummary,
+    alert_blocked_failure_threshold: int,
+    alert_network_failure_threshold: int,
+    alert_retry_scheduled_threshold: int,
+) -> RunAlertSummary:
+    blocked_failure_count = int(failure_summary.scrape_failure_counts.get(FAILURE_BUCKET_BLOCKED, 0))
+    network_failure_count = int(failure_summary.scrape_failure_counts.get(FAILURE_BUCKET_NETWORK, 0))
+    blocked_threshold = max(1, int(alert_blocked_failure_threshold))
+    network_threshold = max(1, int(alert_network_failure_threshold))
+    retry_threshold = max(1, int(alert_retry_scheduled_threshold))
+    alert_flags = {
+        "blocked_failure_threshold_exceeded": blocked_failure_count >= blocked_threshold,
+        "network_failure_threshold_exceeded": network_failure_count >= network_threshold,
+        "retry_scheduled_threshold_exceeded": failure_summary.retries_scheduled_count >= retry_threshold,
+    }
+    return RunAlertSummary(
+        blocked_failure_count=blocked_failure_count,
+        network_failure_count=network_failure_count,
+        blocked_failure_threshold=blocked_threshold,
+        network_failure_threshold=network_threshold,
+        retry_scheduled_threshold=retry_threshold,
+        alert_flags=alert_flags,
+    )
+
+
+def apply_safety_outcome(
+    *,
+    user_settings: Any,
+    run: CrawlRun,
+    user_id: int,
+    alert_summary: RunAlertSummary,
+) -> None:
+    pre_apply_state = run_safety_service.get_safety_event_context(
+        user_settings,
+        now_utc=datetime.now(UTC),
+    )
+    safety_state, cooldown_trigger_reason = run_safety_service.apply_run_safety_outcome(
+        user_settings,
+        run_id=int(run.id),
+        blocked_failure_count=alert_summary.blocked_failure_count,
+        network_failure_count=alert_summary.network_failure_count,
+        blocked_failure_threshold=alert_summary.blocked_failure_threshold,
+        network_failure_threshold=alert_summary.network_failure_threshold,
+        blocked_cooldown_seconds=settings.ingestion_safety_cooldown_blocked_seconds,
+        network_cooldown_seconds=settings.ingestion_safety_cooldown_network_seconds,
+        now_utc=datetime.now(UTC),
+    )
+    if cooldown_trigger_reason is not None:
+        structured_log(
+            logger,
+            "warning",
+            "ingestion.safety_cooldown_entered",
+            user_id=user_id,
+            crawl_run_id=int(run.id),
+            reason=cooldown_trigger_reason,
+            blocked_failure_count=alert_summary.blocked_failure_count,
+            network_failure_count=alert_summary.network_failure_count,
+            blocked_failure_threshold=alert_summary.blocked_failure_threshold,
+            network_failure_threshold=alert_summary.network_failure_threshold,
+            cooldown_until=safety_state.get("cooldown_until"),
+            cooldown_remaining_seconds=safety_state.get("cooldown_remaining_seconds"),
+            safety_counters=safety_state.get("counters", {}),
+        )
+    elif pre_apply_state.get("cooldown_active") and not safety_state.get("cooldown_active"):
+        structured_log(
+            logger,
+            "info",
+            "ingestion.cooldown_cleared",
+            user_id=user_id,
+            crawl_run_id=int(run.id),
+            reason=pre_apply_state.get("cooldown_reason"),
+            cooldown_until=pre_apply_state.get("cooldown_until"),
+        )
+
+
+def finalize_run_record(
+    *,
+    run: CrawlRun,
+    scholars: list[ScholarProfile],
+    progress: RunProgress,
+    failure_summary: RunFailureSummary,
+    alert_summary: RunAlertSummary,
+    idempotency_key: str | None,
+    run_status: RunStatus,
+) -> None:
+    run.end_dt = datetime.now(UTC)
+    if run.status != RunStatus.CANCELED:
+        run.status = run_status
+    run.error_log = {
+        "scholar_results": progress.scholar_results,
+        "summary": {
+            "succeeded_count": progress.succeeded_count,
+            "failed_count": progress.failed_count,
+            "partial_count": progress.partial_count,
+            "failed_state_counts": failure_summary.failed_state_counts,
+            "failed_reason_counts": failure_summary.failed_reason_counts,
+            "scrape_failure_counts": failure_summary.scrape_failure_counts,
+            "retry_counts": {
+                "retries_scheduled_count": failure_summary.retries_scheduled_count,
+                "scholars_with_retries_count": failure_summary.scholars_with_retries_count,
+                "retry_exhausted_count": failure_summary.retry_exhausted_count,
+            },
+            "alert_thresholds": {
+                "blocked_failure_threshold": alert_summary.blocked_failure_threshold,
+                "network_failure_threshold": alert_summary.network_failure_threshold,
+                "retry_scheduled_threshold": alert_summary.retry_scheduled_threshold,
+            },
+            "alert_flags": alert_summary.alert_flags,
+        },
+        "meta": {"idempotency_key": idempotency_key} if idempotency_key else {},
+    }
+
+
+def resolve_run_status(
+    *,
+    scholar_count: int,
+    succeeded_count: int,
+    failed_count: int,
+    partial_count: int,
+) -> RunStatus:
+    if scholar_count == 0:
+        return RunStatus.SUCCESS
+    if failed_count == scholar_count:
+        return RunStatus.FAILED
+    if failed_count > 0 or partial_count > 0:
+        return RunStatus.PARTIAL_FAILURE
+    if succeeded_count > 0:
+        return RunStatus.SUCCESS
+    return RunStatus.FAILED
+
+
+def build_failure_debug_context(
+    *,
+    fetch_result: FetchResult,
+    parsed_page: ParsedProfilePage,
+    attempt_log: list[dict[str, Any]],
+    page_logs: list[dict[str, Any]] | None = None,
+    exception: Exception | None = None,
+) -> dict[str, Any]:
+    context: dict[str, Any] = {
+        "requested_url": fetch_result.requested_url,
+        "final_url": fetch_result.final_url,
+        "status_code": fetch_result.status_code,
+        "fetch_error": fetch_result.error,
+        "state_reason": parsed_page.state_reason,
+        "profile_name": parsed_page.profile_name,
+        "profile_image_url": parsed_page.profile_image_url,
+        "articles_range": parsed_page.articles_range,
+        "has_show_more_button": parsed_page.has_show_more_button,
+        "has_operation_error_banner": parsed_page.has_operation_error_banner,
+        "warning_codes": parsed_page.warnings,
+        "marker_counts_nonzero": {key: value for key, value in parsed_page.marker_counts.items() if value > 0},
+        "body_length": len(fetch_result.body),
+        "body_sha256": hashlib.sha256(fetch_result.body.encode("utf-8")).hexdigest() if fetch_result.body else None,
+        "body_excerpt": _build_body_excerpt(fetch_result.body),
+        "attempt_log": attempt_log,
+    }
+    if page_logs:
+        context["page_logs"] = page_logs
+    if exception is not None:
+        context["exception_type"] = type(exception).__name__
+        context["exception_message"] = str(exception)
+    return context
+
+
+def complete_run_for_user(
+    *,
+    user_settings: Any,
+    run: CrawlRun,
+    scholars: list[ScholarProfile],
+    user_id: int,
+    progress: RunProgress,
+    idempotency_key: str | None,
+    alert_blocked_failure_threshold: int,
+    alert_network_failure_threshold: int,
+    alert_retry_scheduled_threshold: int,
+) -> tuple[RunFailureSummary, RunAlertSummary]:
+    failure_summary = summarize_failures(scholar_results=progress.scholar_results)
+    alert_summary = build_alert_summary(
+        failure_summary=failure_summary,
+        alert_blocked_failure_threshold=alert_blocked_failure_threshold,
+        alert_network_failure_threshold=alert_network_failure_threshold,
+        alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+    )
+    if alert_summary.alert_flags["blocked_failure_threshold_exceeded"]:
+        structured_log(
+            logger,
+            "warning",
+            "ingestion.alert_blocked_failure_threshold_exceeded",
+            user_id=user_id,
+            crawl_run_id=int(run.id),
+            blocked_failure_count=alert_summary.blocked_failure_count,
+            threshold=alert_summary.blocked_failure_threshold,
+        )
+    if alert_summary.alert_flags["network_failure_threshold_exceeded"]:
+        structured_log(
+            logger,
+            "warning",
+            "ingestion.alert_network_failure_threshold_exceeded",
+            user_id=user_id,
+            crawl_run_id=int(run.id),
+            network_failure_count=alert_summary.network_failure_count,
+            threshold=alert_summary.network_failure_threshold,
+        )
+    if alert_summary.alert_flags["retry_scheduled_threshold_exceeded"]:
+        structured_log(
+            logger,
+            "warning",
+            "ingestion.alert_retry_scheduled_threshold_exceeded",
+            user_id=user_id,
+            crawl_run_id=int(run.id),
+            retries_scheduled_count=failure_summary.retries_scheduled_count,
+            threshold=alert_summary.retry_scheduled_threshold,
+        )
+    apply_safety_outcome(user_settings=user_settings, run=run, user_id=user_id, alert_summary=alert_summary)
+    run_status = resolve_run_status(
+        scholar_count=len(scholars),
+        succeeded_count=progress.succeeded_count,
+        failed_count=progress.failed_count,
+        partial_count=progress.partial_count,
+    )
+    finalize_run_record(
+        run=run,
+        scholars=scholars,
+        progress=progress,
+        failure_summary=failure_summary,
+        alert_summary=alert_summary,
+        idempotency_key=idempotency_key,
+        run_status=run_status,
+    )
+    return failure_summary, alert_summary
+
+
+def result_counters(result_entry: dict[str, Any]) -> tuple[int, int, int]:
+    outcome = str(result_entry.get("outcome", "")).strip().lower()
+    if outcome == "success":
+        return 1, 0, 0
+    if outcome == "partial":
+        return 1, 0, 1
+    if outcome == "failed":
+        return 0, 1, 0
+    raise RuntimeError(f"Unexpected scholar outcome label: {outcome!r}")
+
+
+def find_scholar_result_index(
+    *,
+    scholar_results: list[dict[str, Any]],
+    scholar_profile_id: int,
+) -> int | None:
+    for index, result_entry in enumerate(scholar_results):
+        current_scholar_id = _int_or_default(result_entry.get("scholar_profile_id"), 0)
+        if current_scholar_id == scholar_profile_id:
+            return index
+    return None
+
+
+def adjust_progress_counts(
+    *,
+    progress: RunProgress,
+    succeeded_delta: int,
+    failed_delta: int,
+    partial_delta: int,
+) -> None:
+    progress.succeeded_count += succeeded_delta
+    progress.failed_count += failed_delta
+    progress.partial_count += partial_delta
+    if progress.succeeded_count < 0 or progress.failed_count < 0 or progress.partial_count < 0:
+        raise RuntimeError("RunProgress counters entered invalid negative state.")
+
+
+def apply_outcome_to_progress(
+    *,
+    progress: RunProgress,
+    outcome: ScholarProcessingOutcome,
+) -> None:
+    scholar_profile_id = _int_or_default(outcome.result_entry.get("scholar_profile_id"), 0)
+    if scholar_profile_id <= 0:
+        raise RuntimeError("Scholar outcome missing valid scholar_profile_id.")
+    prior_index = find_scholar_result_index(
+        scholar_results=progress.scholar_results,
+        scholar_profile_id=scholar_profile_id,
+    )
+    next_succeeded, next_failed, next_partial = result_counters(outcome.result_entry)
+    if prior_index is None:
+        progress.scholar_results.append(outcome.result_entry)
+        adjust_progress_counts(
+            progress=progress,
+            succeeded_delta=next_succeeded,
+            failed_delta=next_failed,
+            partial_delta=next_partial,
+        )
+        return
+    previous_entry = progress.scholar_results[prior_index]
+    prev_succeeded, prev_failed, prev_partial = result_counters(previous_entry)
+    progress.scholar_results[prior_index] = outcome.result_entry
+    adjust_progress_counts(
+        progress=progress,
+        succeeded_delta=next_succeeded - prev_succeeded,
+        failed_delta=next_failed - prev_failed,
+        partial_delta=next_partial - prev_partial,
+    )
+
+
+def run_execution_summary(
+    *,
+    run: CrawlRun,
+    scholars: list[ScholarProfile],
+    progress: RunProgress,
+) -> RunExecutionSummary:
+    return RunExecutionSummary(
+        crawl_run_id=run.id,
+        status=run.status,
+        scholar_count=len(scholars),
+        succeeded_count=progress.succeeded_count,
+        failed_count=progress.failed_count,
+        partial_count=progress.partial_count,
+        new_publication_count=run.new_pub_count,
+    )
diff --git a/app/services/ingestion/scholar_processing.py b/app/services/ingestion/scholar_processing.py
new file mode 100644
index 0000000..393f85c
--- /dev/null
+++ b/app/services/ingestion/scholar_processing.py
@@ -0,0 +1,614 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from datetime import UTC, datetime
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import (
+    CrawlRun,
+    RunStatus,
+    ScholarProfile,
+)
+from app.logging_utils import structured_log
+from app.services.ingestion import queue as queue_service
+from app.services.ingestion.constants import (
+    RESUMABLE_PARTIAL_REASON_PREFIXES,
+    RESUMABLE_PARTIAL_REASONS,
+)
+from app.services.ingestion.pagination import PaginationEngine
+from app.services.ingestion.publication_upsert import upsert_profile_publications
+from app.services.ingestion.run_completion import apply_outcome_to_progress, build_failure_debug_context
+from app.services.ingestion.types import (
+    PagedParseResult,
+    RunProgress,
+    ScholarProcessingOutcome,
+)
+from app.services.scholar.parser import ParseState
+
+logger = logging.getLogger(__name__)
+
+
+def assert_valid_paged_parse_result(
+    *,
+    scholar_id: str,
+    paged_parse_result: PagedParseResult,
+) -> None:
+    parsed_page = paged_parse_result.parsed_page
+    if parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS} and any(
+        code.startswith("layout_") for code in parsed_page.warnings
+    ):
+        raise RuntimeError(f"Layout warning marked as terminal for scholar_id={scholar_id}.")
+    for publication in paged_parse_result.publications:
+        if not publication.title.strip():
+            raise RuntimeError(f"Malformed publication title for scholar_id={scholar_id}.")
+        if publication.citation_count is not None and int(publication.citation_count) < 0:
+            raise RuntimeError(f"Negative citation count for scholar_id={scholar_id}.")
+
+
+def apply_first_page_profile_metadata(
+    *,
+    scholar: ScholarProfile,
+    paged_parse_result: PagedParseResult,
+    run_dt: datetime,
+) -> None:
+    first_page = paged_parse_result.first_page_parsed_page
+    if first_page.profile_name and not (scholar.display_name or "").strip():
+        scholar.display_name = first_page.profile_name
+    if first_page.profile_image_url:
+        scholar.profile_image_url = first_page.profile_image_url
+    scholar.last_initial_page_checked_at = run_dt
+
+
+def build_result_entry(
+    *,
+    scholar: ScholarProfile,
+    start_cstart: int,
+    paged_parse_result: PagedParseResult,
+) -> dict[str, Any]:
+    parsed_page = paged_parse_result.parsed_page
+    return {
+        "scholar_profile_id": scholar.id,
+        "scholar_id": scholar.scholar_id,
+        "state": parsed_page.state.value,
+        "state_reason": parsed_page.state_reason,
+        "outcome": "failed",
+        "attempt_count": len(paged_parse_result.attempt_log),
+        "publication_count": len(paged_parse_result.publications),
+        "start_cstart": start_cstart,
+        "articles_range": parsed_page.articles_range,
+        "warnings": parsed_page.warnings,
+        "has_show_more_button": parsed_page.has_show_more_button,
+        "pages_fetched": paged_parse_result.pages_fetched,
+        "pages_attempted": paged_parse_result.pages_attempted,
+        "has_more_remaining": paged_parse_result.has_more_remaining,
+        "pagination_truncated_reason": paged_parse_result.pagination_truncated_reason,
+        "continuation_cstart": paged_parse_result.continuation_cstart,
+        "skipped_no_change": paged_parse_result.skipped_no_change,
+        "initial_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
+    }
+
+
+def skipped_no_change_outcome(
+    *,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+) -> ScholarProcessingOutcome:
+    first_page = paged_parse_result.first_page_parsed_page
+    scholar.last_run_status = RunStatus.SUCCESS
+    scholar.last_run_dt = run_dt
+    result_entry["state"] = first_page.state.value
+    result_entry["state_reason"] = "no_change_initial_page_signature"
+    result_entry["outcome"] = "success"
+    result_entry["publication_count"] = 0
+    result_entry["warnings"] = first_page.warnings
+    result_entry["debug"] = {
+        "state_reason": "no_change_initial_page_signature",
+        "first_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
+        "attempt_log": paged_parse_result.attempt_log,
+        "page_logs": paged_parse_result.page_logs,
+    }
+    return ScholarProcessingOutcome(
+        result_entry=result_entry,
+        succeeded_count_delta=1,
+        failed_count_delta=0,
+        partial_count_delta=0,
+        discovered_publication_count=0,
+    )
+
+
+async def upsert_publications_outcome(
+    db_session: AsyncSession,
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+) -> ScholarProcessingOutcome:
+    parsed_page = paged_parse_result.parsed_page
+    publications = paged_parse_result.publications
+    had_page_failure = parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}
+    has_partial_set = len(publications) > 0 and had_page_failure
+    if (not had_page_failure) or has_partial_set:
+        return await _upsert_success_or_exception(
+            db_session,
+            run=run,
+            scholar=scholar,
+            run_dt=run_dt,
+            paged_parse_result=paged_parse_result,
+            result_entry=result_entry,
+            has_partial_publication_set=has_partial_set,
+        )
+    return _parse_failure_outcome(
+        scholar=scholar,
+        run_dt=run_dt,
+        paged_parse_result=paged_parse_result,
+        result_entry=result_entry,
+    )
+
+
+async def _upsert_success_or_exception(
+    db_session: AsyncSession,
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+    has_partial_publication_set: bool,
+) -> ScholarProcessingOutcome:
+    try:
+        return _upsert_success(
+            run=run,
+            scholar=scholar,
+            run_dt=run_dt,
+            paged_parse_result=paged_parse_result,
+            result_entry=result_entry,
+            has_partial_publication_set=has_partial_publication_set,
+        )
+    except Exception as exc:
+        return _upsert_exception_outcome(
+            run=run,
+            scholar=scholar,
+            run_dt=run_dt,
+            paged_parse_result=paged_parse_result,
+            result_entry=result_entry,
+            exc=exc,
+        )
+
+
+def _upsert_success(
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+    has_partial_publication_set: bool,
+) -> ScholarProcessingOutcome:
+    discovered_count = paged_parse_result.discovered_publication_count
+    is_partial = (
+        paged_parse_result.has_more_remaining
+        or paged_parse_result.pagination_truncated_reason is not None
+        or has_partial_publication_set
+    )
+    scholar.last_run_status = RunStatus.PARTIAL_FAILURE if is_partial else RunStatus.SUCCESS
+    scholar.last_run_dt = run_dt
+    if not is_partial and paged_parse_result.first_page_fingerprint_sha256:
+        scholar.last_initial_page_fingerprint_sha256 = paged_parse_result.first_page_fingerprint_sha256
+    result_entry["outcome"] = "partial" if is_partial else "success"
+    if is_partial:
+        result_entry["debug"] = build_failure_debug_context(
+            fetch_result=paged_parse_result.fetch_result,
+            parsed_page=paged_parse_result.parsed_page,
+            attempt_log=paged_parse_result.attempt_log,
+            page_logs=paged_parse_result.page_logs,
+        )
+    return ScholarProcessingOutcome(
+        result_entry=result_entry,
+        succeeded_count_delta=1,
+        failed_count_delta=0,
+        partial_count_delta=1 if is_partial else 0,
+        discovered_publication_count=discovered_count,
+    )
+
+
+def _upsert_exception_outcome(
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+    exc: Exception,
+) -> ScholarProcessingOutcome:
+    scholar.last_run_status = RunStatus.FAILED
+    scholar.last_run_dt = run_dt
+    result_entry["state"] = "ingestion_error"
+    result_entry["state_reason"] = "publication_upsert_exception"
+    result_entry["outcome"] = "failed"
+    result_entry["error"] = str(exc)
+    result_entry["debug"] = build_failure_debug_context(
+        fetch_result=paged_parse_result.fetch_result,
+        parsed_page=paged_parse_result.parsed_page,
+        attempt_log=paged_parse_result.attempt_log,
+        page_logs=paged_parse_result.page_logs,
+        exception=exc,
+    )
+    logger.exception(
+        "ingestion.scholar_failed",
+        extra={
+            "crawl_run_id": run.id,
+            "scholar_profile_id": scholar.id,
+            "scholar_id": scholar.scholar_id,
+        },
+    )
+    return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
+
+
+def _parse_failure_outcome(
+    *,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+) -> ScholarProcessingOutcome:
+    scholar.last_run_status = RunStatus.FAILED
+    scholar.last_run_dt = run_dt
+    result_entry["debug"] = build_failure_debug_context(
+        fetch_result=paged_parse_result.fetch_result,
+        parsed_page=paged_parse_result.parsed_page,
+        attempt_log=paged_parse_result.attempt_log,
+        page_logs=paged_parse_result.page_logs,
+    )
+    structured_log(
+        logger,
+        "warning",
+        "ingestion.scholar_parse_failed",
+        scholar_profile_id=scholar.id,
+        scholar_id=scholar.scholar_id,
+        state=paged_parse_result.parsed_page.state.value,
+        state_reason=paged_parse_result.parsed_page.state_reason,
+        status_code=paged_parse_result.fetch_result.status_code,
+    )
+    return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
+
+
+async def sync_continuation_queue(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar: ScholarProfile,
+    run: CrawlRun,
+    start_cstart: int,
+    result_entry: dict[str, Any],
+    paged_parse_result: PagedParseResult,
+    auto_queue_continuations: bool,
+    queue_delay_seconds: int,
+) -> None:
+    queue_reason, queue_cstart = resolve_continuation_queue_target(
+        outcome=str(result_entry.get("outcome", "")),
+        state=str(result_entry.get("state", "")),
+        pagination_truncated_reason=paged_parse_result.pagination_truncated_reason,
+        continuation_cstart=paged_parse_result.continuation_cstart,
+        fallback_cstart=start_cstart,
+    )
+    if auto_queue_continuations and queue_reason is not None:
+        await queue_service.upsert_job(
+            db_session,
+            user_id=user_id,
+            scholar_profile_id=scholar.id,
+            resume_cstart=queue_cstart,
+            reason=queue_reason,
+            run_id=run.id,
+            delay_seconds=queue_delay_seconds,
+        )
+        result_entry["continuation_enqueued"] = True
+        result_entry["continuation_reason"] = queue_reason
+        result_entry["continuation_cstart"] = queue_cstart
+        return
+    if await queue_service.clear_job_for_scholar(db_session, user_id=user_id, scholar_profile_id=scholar.id):
+        result_entry["continuation_cleared"] = True
+
+
+def resolve_continuation_queue_target(
+    *,
+    outcome: str,
+    state: str,
+    pagination_truncated_reason: str | None,
+    continuation_cstart: int | None,
+    fallback_cstart: int,
+) -> tuple[str | None, int]:
+    if outcome == "partial":
+        reason = (pagination_truncated_reason or "").strip()
+        if reason in RESUMABLE_PARTIAL_REASONS or reason.startswith(RESUMABLE_PARTIAL_REASON_PREFIXES):
+            return reason, queue_service.normalize_cstart(
+                continuation_cstart if continuation_cstart is not None else fallback_cstart
+            )
+        return None, queue_service.normalize_cstart(fallback_cstart)
+
+    if outcome == "failed" and state == ParseState.NETWORK_ERROR.value:
+        return "network_error_retry", queue_service.normalize_cstart(
+            continuation_cstart if continuation_cstart is not None else fallback_cstart
+        )
+
+    return None, queue_service.normalize_cstart(fallback_cstart)
+
+
+async def process_scholar(
+    db_session: AsyncSession,
+    *,
+    pagination: PaginationEngine,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    user_id: int,
+    request_delay_seconds: int,
+    network_error_retries: int,
+    retry_backoff_seconds: float,
+    rate_limit_retries: int,
+    rate_limit_backoff_seconds: float,
+    max_pages_per_scholar: int,
+    page_size: int,
+    start_cstart: int,
+    auto_queue_continuations: bool,
+    queue_delay_seconds: int,
+) -> ScholarProcessingOutcome:
+    try:
+        run_dt, paged_parse_result, result_entry = await _fetch_and_prepare_scholar_result(
+            db_session,
+            pagination=pagination,
+            run=run,
+            scholar=scholar,
+            user_id=user_id,
+            start_cstart=start_cstart,
+            request_delay_seconds=request_delay_seconds,
+            network_error_retries=network_error_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            rate_limit_retries=rate_limit_retries,
+            rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+            max_pages_per_scholar=max_pages_per_scholar,
+            page_size=page_size,
+        )
+        outcome = await _resolve_scholar_outcome(
+            db_session,
+            run=run,
+            scholar=scholar,
+            run_dt=run_dt,
+            paged_parse_result=paged_parse_result,
+            result_entry=result_entry,
+        )
+        await sync_continuation_queue(
+            db_session,
+            user_id=user_id,
+            scholar=scholar,
+            run=run,
+            start_cstart=start_cstart,
+            result_entry=outcome.result_entry,
+            paged_parse_result=paged_parse_result,
+            auto_queue_continuations=auto_queue_continuations,
+            queue_delay_seconds=queue_delay_seconds,
+        )
+        return outcome
+    except Exception as exc:
+        return unexpected_scholar_exception_outcome(
+            run=run,
+            scholar=scholar,
+            start_cstart=start_cstart,
+            exc=exc,
+        )
+
+
+async def _fetch_and_prepare_scholar_result(
+    db_session: AsyncSession,
+    *,
+    pagination: PaginationEngine,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    user_id: int,
+    start_cstart: int,
+    request_delay_seconds: int,
+    network_error_retries: int,
+    retry_backoff_seconds: float,
+    rate_limit_retries: int,
+    rate_limit_backoff_seconds: float,
+    max_pages_per_scholar: int,
+    page_size: int,
+) -> tuple[datetime, PagedParseResult, dict[str, Any]]:
+    run_dt = datetime.now(UTC)
+    paged_parse_result = await pagination.fetch_and_parse_all_pages(
+        scholar=scholar,
+        run=run,
+        db_session=db_session,
+        start_cstart=start_cstart,
+        request_delay_seconds=request_delay_seconds,
+        network_error_retries=network_error_retries,
+        retry_backoff_seconds=retry_backoff_seconds,
+        rate_limit_retries=rate_limit_retries,
+        rate_limit_backoff_seconds=rate_limit_backoff_seconds,
+        max_pages=max_pages_per_scholar,
+        page_size=page_size,
+        previous_initial_page_fingerprint_sha256=scholar.last_initial_page_fingerprint_sha256,
+        upsert_publications_fn=upsert_profile_publications,
+    )
+    assert_valid_paged_parse_result(scholar_id=scholar.scholar_id, paged_parse_result=paged_parse_result)
+    apply_first_page_profile_metadata(scholar=scholar, paged_parse_result=paged_parse_result, run_dt=run_dt)
+    parsed_page = paged_parse_result.parsed_page
+    structured_log(
+        logger,
+        "info",
+        "ingestion.scholar_parsed",
+        user_id=user_id,
+        crawl_run_id=run.id,
+        scholar_profile_id=scholar.id,
+        scholar_id=scholar.scholar_id,
+        state=parsed_page.state.value,
+        publication_count=len(paged_parse_result.publications),
+        has_show_more_button=parsed_page.has_show_more_button,
+        pages_fetched=paged_parse_result.pages_fetched,
+        pages_attempted=paged_parse_result.pages_attempted,
+        has_more_remaining=paged_parse_result.has_more_remaining,
+        pagination_truncated_reason=paged_parse_result.pagination_truncated_reason,
+        warning_count=len(parsed_page.warnings),
+        skipped_no_change=paged_parse_result.skipped_no_change,
+    )
+    result_entry = build_result_entry(
+        scholar=scholar,
+        start_cstart=start_cstart,
+        paged_parse_result=paged_parse_result,
+    )
+    return run_dt, paged_parse_result, result_entry
+
+
+async def _resolve_scholar_outcome(
+    db_session: AsyncSession,
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+) -> ScholarProcessingOutcome:
+    if paged_parse_result.skipped_no_change:
+        return skipped_no_change_outcome(
+            scholar=scholar,
+            run_dt=run_dt,
+            paged_parse_result=paged_parse_result,
+            result_entry=result_entry,
+        )
+    return await upsert_publications_outcome(
+        db_session,
+        run=run,
+        scholar=scholar,
+        run_dt=run_dt,
+        paged_parse_result=paged_parse_result,
+        result_entry=result_entry,
+    )
+
+
+def unexpected_scholar_exception_outcome(
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    start_cstart: int,
+    exc: Exception,
+) -> ScholarProcessingOutcome:
+    scholar.last_run_status = RunStatus.FAILED
+    scholar.last_run_dt = datetime.now(UTC)
+    logger.exception(
+        "ingestion.scholar_unexpected_failure",
+        extra={
+            "crawl_run_id": run.id,
+            "scholar_profile_id": scholar.id,
+            "scholar_id": scholar.scholar_id,
+        },
+    )
+    return ScholarProcessingOutcome(
+        result_entry={
+            "scholar_profile_id": scholar.id,
+            "scholar_id": scholar.scholar_id,
+            "state": "ingestion_error",
+            "state_reason": "scholar_processing_exception",
+            "outcome": "failed",
+            "attempt_count": 0,
+            "publication_count": 0,
+            "start_cstart": start_cstart,
+            "warnings": [],
+            "error": str(exc),
+            "debug": {"exception_type": type(exc).__name__, "exception_message": str(exc)},
+        },
+        succeeded_count_delta=0,
+        failed_count_delta=1,
+        partial_count_delta=0,
+        discovered_publication_count=0,
+    )
+
+
+async def run_scholar_iteration(
+    db_session: AsyncSession,
+    *,
+    pagination: PaginationEngine,
+    run: CrawlRun,
+    scholars: list[ScholarProfile],
+    user_id: int,
+    start_cstart_map: dict[int, int],
+    request_delay_seconds: int,
+    network_error_retries: int,
+    retry_backoff_seconds: float,
+    rate_limit_retries: int,
+    rate_limit_backoff_seconds: float,
+    max_pages_per_scholar: int,
+    page_size: int,
+    auto_queue_continuations: bool,
+    queue_delay_seconds: int,
+) -> RunProgress:
+    progress = RunProgress()
+    scholar_kwargs = {
+        "request_delay_seconds": request_delay_seconds,
+        "network_error_retries": network_error_retries,
+        "retry_backoff_seconds": retry_backoff_seconds,
+        "rate_limit_retries": rate_limit_retries,
+        "rate_limit_backoff_seconds": rate_limit_backoff_seconds,
+        "page_size": page_size,
+    }
+
+    # ── Pass 1: first page of every scholar (breadth-first) ──────────
+    first_pass_cstarts: dict[int, int] = {}
+    for index, scholar in enumerate(scholars):
+        await db_session.refresh(run)
+        if run.status == RunStatus.CANCELED:
+            structured_log(logger, "info", "ingestion.run_canceled", run_id=run.id, user_id=user_id)
+            return progress
+        if index > 0 and request_delay_seconds > 0:
+            await asyncio.sleep(float(request_delay_seconds))
+        start_cstart = int(start_cstart_map.get(int(scholar.id), 0))
+        outcome = await process_scholar(
+            db_session,
+            pagination=pagination,
+            run=run,
+            scholar=scholar,
+            user_id=user_id,
+            start_cstart=start_cstart,
+            max_pages_per_scholar=1,
+            auto_queue_continuations=False,
+            queue_delay_seconds=queue_delay_seconds,
+            **scholar_kwargs,
+        )
+        apply_outcome_to_progress(progress=progress, outcome=outcome)
+        resume_cstart = outcome.result_entry.get("continuation_cstart")
+        if resume_cstart is not None and int(resume_cstart) > start_cstart:
+            first_pass_cstarts[int(scholar.id)] = int(resume_cstart)
+
+    # ── Pass 2: remaining pages for each scholar (depth) ─────────────
+    remaining_max = max(max_pages_per_scholar - 1, 0)
+    if remaining_max <= 0:
+        return progress
+
+    for index, scholar in enumerate(scholars):
+        resume_cstart = first_pass_cstarts.get(int(scholar.id))
+        if resume_cstart is None:
+            continue
+        await db_session.refresh(run)
+        if run.status == RunStatus.CANCELED:
+            structured_log(logger, "info", "ingestion.run_canceled", run_id=run.id, user_id=user_id)
+            break
+        if index > 0 and request_delay_seconds > 0:
+            await asyncio.sleep(float(request_delay_seconds))
+        outcome = await process_scholar(
+            db_session,
+            pagination=pagination,
+            run=run,
+            scholar=scholar,
+            user_id=user_id,
+            start_cstart=resume_cstart,
+            max_pages_per_scholar=remaining_max,
+            auto_queue_continuations=auto_queue_continuations,
+            queue_delay_seconds=queue_delay_seconds,
+            **scholar_kwargs,
+        )
+        apply_outcome_to_progress(progress=progress, outcome=outcome)
+    return progress
diff --git a/app/services/scholar/source.py b/app/services/scholar/source.py
index 08f22ba..8d61ec8 100644
--- a/app/services/scholar/source.py
+++ b/app/services/scholar/source.py
@@ -62,6 +62,7 @@ class LiveScholarSource:
         *,
         timeout_seconds: float = 25.0,
         min_interval_seconds: float | None = None,
+        rotate_user_agents: bool | None = None,
         user_agents: list[str] | None = None,
     ) -> None:
         self._timeout_seconds = timeout_seconds
@@ -72,6 +73,38 @@ class LiveScholarSource:
         )
         self._min_interval_seconds = max(configured_interval, 0.0)
         self._user_agents = user_agents or DEFAULT_USER_AGENTS
+        self._rotate_user_agents = (
+            bool(settings.scholar_http_rotate_user_agent)
+            if rotate_user_agents is None
+            else bool(rotate_user_agents)
+        )
+        configured_user_agent = settings.scholar_http_user_agent.strip()
+        self._configured_user_agent = configured_user_agent or None
+        self._accept_language = settings.scholar_http_accept_language.strip() or "en-US,en;q=0.9"
+        self._cookie_header = settings.scholar_http_cookie.strip() or None
+        self._stable_user_agent = self._resolve_initial_user_agent()
+
+    def _resolve_initial_user_agent(self) -> str:
+        if self._configured_user_agent is not None:
+            return self._configured_user_agent
+        return random.choice(self._user_agents)
+
+    def _resolve_user_agent_for_request(self) -> str:
+        if self._configured_user_agent is not None:
+            return self._configured_user_agent
+        if self._rotate_user_agents:
+            return random.choice(self._user_agents)
+        return self._stable_user_agent
+
+    def _request_headers(self) -> dict[str, str]:
+        headers = {
+            "User-Agent": self._resolve_user_agent_for_request(),
+            "Accept": "text/html,application/xhtml+xml",
+            "Accept-Language": self._accept_language,
+        }
+        if self._cookie_header is not None:
+            headers["Cookie"] = self._cookie_header
+        return headers
 
     async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
         return await self.fetch_profile_page_html(
@@ -116,15 +149,21 @@ class LiveScholarSource:
         return await asyncio.to_thread(self._fetch_sync, requested_url)
 
     def _build_request(self, requested_url: str) -> Request:
-        return Request(
-            requested_url,
-            headers={
-                "User-Agent": random.choice(self._user_agents),
-                "Accept": "text/html,application/xhtml+xml",
-                "Accept-Language": "en-US,en;q=0.9",
-                "Connection": "close",
-            },
-        )
+        return Request(requested_url, headers=self._request_headers())
+
+    @staticmethod
+    def _http_error_reason(*, status_code: int, final_url: str, body: str) -> str:
+        lowered_url = final_url.lower()
+        lowered_body = body.lower()
+        if "sorry/index" in lowered_url or "sorry/index" in lowered_body:
+            return "blocked_google_sorry_challenge"
+        if "our systems have detected" in lowered_body or "unusual traffic" in lowered_body:
+            return "blocked_unusual_traffic_detected"
+        if "automated queries" in lowered_body:
+            return "blocked_automated_queries_detected"
+        if status_code == 429:
+            return "blocked_http_429_rate_limited"
+        return f"http_error_status_{status_code}"
 
     @staticmethod
     def _http_error_body(exc: HTTPError) -> str:
@@ -151,18 +190,27 @@ class LiveScholarSource:
 
     @staticmethod
     def _http_error_result(requested_url: str, exc: HTTPError) -> FetchResult:
+        final_url = exc.geturl()
+        body = LiveScholarSource._http_error_body(exc)
+        block_reason = LiveScholarSource._http_error_reason(
+            status_code=exc.code,
+            final_url=final_url,
+            body=body,
+        )
         structured_log(
             logger,
             "warning",
             "scholar_source.fetch_http_error",
             requested_url=requested_url,
             status_code=exc.code,
+            final_url=final_url,
+            block_reason=block_reason,
         )
         return FetchResult(
             requested_url=requested_url,
             status_code=exc.code,
-            final_url=exc.geturl(),
-            body=LiveScholarSource._http_error_body(exc),
+            final_url=final_url,
+            body=body,
             error=str(exc),
         )
 
diff --git a/app/services/scholar/state_detection.py b/app/services/scholar/state_detection.py
index 75f7125..7532afa 100644
--- a/app/services/scholar/state_detection.py
+++ b/app/services/scholar/state_detection.py
@@ -38,18 +38,18 @@ def classify_block_or_captcha_reason(
 ) -> str | None:
     if "accounts.google.com" in final_url and ("signin" in final_url or "servicelogin" in final_url):
         return "blocked_accounts_redirect"
-    if status_code == 429:
-        return "blocked_http_429_rate_limited"
-    if status_code == 403:
-        if "recaptcha" in body_lowered or "captcha" in body_lowered or "sorry/index" in final_url:
-            return "blocked_http_403_captcha_challenge"
-        return "blocked_http_403_forbidden"
     if "sorry/index" in final_url or "sorry/index" in body_lowered:
         return "blocked_google_sorry_challenge"
     if "our systems have detected" in body_lowered or "unusual traffic" in body_lowered:
         return "blocked_unusual_traffic_detected"
     if "automated queries" in body_lowered:
         return "blocked_automated_queries_detected"
+    if status_code == 429:
+        return "blocked_http_429_rate_limited"
+    if status_code == 403:
+        if "recaptcha" in body_lowered or "captcha" in body_lowered:
+            return "blocked_http_403_captcha_challenge"
+        return "blocked_http_403_forbidden"
     if "not a robot" in body_lowered:
         return "blocked_not_a_robot_challenge"
     if "recaptcha" in body_lowered:
diff --git a/app/settings.py b/app/settings.py
index 175480e..c9098a1 100644
--- a/app/settings.py
+++ b/app/settings.py
@@ -235,6 +235,13 @@ class Settings:
         "SCHOLAR_NAME_SEARCH_ALERT_COOLDOWN_REJECTIONS_THRESHOLD",
         3,
     )
+    scholar_http_user_agent: str = _env_str("SCHOLAR_HTTP_USER_AGENT", "")
+    scholar_http_rotate_user_agent: bool = _env_bool("SCHOLAR_HTTP_ROTATE_USER_AGENT", False)
+    scholar_http_accept_language: str = _env_str(
+        "SCHOLAR_HTTP_ACCEPT_LANGUAGE",
+        "en-US,en;q=0.9",
+    )
+    scholar_http_cookie: str = _env_str("SCHOLAR_HTTP_COOKIE", "")
     unpaywall_enabled: bool = _env_bool("UNPAYWALL_ENABLED", True)
     unpaywall_email: str = _env_str("UNPAYWALL_EMAIL", "")
     unpaywall_timeout_seconds: float = _env_float("UNPAYWALL_TIMEOUT_SECONDS", 4.0)
diff --git a/frontend/src/features/settings/index.ts b/frontend/src/features/settings/index.ts
index 6ff6c94..a1edce7 100644
--- a/frontend/src/features/settings/index.ts
+++ b/frontend/src/features/settings/index.ts
@@ -34,6 +34,13 @@ export interface UserSettingsUpdate {
   crossref_api_mailto: string | null;
 }
 
+export interface AdminScholarHttpSettings {
+  user_agent: string;
+  rotate_user_agent: boolean;
+  accept_language: string;
+  cookie: string;
+}
+
 export interface ChangePasswordPayload {
   current_password: string;
   new_password: string;
@@ -60,3 +67,20 @@ export async function changePassword(payload: ChangePasswordPayload): Promise<{
   });
   return response.data;
 }
+
+export async function fetchAdminScholarHttpSettings(): Promise<AdminScholarHttpSettings> {
+  const response = await apiRequest<AdminScholarHttpSettings>("/admin/settings/scholar-http", {
+    method: "GET",
+  });
+  return response.data;
+}
+
+export async function updateAdminScholarHttpSettings(
+  payload: AdminScholarHttpSettings,
+): Promise<AdminScholarHttpSettings> {
+  const response = await apiRequest<AdminScholarHttpSettings>("/admin/settings/scholar-http", {
+    method: "PUT",
+    body: payload,
+  });
+  return response.data;
+}
diff --git a/frontend/src/pages/SettingsPage.vue b/frontend/src/pages/SettingsPage.vue
index 66f12eb..4040f0e 100644
--- a/frontend/src/pages/SettingsPage.vue
+++ b/frontend/src/pages/SettingsPage.vue
@@ -14,9 +14,12 @@ import AppTabs, { type AppTabItem } from "@/components/ui/AppTabs.vue";
 import SettingsAdminPanel from "@/features/settings/SettingsAdminPanel.vue";
 import {
   changePassword,
+  fetchAdminScholarHttpSettings,
   fetchSettings,
+  type AdminScholarHttpSettings,
   type UserSettings,
   type UserSettingsUpdate,
+  updateAdminScholarHttpSettings,
   updateSettings,
 } from "@/features/settings";
 import { ApiRequestError } from "@/lib/api/errors";
@@ -40,6 +43,7 @@ const router = useRouter();
 
 const loading = ref(true);
 const saving = ref(false);
+const savingScholarHttp = ref(false);
 const updatingPassword = ref(false);
 
 const autoRunEnabled = ref(false);
@@ -49,6 +53,10 @@ const navVisiblePages = ref<string[]>([]);
 const openalexApiKey = ref("");
 const crossrefApiToken = ref("");
 const crossrefApiMailto = ref("");
+const scholarHttpUserAgent = ref("");
+const scholarHttpRotateUserAgent = ref(false);
+const scholarHttpAcceptLanguage = ref("en-US,en;q=0.9");
+const scholarHttpCookie = ref("");
 
 const currentPassword = ref("");
 const newPassword = ref("");
@@ -142,6 +150,13 @@ function hydrateSettings(settings: UserSettings): void {
   runStatus.setSafetyState(settings.safety_state);
 }
 
+function hydrateScholarHttpSettings(settings: AdminScholarHttpSettings): void {
+  scholarHttpUserAgent.value = settings.user_agent;
+  scholarHttpRotateUserAgent.value = Boolean(settings.rotate_user_agent);
+  scholarHttpAcceptLanguage.value = settings.accept_language;
+  scholarHttpCookie.value = settings.cookie;
+}
+
 function parseBoundedInteger(value: string, label: string, minimum: number): number {
   const parsed = Number(value);
   if (!Number.isInteger(parsed)) {
@@ -160,6 +175,9 @@ async function loadSettings(): Promise<void> {
   try {
     const settings = await fetchSettings();
     hydrateSettings(settings);
+    if (auth.isAdmin) {
+      hydrateScholarHttpSettings(await fetchAdminScholarHttpSettings());
+    }
   } catch (error) {
     if (error instanceof ApiRequestError) {
       errorMessage.value = error.message;
@@ -172,6 +190,32 @@ async function loadSettings(): Promise<void> {
   }
 }
 
+async function onSaveScholarHttpSettings(): Promise<void> {
+  savingScholarHttp.value = true;
+  errorMessage.value = null;
+  errorRequestId.value = null;
+  successMessage.value = null;
+  try {
+    const updated = await updateAdminScholarHttpSettings({
+      user_agent: scholarHttpUserAgent.value.trim(),
+      rotate_user_agent: scholarHttpRotateUserAgent.value,
+      accept_language: scholarHttpAcceptLanguage.value.trim(),
+      cookie: scholarHttpCookie.value.trim(),
+    });
+    hydrateScholarHttpSettings(updated);
+    successMessage.value = "Scholar HTTP profile updated.";
+  } catch (error) {
+    if (error instanceof ApiRequestError) {
+      errorMessage.value = error.message;
+      errorRequestId.value = error.requestId;
+    } else {
+      errorMessage.value = "Unable to save Scholar HTTP profile.";
+    }
+  } finally {
+    savingScholarHttp.value = false;
+  }
+}
+
 async function onSaveSettings(): Promise<void> {
   saving.value = true;
   errorMessage.value = null;
@@ -404,6 +448,49 @@ onMounted(async () => {
                 <AppInput v-model="crossrefApiMailto" placeholder="e.g. admin@yourdomain.com" type="email" autocomplete="off" />
               </label>
             </div>
+
+            <div class="grid gap-2 rounded-lg border border-stroke-default bg-surface-card-muted p-3">
+              <h3 class="text-sm font-semibold text-ink-secondary">Scholar Request Profile</h3>
+              <p class="text-xs text-secondary mb-2">
+                Tune Scholar HTTP fingerprint behavior used by live scraper requests. Changes apply to new runs.
+              </p>
+              <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+                <span>User-Agent override</span>
+                <AppInput
+                  v-model="scholarHttpUserAgent"
+                  placeholder="Leave empty to use built-in browser-like user agent"
+                  autocomplete="off"
+                />
+              </label>
+              <label class="grid gap-1 text-sm font-medium text-ink-secondary mt-2">
+                <span>Accept-Language</span>
+                <AppInput
+                  v-model="scholarHttpAcceptLanguage"
+                  placeholder="e.g. en-US,en;q=0.9"
+                  autocomplete="off"
+                />
+              </label>
+              <label class="grid gap-1 text-sm font-medium text-ink-secondary mt-2">
+                <span>Cookie header</span>
+                <AppInput
+                  v-model="scholarHttpCookie"
+                  placeholder="Optional. Leave empty to disable cookie passthrough"
+                  autocomplete="off"
+                />
+              </label>
+              <div class="mt-2">
+                <AppCheckbox
+                  id="scholar-http-rotate-user-agent"
+                  v-model="scholarHttpRotateUserAgent"
+                  label="Rotate user-agent per request"
+                />
+              </div>
+              <div>
+                <AppButton :disabled="savingScholarHttp" @click="onSaveScholarHttpSettings">
+                  {{ savingScholarHttp ? "Saving..." : "Save Scholar request profile" }}
+                </AppButton>
+              </div>
+            </div>
           </div>
 
           <div>
diff --git a/tests/integration/test_api_v1.py b/tests/integration/test_api_v1.py
index 41a9051..06551ca 100644
--- a/tests/integration/test_api_v1.py
+++ b/tests/integration/test_api_v1.py
@@ -391,6 +391,61 @@ async def test_api_admin_user_management_endpoints(db_session: AsyncSession) ->
     assert created_exists.scalar_one() == 1
 
 
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_admin_scholar_http_settings_endpoints(db_session: AsyncSession) -> None:
+    await insert_user(
+        db_session,
+        email="api-admin-http@example.com",
+        password="admin-password",
+        is_admin=True,
+    )
+    await insert_user(
+        db_session,
+        email="api-member-http@example.com",
+        password="member-password",
+        is_admin=False,
+    )
+    previous_user_agent = settings.scholar_http_user_agent
+    previous_rotate = settings.scholar_http_rotate_user_agent
+    previous_accept_language = settings.scholar_http_accept_language
+    previous_cookie = settings.scholar_http_cookie
+    try:
+        client = TestClient(app)
+        login_user(client, email="api-admin-http@example.com", password="admin-password")
+        headers = _api_csrf_headers(client)
+
+        read_response = client.get("/api/v1/admin/settings/scholar-http")
+        assert read_response.status_code == 200
+
+        update_response = client.put(
+            "/api/v1/admin/settings/scholar-http",
+            json={
+                "user_agent": "Mozilla/5.0 Test Runner",
+                "rotate_user_agent": False,
+                "accept_language": "en-US,en;q=0.8",
+                "cookie": "SID=test-cookie",
+            },
+            headers=headers,
+        )
+        assert update_response.status_code == 200
+        payload = update_response.json()["data"]
+        assert payload["user_agent"] == "Mozilla/5.0 Test Runner"
+        assert payload["cookie"] == "SID=test-cookie"
+        assert settings.scholar_http_user_agent == "Mozilla/5.0 Test Runner"
+
+        client.post("/api/v1/auth/logout", headers=headers)
+        login_user(client, email="api-member-http@example.com", password="member-password")
+        forbidden_response = client.get("/api/v1/admin/settings/scholar-http")
+        assert forbidden_response.status_code == 403
+    finally:
+        object.__setattr__(settings, "scholar_http_user_agent", previous_user_agent)
+        object.__setattr__(settings, "scholar_http_rotate_user_agent", previous_rotate)
+        object.__setattr__(settings, "scholar_http_accept_language", previous_accept_language)
+        object.__setattr__(settings, "scholar_http_cookie", previous_cookie)
+
+
 @pytest.mark.integration
 @pytest.mark.db
 @pytest.mark.asyncio
diff --git a/tests/integration/test_deferred_enrichment.py b/tests/integration/test_deferred_enrichment.py
index 14f5bee..d026fe3 100644
--- a/tests/integration/test_deferred_enrichment.py
+++ b/tests/integration/test_deferred_enrichment.py
@@ -8,7 +8,7 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import CrawlRun, Publication, RunStatus, RunTriggerType, ScholarProfile, ScholarPublication
-from app.services.ingestion.application import ScholarIngestionService
+from app.services.ingestion.enrichment import EnrichmentRunner
 from app.services.openalex.types import OpenAlexWork
 from tests.integration.helpers import insert_user
 
@@ -79,8 +79,7 @@ async def test_deferred_enrichment_sweeps_previous_runs(db_session: AsyncSession
         oa_url="http://example.com/grover.pdf",
     )
 
-    mock_source = MagicMock()
-    service = ScholarIngestionService(source=mock_source)
+    runner = EnrichmentRunner()
 
     # We patch the client at its source, and also mock arXiv to avoid real HTTP calls
     with (
@@ -93,7 +92,7 @@ async def test_deferred_enrichment_sweeps_previous_runs(db_session: AsyncSession
         mock_instance.get_works_by_filter = AsyncMock(return_value=[mock_work])
 
         # 5. Execute the enrichment pass for the NEW run
-        await service._enrich_pending_publications(db_session, run_id=new_run.id)
+        await runner.enrich_pending_publications(db_session, run_id=new_run.id)
         await db_session.commit()
 
     # 6. Verification: The publication from the FAILED run should now be enriched
diff --git a/tests/unit/test_ingestion_arxiv_rate_limit.py b/tests/unit/test_ingestion_arxiv_rate_limit.py
index 68f2792..5d38779 100644
--- a/tests/unit/test_ingestion_arxiv_rate_limit.py
+++ b/tests/unit/test_ingestion_arxiv_rate_limit.py
@@ -5,7 +5,7 @@ from types import SimpleNamespace
 import pytest
 
 from app.services.arxiv.errors import ArxivRateLimitError
-from app.services.ingestion.application import ScholarIngestionService
+from app.services.ingestion.enrichment import EnrichmentRunner
 from app.services.publication_identifiers import application as identifier_service
 
 
@@ -13,7 +13,7 @@ from app.services.publication_identifiers import application as identifier_servi
 async def test_discover_identifiers_for_enrichment_disables_arxiv_on_rate_limit(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    service = ScholarIngestionService(source=object())
+    runner = EnrichmentRunner()
     publication = SimpleNamespace(id=11, author_text="Ada Lovelace")
     calls = {"sync": 0}
 
@@ -35,9 +35,9 @@ async def test_discover_identifiers_for_enrichment_disables_arxiv_on_rate_limit(
     async def _publish_noop(*args, **kwargs) -> None:
         _ = (args, kwargs)
 
-    monkeypatch.setattr(service, "_publish_identifier_update_event", _publish_noop)
+    monkeypatch.setattr(runner, "_publish_identifier_update_event", _publish_noop)
 
-    result = await service._discover_identifiers_for_enrichment(
+    result = await runner._discover_identifiers_for_enrichment(
         object(),
         publication=publication,
         run_id=321,
diff --git a/tests/unit/test_ingestion_progress_reporting.py b/tests/unit/test_ingestion_progress_reporting.py
index ed470d6..bdae206 100644
--- a/tests/unit/test_ingestion_progress_reporting.py
+++ b/tests/unit/test_ingestion_progress_reporting.py
@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import pytest
 
-from app.services.ingestion.application import ScholarIngestionService
+from app.services.ingestion.run_completion import apply_outcome_to_progress
 from app.services.ingestion.types import RunProgress, ScholarProcessingOutcome
 
 
@@ -31,11 +31,11 @@ def _outcome(*, scholar_profile_id: int, outcome_label: str) -> ScholarProcessin
 def test_apply_outcome_to_progress_replaces_previous_scholar_outcome() -> None:
     progress = RunProgress()
 
-    ScholarIngestionService._apply_outcome_to_progress(
+    apply_outcome_to_progress(
         progress=progress,
         outcome=_outcome(scholar_profile_id=42, outcome_label="partial"),
     )
-    ScholarIngestionService._apply_outcome_to_progress(
+    apply_outcome_to_progress(
         progress=progress,
         outcome=_outcome(scholar_profile_id=42, outcome_label="success"),
     )
@@ -58,4 +58,4 @@ def test_apply_outcome_to_progress_rejects_invalid_scholar_id() -> None:
     )
 
     with pytest.raises(RuntimeError, match="missing valid scholar_profile_id"):
-        ScholarIngestionService._apply_outcome_to_progress(progress=progress, outcome=invalid)
+        apply_outcome_to_progress(progress=progress, outcome=invalid)
diff --git a/tests/unit/test_scholar_parser.py b/tests/unit/test_scholar_parser.py
index ee3c3ec..90bc2da 100644
--- a/tests/unit/test_scholar_parser.py
+++ b/tests/unit/test_scholar_parser.py
@@ -433,3 +433,18 @@ def test_parse_author_search_page_classifies_http_429_as_blocked() -> None:
 
     assert parsed.state == ParseState.BLOCKED_OR_CAPTCHA
     assert parsed.state_reason == "blocked_http_429_rate_limited"
+
+
+def test_parse_author_search_page_prefers_sorry_challenge_reason_over_generic_429() -> None:
+    fetch_result = FetchResult(
+        requested_url="https://scholar.google.com/citations?hl=en&view_op=search_authors&mauthors=ada",
+        status_code=429,
+        final_url="https://www.google.com/sorry/index?continue=scholar",
+        body="<html><body>Our systems have detected unusual traffic.</body></html>",
+        error=None,
+    )
+
+    parsed = parse_author_search_page(fetch_result)
+
+    assert parsed.state == ParseState.BLOCKED_OR_CAPTCHA
+    assert parsed.state_reason == "blocked_google_sorry_challenge"
diff --git a/tests/unit/test_scholar_source.py b/tests/unit/test_scholar_source.py
index 654cb58..0d98f4c 100644
--- a/tests/unit/test_scholar_source.py
+++ b/tests/unit/test_scholar_source.py
@@ -2,6 +2,12 @@ import pytest
 
 from app.services.scholar import rate_limit as scholar_rate_limit
 from app.services.scholar.source import FetchResult, LiveScholarSource, _build_profile_url
+from app.settings import settings
+
+
+def _request_header(request, name: str) -> str | None:
+    headers = {key.lower(): value for key, value in request.header_items()}
+    return headers.get(name.lower())
 
 
 def test_build_profile_url_includes_pagesize_for_initial_page() -> None:
@@ -48,3 +54,72 @@ async def test_live_scholar_source_applies_global_throttle(monkeypatch: pytest.M
 
     assert result == expected_result
     assert captured_interval == [7.0]
+
+
+def test_http_error_reason_prefers_sorry_challenge_marker() -> None:
+    reason = LiveScholarSource._http_error_reason(
+        status_code=429,
+        final_url="https://www.google.com/sorry/index?continue=example",
+        body="",
+    )
+    assert reason == "blocked_google_sorry_challenge"
+
+
+def test_http_error_reason_falls_back_to_http_429_rate_limit() -> None:
+    reason = LiveScholarSource._http_error_reason(
+        status_code=429,
+        final_url="https://scholar.google.com/citations?hl=en&user=abc",
+        body="Too Many Requests",
+    )
+    assert reason == "blocked_http_429_rate_limited"
+
+
+def test_build_request_uses_stable_user_agent_by_default() -> None:
+    previous_user_agent = settings.scholar_http_user_agent
+    previous_rotate = settings.scholar_http_rotate_user_agent
+    previous_cookie = settings.scholar_http_cookie
+    previous_accept_language = settings.scholar_http_accept_language
+    object.__setattr__(settings, "scholar_http_user_agent", "")
+    object.__setattr__(settings, "scholar_http_rotate_user_agent", False)
+    object.__setattr__(settings, "scholar_http_cookie", "")
+    object.__setattr__(settings, "scholar_http_accept_language", "en-US,en;q=0.9")
+    try:
+        source = LiveScholarSource(user_agents=["UA-A", "UA-B"])
+        request_one = source._build_request("https://example.test/one")
+        request_two = source._build_request("https://example.test/two")
+        assert _request_header(request_one, "User-Agent") == _request_header(request_two, "User-Agent")
+        assert _request_header(request_one, "Connection") is None
+    finally:
+        object.__setattr__(settings, "scholar_http_user_agent", previous_user_agent)
+        object.__setattr__(settings, "scholar_http_rotate_user_agent", previous_rotate)
+        object.__setattr__(settings, "scholar_http_cookie", previous_cookie)
+        object.__setattr__(settings, "scholar_http_accept_language", previous_accept_language)
+
+
+def test_build_request_rotates_user_agent_when_enabled(monkeypatch: pytest.MonkeyPatch) -> None:
+    previous_user_agent = settings.scholar_http_user_agent
+    previous_rotate = settings.scholar_http_rotate_user_agent
+    object.__setattr__(settings, "scholar_http_user_agent", "")
+    object.__setattr__(settings, "scholar_http_rotate_user_agent", True)
+    choices = iter(["UA-STABLE", "UA-1", "UA-2"])
+    monkeypatch.setattr("app.services.scholar.source.random.choice", lambda _values: next(choices))
+    try:
+        source = LiveScholarSource(user_agents=["UA-A", "UA-B"])
+        request_one = source._build_request("https://example.test/one")
+        request_two = source._build_request("https://example.test/two")
+        assert _request_header(request_one, "User-Agent") == "UA-1"
+        assert _request_header(request_two, "User-Agent") == "UA-2"
+    finally:
+        object.__setattr__(settings, "scholar_http_user_agent", previous_user_agent)
+        object.__setattr__(settings, "scholar_http_rotate_user_agent", previous_rotate)
+
+
+def test_build_request_includes_cookie_when_configured() -> None:
+    previous_cookie = settings.scholar_http_cookie
+    object.__setattr__(settings, "scholar_http_cookie", "SID=abc123")
+    try:
+        source = LiveScholarSource(user_agents=["UA-A"])
+        request = source._build_request("https://example.test/one")
+        assert _request_header(request, "Cookie") == "SID=abc123"
+    finally:
+        object.__setattr__(settings, "scholar_http_cookie", previous_cookie)
-- 
2.49.1


From 8c6069c121d25e5efdf4a423997fe09ce9e91ff9 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 14:26:29 +0100
Subject: [PATCH 26/38] Decomp plan adjustment

---
 DECOMPOSITION_SLICES.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/DECOMPOSITION_SLICES.md b/DECOMPOSITION_SLICES.md
index 87604ae..c65cb2a 100644
--- a/DECOMPOSITION_SLICES.md
+++ b/DECOMPOSITION_SLICES.md
@@ -6,6 +6,7 @@ This file contains self-contained decomposition prompts ("slices") to bring the
 
 **Rules from `agents.md`:**
 - File length: 400 lines target, 600 lines hard ceiling
+- Slightly exceeding the 600-line ceiling is acceptable when the excess is driven by verbose keyword-argument signatures (named parameters), not by business logic density
 - Function length: 50 lines max
 - All business logic in `app/services/<domain>/`
 - Read `agents.md` fully before starting any slice
-- 
2.49.1


From b7015837169e1440b706f2f22940d871c970556c Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 14:39:12 +0100
Subject: [PATCH 27/38] refactor: decompose scholars service and pdf_queue into
 focused modules

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 DECOMPOSITION_SLICES.md                       |  17 +-
 .../publication_identifiers/application.py    |   2 +-
 app/services/publications/application.py      |   4 +-
 app/services/publications/pdf_queue.py        | 638 +-------------
 .../publications/pdf_queue_queries.py         | 395 +++++++++
 .../publications/pdf_queue_resolution.py      | 311 +++++++
 app/services/scholars/application.py          | 823 +-----------------
 app/services/scholars/author_search.py        | 580 ++++++++++++
 app/services/scholars/author_search_cache.py  | 239 +++++
 .../unit/test_publication_pdf_queue_policy.py |  26 +-
 10 files changed, 1592 insertions(+), 1443 deletions(-)
 create mode 100644 app/services/publications/pdf_queue_queries.py
 create mode 100644 app/services/publications/pdf_queue_resolution.py
 create mode 100644 app/services/scholars/author_search.py
 create mode 100644 app/services/scholars/author_search_cache.py

diff --git a/DECOMPOSITION_SLICES.md b/DECOMPOSITION_SLICES.md
index c65cb2a..f14f072 100644
--- a/DECOMPOSITION_SLICES.md
+++ b/DECOMPOSITION_SLICES.md
@@ -28,7 +28,7 @@ This file contains self-contained decomposition prompts ("slices") to bring the
 | 1 | Schema split | **DONE** |
 | 2 | Ingestion: pagination + publication upsert | **DONE** |
 | 3 | Ingestion: enrichment + scholar processing + run completion | **DONE** |
-| 4 | Scholars service + PDF queue | pending |
+| 4 | Scholars service + PDF queue | **DONE** |
 | 5 | Routers + scheduler | pending |
 
 ---
@@ -132,13 +132,20 @@ Commit message: `refactor: extract enrichment, scholar processing, and run compl
 
 ---
 
-## Slice 4: Decompose `app/services/scholars/application.py` (996 lines) and `app/services/publications/pdf_queue.py` (969 lines)
+## Slice 4: Decompose `app/services/scholars/application.py` (996 lines) and `app/services/publications/pdf_queue.py` (969 lines) — DONE
 
-**Why:** Two service files nearly 2x the hard ceiling. Each has clear internal seams.
+Completed. Extracted four modules from two oversized service files:
 
-**Files to create:** `app/services/scholars/author_search.py`, `app/services/scholars/author_search_cache.py`, `app/services/publications/pdf_queue_queries.py`, `app/services/publications/pdf_queue_resolution.py`
+| File | Lines | Contents |
+|---|---|---|
+| `app/services/scholars/author_search_cache.py` | 239 | Serialize/deserialize cache entries, cache get/set/prune |
+| `app/services/scholars/author_search.py` | 580 | Cooldown, throttle, retry, circuit breaker, `search_author_candidates` |
+| `app/services/scholars/application.py` | 221 | Scholar CRUD only (list, create, get, toggle, delete, image ops) |
+| `app/services/publications/pdf_queue_queries.py` | 395 | SQL builders, row hydration, listing/counting/pagination, retry item builders |
+| `app/services/publications/pdf_queue_resolution.py` | 311 | Task execution, outcome persistence, scheduling (`schedule_rows`) |
+| `app/services/publications/pdf_queue.py` | 364 | Dataclasses, constants, enqueueing logic, public API |
 
-**Files to modify:** `app/services/scholars/application.py`, `app/services/publications/pdf_queue.py`
+Also updated one test file (`test_publication_pdf_queue_policy.py`) to monkeypatch `pdf_queue_resolution` instead of `pdf_queue` for the 4 resolution-related tests, and updated `publications/application.py` and `publication_identifiers/application.py` imports.
 
 **Prompt:**
 
diff --git a/app/services/publication_identifiers/application.py b/app/services/publication_identifiers/application.py
index 7724f46..560211e 100644
--- a/app/services/publication_identifiers/application.py
+++ b/app/services/publication_identifiers/application.py
@@ -21,7 +21,7 @@ from app.services.publication_identifiers.types import (
 )
 
 if TYPE_CHECKING:
-    from app.services.publications.pdf_queue import PdfQueueListItem
+    from app.services.publications.pdf_queue_queries import PdfQueueListItem
     from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 CONFIDENCE_HIGH = 0.98
diff --git a/app/services/publications/application.py b/app/services/publications/application.py
index 023903c..61cf9ad 100644
--- a/app/services/publications/application.py
+++ b/app/services/publications/application.py
@@ -24,9 +24,11 @@ from app.services.publications.modes import (
     resolve_publication_view_mode,
 )
 from app.services.publications.pdf_queue import (
-    count_pdf_queue_items,
     enqueue_all_missing_pdf_jobs,
     enqueue_retry_pdf_job_for_publication_id,
+)
+from app.services.publications.pdf_queue_queries import (
+    count_pdf_queue_items,
     list_pdf_queue_items,
     list_pdf_queue_page,
 )
diff --git a/app/services/publications/pdf_queue.py b/app/services/publications/pdf_queue.py
index 96ec41b..eef0d61 100644
--- a/app/services/publications/pdf_queue.py
+++ b/app/services/publications/pdf_queue.py
@@ -1,33 +1,23 @@
 from __future__ import annotations
 
-import asyncio
 import logging
 from dataclasses import dataclass
-from datetime import UTC, datetime, timedelta
+from datetime import UTC, datetime
 
-from sqlalchemy import Select, and_, func, literal, or_, select, union_all
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import (
-    Publication,
     PublicationPdfJob,
     PublicationPdfJobEvent,
-    ScholarProfile,
-    ScholarPublication,
     User,
 )
-from app.db.session import get_session_factory
-from app.logging_utils import structured_log
-from app.services.publication_identifiers import application as identifier_service
-from app.services.publication_identifiers.types import DisplayIdentifier
-from app.services.publications.pdf_resolution_pipeline import (
-    resolve_publication_pdf_outcome_for_row,
+from app.services.publications.pdf_queue_queries import (
+    missing_pdf_candidates,
+    retry_item_for_publication_id,
 )
+from app.services.publications.pdf_queue_resolution import schedule_rows
 from app.services.publications.types import PublicationListItem
-from app.services.unpaywall.application import (
-    FAILURE_RESOLUTION_EXCEPTION,
-    OaResolutionOutcome,
-)
 from app.settings import settings
 
 PDF_STATUS_UNTRACKED = "untracked"
@@ -37,31 +27,8 @@ PDF_STATUS_RESOLVED = "resolved"
 PDF_STATUS_FAILED = "failed"
 
 PDF_EVENT_QUEUED = "queued"
-PDF_EVENT_ATTEMPT_STARTED = "attempt_started"
-PDF_EVENT_RESOLVED = "resolved"
-PDF_EVENT_FAILED = "failed"
 
 logger = logging.getLogger(__name__)
-_scheduled_tasks: set[asyncio.Task[None]] = set()
-
-
-@dataclass(frozen=True)
-class PdfQueueListItem:
-    publication_id: int
-    title: str
-    pdf_url: str | None
-    status: str
-    attempt_count: int
-    last_failure_reason: str | None
-    last_failure_detail: str | None
-    last_source: str | None
-    requested_by_user_id: int | None
-    requested_by_email: str | None
-    queued_at: datetime | None
-    last_attempt_at: datetime | None
-    resolved_at: datetime | None
-    updated_at: datetime
-    display_identifier: DisplayIdentifier | None = None
 
 
 @dataclass(frozen=True)
@@ -76,14 +43,6 @@ class PdfBulkQueueResult:
     queued_count: int
 
 
-@dataclass(frozen=True)
-class PdfQueuePage:
-    items: list[PdfQueueListItem]
-    total_count: int
-    limit: int
-    offset: int
-
-
 def _utcnow() -> datetime:
     return datetime.now(UTC)
 
@@ -138,14 +97,6 @@ def _queueable_rows(
     return candidates[:bounded]
 
 
-def _bounded_limit(limit: int, *, max_value: int = 500) -> int:
-    return max(1, min(int(limit), max_value))
-
-
-def _bounded_offset(offset: int) -> int:
-    return max(int(offset), 0)
-
-
 def _auto_retry_interval_seconds() -> int:
     return max(int(settings.pdf_auto_retry_interval_seconds), 1)
 
@@ -202,18 +153,12 @@ def _event_row(
     user_id: int | None,
     event_type: str,
     status: str | None,
-    source: str | None = None,
-    failure_reason: str | None = None,
-    message: str | None = None,
 ) -> PublicationPdfJobEvent:
     return PublicationPdfJobEvent(
         publication_id=publication_id,
         user_id=user_id,
         event_type=event_type,
         status=status,
-        source=source,
-        failure_reason=failure_reason,
-        message=message,
     )
 
 
@@ -310,247 +255,9 @@ async def _enqueue_rows(
     return queued
 
 
-def _register_task(task: asyncio.Task[None]) -> None:
-    _scheduled_tasks.add(task)
-
-
-def _drop_finished_task(task: asyncio.Task[None]) -> None:
-    _scheduled_tasks.discard(task)
-    try:
-        task.result()
-    except Exception:
-        logger.exception("publications.pdf_queue.task_failed")
-
-
-async def _mark_attempt_started(
-    *,
-    publication_id: int,
-    user_id: int,
-) -> None:
-    session_factory = get_session_factory()
-    async with session_factory() as db_session:
-        job = await db_session.get(PublicationPdfJob, publication_id)
-        if job is None:
-            job = _queued_job(publication_id=publication_id, user_id=user_id)
-            db_session.add(job)
-        job.status = PDF_STATUS_RUNNING
-        job.last_attempt_at = _utcnow()
-        job.attempt_count = int(job.attempt_count) + 1
-        db_session.add(
-            _event_row(
-                publication_id=publication_id,
-                user_id=user_id,
-                event_type=PDF_EVENT_ATTEMPT_STARTED,
-                status=PDF_STATUS_RUNNING,
-            )
-        )
-        await db_session.commit()
-
-
-def _failed_outcome(
-    *,
-    row: PublicationListItem,
-) -> OaResolutionOutcome:
-    return OaResolutionOutcome(
-        publication_id=row.publication_id,
-        doi=None,
-        pdf_url=None,
-        failure_reason=FAILURE_RESOLUTION_EXCEPTION,
-        source=None,
-        used_crossref=False,
-    )
-
-
-async def _fetch_outcome_for_row(
-    *,
-    row: PublicationListItem,
-    request_email: str | None,
-    openalex_api_key: str | None = None,
-    allow_arxiv_lookup: bool = True,
-) -> tuple[OaResolutionOutcome, bool]:
-    pipeline_result = await resolve_publication_pdf_outcome_for_row(
-        row=row,
-        request_email=request_email,
-        openalex_api_key=openalex_api_key,
-        allow_arxiv_lookup=allow_arxiv_lookup,
-    )
-    outcome = pipeline_result.outcome
-    if outcome is not None:
-        return outcome, bool(pipeline_result.arxiv_rate_limited)
-    return _failed_outcome(row=row), bool(pipeline_result.arxiv_rate_limited)
-
-
-def _apply_publication_update(
-    publication: Publication,
-    *,
-    pdf_url: str | None,
-) -> None:
-    if pdf_url and publication.pdf_url != pdf_url:
-        publication.pdf_url = pdf_url
-
-
-def _apply_job_outcome(job: PublicationPdfJob, *, outcome: OaResolutionOutcome) -> None:
-    job.last_source = outcome.source
-    if outcome.pdf_url:
-        job.status = PDF_STATUS_RESOLVED
-        job.resolved_at = _utcnow()
-        job.last_failure_reason = None
-        job.last_failure_detail = None
-        return
-    job.status = PDF_STATUS_FAILED
-    job.last_failure_reason = outcome.failure_reason
-    job.last_failure_detail = outcome.failure_reason
-
-
-def _result_event(outcome: OaResolutionOutcome) -> tuple[str, str]:
-    if outcome.pdf_url:
-        return PDF_EVENT_RESOLVED, PDF_STATUS_RESOLVED
-    return PDF_EVENT_FAILED, PDF_STATUS_FAILED
-
-
-async def _persist_outcome(
-    *,
-    publication_id: int,
-    user_id: int,
-    outcome: OaResolutionOutcome,
-) -> None:
-    session_factory = get_session_factory()
-    async with session_factory() as db_session:
-        publication = await db_session.get(Publication, publication_id)
-        job = await db_session.get(PublicationPdfJob, publication_id)
-        if publication is None or job is None:
-            return
-        _apply_publication_update(publication, pdf_url=outcome.pdf_url)
-        await identifier_service.sync_identifiers_for_publication_resolution(
-            db_session,
-            publication=publication,
-            source=outcome.source,
-        )
-        _apply_job_outcome(job, outcome=outcome)
-        event_type, status = _result_event(outcome)
-        db_session.add(
-            _event_row(
-                publication_id=publication_id,
-                user_id=user_id,
-                event_type=event_type,
-                status=status,
-                source=outcome.source,
-                failure_reason=outcome.failure_reason,
-                message=outcome.failure_reason,
-            )
-        )
-        await db_session.commit()
-
-
-async def _resolve_publication_row(
-    *,
-    user_id: int,
-    request_email: str | None,
-    row: PublicationListItem,
-    openalex_api_key: str | None = None,
-    allow_arxiv_lookup: bool = True,
-) -> bool:
-    from app.services.openalex.client import OpenAlexBudgetExhaustedError
-
-    await _mark_attempt_started(publication_id=row.publication_id, user_id=user_id)
-    try:
-        outcome, arxiv_rate_limited = await _fetch_outcome_for_row(
-            row=row,
-            request_email=request_email,
-            openalex_api_key=openalex_api_key,
-            allow_arxiv_lookup=allow_arxiv_lookup,
-        )
-    except OpenAlexBudgetExhaustedError:
-        # Persist a terminal outcome so jobs do not remain stuck in "running".
-        await _persist_outcome(
-            publication_id=row.publication_id,
-            user_id=user_id,
-            outcome=_failed_outcome(row=row),
-        )
-        # Propagate upward so the batch loop can stop immediately.
-        raise
-    except Exception as exc:  # pragma: no cover - defensive network boundary
-        structured_log(
-            logger,
-            "warning",
-            "publications.pdf_queue.resolve_failed",
-            publication_id=row.publication_id,
-            error=str(exc),
-        )
-        outcome = _failed_outcome(row=row)
-        arxiv_rate_limited = False
-    await _persist_outcome(
-        publication_id=row.publication_id,
-        user_id=user_id,
-        outcome=outcome,
-    )
-    return bool(arxiv_rate_limited)
-
-
-async def _run_resolution_task(
-    *,
-    user_id: int,
-    request_email: str | None,
-    rows: list[PublicationListItem],
-) -> None:
-    from app.services.openalex.client import OpenAlexBudgetExhaustedError
-    from app.services.settings import application as user_settings_service
-
-    # Resolve the best available API key: per-user setting → env var fallback.
-    openalex_api_key: str | None = None
-    try:
-        session_factory = get_session_factory()
-        async with session_factory() as key_session:
-            user_settings = await user_settings_service.get_or_create_settings(key_session, user_id=user_id)
-            openalex_api_key = getattr(user_settings, "openalex_api_key", None) or settings.openalex_api_key
-    except Exception:
-        openalex_api_key = settings.openalex_api_key
-
-    arxiv_lookup_allowed = True
-    for row in rows:
-        try:
-            arxiv_rate_limited = await _resolve_publication_row(
-                user_id=user_id,
-                request_email=request_email,
-                row=row,
-                openalex_api_key=openalex_api_key,
-                allow_arxiv_lookup=arxiv_lookup_allowed,
-            )
-            if arxiv_rate_limited and arxiv_lookup_allowed:
-                arxiv_lookup_allowed = False
-                structured_log(
-                    logger,
-                    "warning",
-                    "pdf_queue.arxiv_batch_disabled",
-                    detail="arXiv temporarily disabled for remaining batch after rate limit",
-                )
-        except OpenAlexBudgetExhaustedError:
-            structured_log(
-                logger,
-                "warning",
-                "pdf_queue.budget_exhausted",
-                detail="Stopping PDF resolution batch — OpenAlex daily budget exhausted",
-            )
-            break
-
-
-def _schedule_rows(
-    *,
-    user_id: int,
-    request_email: str | None,
-    rows: list[PublicationListItem],
-) -> None:
-    if not rows:
-        return
-    task = asyncio.create_task(
-        _run_resolution_task(
-            user_id=user_id,
-            request_email=request_email,
-            rows=rows,
-        )
-    )
-    _register_task(task)
-    task.add_done_callback(_drop_finished_task)
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
 
 
 async def enqueue_missing_pdf_jobs(
@@ -568,7 +275,7 @@ async def enqueue_missing_pdf_jobs(
         rows=queueable,
         force_retry=False,
     )
-    _schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
+    schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
     return [row.publication_id for row in queued_rows]
 
 
@@ -585,69 +292,10 @@ async def enqueue_retry_pdf_job(
         rows=[row],
         force_retry=True,
     )
-    _schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
+    schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
     return bool(queued_rows)
 
 
-def _retry_item_label(display_name: str | None, scholar_id: str | None) -> str:
-    return str(display_name or scholar_id or "unknown")
-
-
-def _retry_item_from_publication(
-    publication: Publication,
-    *,
-    link_row: tuple | None,
-) -> PublicationListItem:
-    if link_row is None:
-        scholar_profile_id = 0
-        scholar_label = "unknown"
-        is_read = True
-        first_seen_at = publication.created_at or _utcnow()
-    else:
-        scholar_profile_id = int(link_row[0])
-        scholar_label = _retry_item_label(link_row[1], link_row[2])
-        is_read = bool(link_row[3])
-        first_seen_at = link_row[4] or publication.created_at or _utcnow()
-    return PublicationListItem(
-        publication_id=int(publication.id),
-        scholar_profile_id=scholar_profile_id,
-        scholar_label=scholar_label,
-        title=publication.title_raw,
-        year=publication.year,
-        citation_count=int(publication.citation_count or 0),
-        venue_text=publication.venue_text,
-        pub_url=publication.pub_url,
-        pdf_url=publication.pdf_url,
-        is_read=is_read,
-        first_seen_at=first_seen_at,
-        is_new_in_latest_run=False,
-    )
-
-
-async def _retry_item_for_publication_id(
-    db_session: AsyncSession,
-    *,
-    publication_id: int,
-) -> PublicationListItem | None:
-    publication = await db_session.get(Publication, publication_id)
-    if publication is None:
-        return None
-    result = await db_session.execute(
-        select(
-            ScholarProfile.id,
-            ScholarProfile.display_name,
-            ScholarProfile.scholar_id,
-            ScholarPublication.is_read,
-            ScholarPublication.created_at,
-        )
-        .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
-        .where(ScholarPublication.publication_id == publication_id)
-        .order_by(ScholarPublication.created_at.asc())
-        .limit(1)
-    )
-    return _retry_item_from_publication(publication, link_row=result.one_or_none())
-
-
 async def enqueue_retry_pdf_job_for_publication_id(
     db_session: AsyncSession,
     *,
@@ -655,7 +303,7 @@ async def enqueue_retry_pdf_job_for_publication_id(
     request_email: str | None,
     publication_id: int,
 ) -> PdfRequeueResult:
-    row = await _retry_item_for_publication_id(
+    row = await retry_item_for_publication_id(
         db_session,
         publication_id=publication_id,
     )
@@ -670,54 +318,6 @@ async def enqueue_retry_pdf_job_for_publication_id(
     return PdfRequeueResult(publication_exists=True, queued=queued)
 
 
-def _queue_candidate_from_publication(publication: Publication) -> PublicationListItem:
-    return PublicationListItem(
-        publication_id=int(publication.id),
-        scholar_profile_id=0,
-        scholar_label="",
-        title=publication.title_raw,
-        year=publication.year,
-        citation_count=int(publication.citation_count or 0),
-        venue_text=publication.venue_text,
-        pub_url=publication.pub_url,
-        pdf_url=publication.pdf_url,
-        is_read=True,
-        first_seen_at=publication.created_at or _utcnow(),
-        is_new_in_latest_run=False,
-    )
-
-
-async def _missing_pdf_candidates(
-    db_session: AsyncSession,
-    *,
-    limit: int,
-) -> list[PublicationListItem]:
-    bounded_limit = max(1, min(int(limit), 5000))
-    now = datetime.now(UTC)
-    cooldown_threshold = now - timedelta(days=7)
-
-    result = await db_session.execute(
-        select(Publication)
-        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
-        .where(Publication.pdf_url.is_(None))
-        .where(
-            or_(
-                PublicationPdfJob.publication_id.is_(None),
-                and_(
-                    PublicationPdfJob.status.notin_([PDF_STATUS_QUEUED, PDF_STATUS_RUNNING]),
-                    or_(
-                        PublicationPdfJob.last_attempt_at.is_(None),
-                        PublicationPdfJob.last_attempt_at < cooldown_threshold,
-                    ),
-                ),
-            )
-        )
-        .order_by(Publication.updated_at.desc(), Publication.id.desc())
-        .limit(bounded_limit)
-    )
-    return [_queue_candidate_from_publication(publication) for publication in result.scalars()]
-
-
 async def enqueue_all_missing_pdf_jobs(
     db_session: AsyncSession,
     *,
@@ -725,230 +325,20 @@ async def enqueue_all_missing_pdf_jobs(
     request_email: str | None,
     limit: int = 1000,
 ) -> PdfBulkQueueResult:
-    candidates = await _missing_pdf_candidates(db_session, limit=limit)
+    candidates = await missing_pdf_candidates(db_session, limit=limit)
     queued_rows = await _enqueue_rows(
         db_session,
         user_id=user_id,
         rows=candidates,
         force_retry=True,
     )
-    _schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
+    schedule_rows(user_id=user_id, request_email=request_email, rows=queued_rows)
     return PdfBulkQueueResult(
         requested_count=len(candidates),
         queued_count=len(queued_rows),
     )
 
 
-def _tracked_queue_select_base(*, status: str | None) -> Select[tuple]:
-    stmt = (
-        select(
-            PublicationPdfJob.publication_id,
-            Publication.title_raw,
-            Publication.pdf_url,
-            PublicationPdfJob.status,
-            PublicationPdfJob.attempt_count,
-            PublicationPdfJob.last_failure_reason,
-            PublicationPdfJob.last_failure_detail,
-            PublicationPdfJob.last_source,
-            PublicationPdfJob.last_requested_by_user_id,
-            User.email,
-            PublicationPdfJob.queued_at,
-            PublicationPdfJob.last_attempt_at,
-            PublicationPdfJob.resolved_at,
-            PublicationPdfJob.updated_at,
-        )
-        .join(Publication, Publication.id == PublicationPdfJob.publication_id)
-        .outerjoin(User, User.id == PublicationPdfJob.last_requested_by_user_id)
-    )
-    if status:
-        stmt = stmt.where(PublicationPdfJob.status == status)
-    return stmt
-
-
-def _tracked_queue_select(*, limit: int, offset: int, status: str | None) -> Select[tuple]:
-    return (
-        _tracked_queue_select_base(status=status)
-        .order_by(PublicationPdfJob.updated_at.desc())
-        .limit(_bounded_limit(limit))
-        .offset(_bounded_offset(offset))
-    )
-
-
-def _untracked_queue_select_base() -> Select[tuple]:
-    return (
-        select(
-            Publication.id,
-            Publication.title_raw,
-            Publication.pdf_url,
-            literal(PDF_STATUS_UNTRACKED),
-            literal(0),
-            literal(None),
-            literal(None),
-            literal(None),
-            literal(None),
-            literal(None),
-            literal(None),
-            literal(None),
-            literal(None),
-            Publication.updated_at,
-        )
-        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
-        .where(Publication.pdf_url.is_(None))
-        .where(PublicationPdfJob.publication_id.is_(None))
-    )
-
-
-def _untracked_queue_select(*, limit: int, offset: int) -> Select[tuple]:
-    return (
-        _untracked_queue_select_base()
-        .order_by(Publication.updated_at.desc(), Publication.id.desc())
-        .limit(_bounded_limit(limit))
-        .offset(_bounded_offset(offset))
-    )
-
-
-def _all_queue_select(*, limit: int, offset: int) -> Select[tuple]:
-    union_stmt = union_all(
-        _tracked_queue_select_base(status=None),
-        _untracked_queue_select_base(),
-    ).subquery()
-    return (
-        select(union_stmt)
-        .order_by(union_stmt.c.updated_at.desc())
-        .limit(_bounded_limit(limit))
-        .offset(_bounded_offset(offset))
-    )
-
-
-def _tracked_queue_count_select(*, status: str | None) -> Select[tuple]:
-    stmt = select(func.count()).select_from(PublicationPdfJob)
-    if status:
-        stmt = stmt.where(PublicationPdfJob.status == status)
-    return stmt
-
-
-def _untracked_queue_count_select() -> Select[tuple]:
-    return (
-        select(func.count())
-        .select_from(Publication)
-        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
-        .where(Publication.pdf_url.is_(None))
-        .where(PublicationPdfJob.publication_id.is_(None))
-    )
-
-
-def _queue_item_from_row(row: tuple) -> PdfQueueListItem:
-    return PdfQueueListItem(
-        publication_id=int(row[0]),
-        title=str(row[1] or ""),
-        pdf_url=row[2],
-        status=str(row[3] or PDF_STATUS_UNTRACKED),
-        attempt_count=int(row[4] or 0),
-        last_failure_reason=row[5],
-        last_failure_detail=row[6],
-        last_source=row[7],
-        requested_by_user_id=int(row[8]) if row[8] is not None else None,
-        requested_by_email=row[9],
-        queued_at=row[10],
-        last_attempt_at=row[11],
-        resolved_at=row[12],
-        updated_at=row[13],
-    )
-
-
-async def _hydrated_queue_items(
-    db_session: AsyncSession,
-    *,
-    rows: list[tuple],
-) -> list[PdfQueueListItem]:
-    items = [_queue_item_from_row(row) for row in rows]
-    return await identifier_service.overlay_pdf_queue_items_with_display_identifiers(
-        db_session,
-        items=items,
-    )
-
-
-async def list_pdf_queue_items(
-    db_session: AsyncSession,
-    *,
-    limit: int = 100,
-    offset: int = 0,
-    status: str | None = None,
-) -> list[PdfQueueListItem]:
-    bounded_limit = _bounded_limit(limit)
-    bounded_offset = _bounded_offset(offset)
-    normalized_status = (status or "").strip().lower() or None
-    if normalized_status == PDF_STATUS_UNTRACKED:
-        result = await db_session.execute(
-            _untracked_queue_select(
-                limit=bounded_limit,
-                offset=bounded_offset,
-            )
-        )
-        return await _hydrated_queue_items(db_session, rows=list(result.all()))
-    if normalized_status is None:
-        result = await db_session.execute(
-            _all_queue_select(
-                limit=bounded_limit,
-                offset=bounded_offset,
-            )
-        )
-        return await _hydrated_queue_items(db_session, rows=list(result.all()))
-    result = await db_session.execute(
-        _tracked_queue_select(
-            limit=bounded_limit,
-            offset=bounded_offset,
-            status=normalized_status,
-        )
-    )
-    return await _hydrated_queue_items(db_session, rows=list(result.all()))
-
-
-async def count_pdf_queue_items(
-    db_session: AsyncSession,
-    *,
-    status: str | None = None,
-) -> int:
-    normalized_status = (status or "").strip().lower() or None
-    if normalized_status == PDF_STATUS_UNTRACKED:
-        result = await db_session.execute(_untracked_queue_count_select())
-        return int(result.scalar_one() or 0)
-    tracked_result = await db_session.execute(_tracked_queue_count_select(status=normalized_status))
-    tracked_count = int(tracked_result.scalar_one() or 0)
-    if normalized_status is not None:
-        return tracked_count
-    untracked_result = await db_session.execute(_untracked_queue_count_select())
-    untracked_count = int(untracked_result.scalar_one() or 0)
-    return tracked_count + untracked_count
-
-
-async def list_pdf_queue_page(
-    db_session: AsyncSession,
-    *,
-    limit: int = 100,
-    offset: int = 0,
-    status: str | None = None,
-) -> PdfQueuePage:
-    bounded_limit = _bounded_limit(limit)
-    bounded_offset = _bounded_offset(offset)
-    items = await list_pdf_queue_items(
-        db_session,
-        limit=bounded_limit,
-        offset=bounded_offset,
-        status=status,
-    )
-    total_count = await count_pdf_queue_items(
-        db_session,
-        status=status,
-    )
-    return PdfQueuePage(
-        items=items,
-        total_count=total_count,
-        limit=bounded_limit,
-        offset=bounded_offset,
-    )
-
-
 async def drain_ready_jobs(
     db_session: AsyncSession,
     *,
diff --git a/app/services/publications/pdf_queue_queries.py b/app/services/publications/pdf_queue_queries.py
new file mode 100644
index 0000000..d8dad1f
--- /dev/null
+++ b/app/services/publications/pdf_queue_queries.py
@@ -0,0 +1,395 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
+
+from sqlalchemy import Select, and_, func, literal, or_, select, union_all
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import (
+    Publication,
+    PublicationPdfJob,
+    ScholarProfile,
+    ScholarPublication,
+    User,
+)
+from app.services.publication_identifiers import application as identifier_service
+from app.services.publication_identifiers.types import DisplayIdentifier
+from app.services.publications.types import PublicationListItem
+
+PDF_STATUS_UNTRACKED = "untracked"
+PDF_STATUS_QUEUED = "queued"
+PDF_STATUS_RUNNING = "running"
+PDF_STATUS_RESOLVED = "resolved"
+PDF_STATUS_FAILED = "failed"
+
+
+def _bounded_limit(limit: int, *, max_value: int = 500) -> int:
+    return max(1, min(int(limit), max_value))
+
+
+def _bounded_offset(offset: int) -> int:
+    return max(int(offset), 0)
+
+
+def _utcnow() -> datetime:
+    return datetime.now(UTC)
+
+
+def _retry_item_label(display_name: str | None, scholar_id: str | None) -> str:
+    return str(display_name or scholar_id or "unknown")
+
+
+def _retry_item_from_publication(
+    publication: Publication,
+    *,
+    link_row: tuple | None,
+) -> PublicationListItem:
+    if link_row is None:
+        scholar_profile_id = 0
+        scholar_label = "unknown"
+        is_read = True
+        first_seen_at = publication.created_at or _utcnow()
+    else:
+        scholar_profile_id = int(link_row[0])
+        scholar_label = _retry_item_label(link_row[1], link_row[2])
+        is_read = bool(link_row[3])
+        first_seen_at = link_row[4] or publication.created_at or _utcnow()
+    return PublicationListItem(
+        publication_id=int(publication.id),
+        scholar_profile_id=scholar_profile_id,
+        scholar_label=scholar_label,
+        title=publication.title_raw,
+        year=publication.year,
+        citation_count=int(publication.citation_count or 0),
+        venue_text=publication.venue_text,
+        pub_url=publication.pub_url,
+        pdf_url=publication.pdf_url,
+        is_read=is_read,
+        first_seen_at=first_seen_at,
+        is_new_in_latest_run=False,
+    )
+
+
+async def retry_item_for_publication_id(
+    db_session: AsyncSession,
+    *,
+    publication_id: int,
+) -> PublicationListItem | None:
+    publication = await db_session.get(Publication, publication_id)
+    if publication is None:
+        return None
+    result = await db_session.execute(
+        select(
+            ScholarProfile.id,
+            ScholarProfile.display_name,
+            ScholarProfile.scholar_id,
+            ScholarPublication.is_read,
+            ScholarPublication.created_at,
+        )
+        .join(ScholarProfile, ScholarProfile.id == ScholarPublication.scholar_profile_id)
+        .where(ScholarPublication.publication_id == publication_id)
+        .order_by(ScholarPublication.created_at.asc())
+        .limit(1)
+    )
+    return _retry_item_from_publication(publication, link_row=result.one_or_none())
+
+
+def _queue_candidate_from_publication(publication: Publication) -> PublicationListItem:
+    return PublicationListItem(
+        publication_id=int(publication.id),
+        scholar_profile_id=0,
+        scholar_label="",
+        title=publication.title_raw,
+        year=publication.year,
+        citation_count=int(publication.citation_count or 0),
+        venue_text=publication.venue_text,
+        pub_url=publication.pub_url,
+        pdf_url=publication.pdf_url,
+        is_read=True,
+        first_seen_at=publication.created_at or _utcnow(),
+        is_new_in_latest_run=False,
+    )
+
+
+async def missing_pdf_candidates(
+    db_session: AsyncSession,
+    *,
+    limit: int,
+) -> list[PublicationListItem]:
+    bounded_limit = max(1, min(int(limit), 5000))
+    now = datetime.now(UTC)
+    cooldown_threshold = now - timedelta(days=7)
+
+    result = await db_session.execute(
+        select(Publication)
+        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
+        .where(Publication.pdf_url.is_(None))
+        .where(
+            or_(
+                PublicationPdfJob.publication_id.is_(None),
+                and_(
+                    PublicationPdfJob.status.notin_([PDF_STATUS_QUEUED, PDF_STATUS_RUNNING]),
+                    or_(
+                        PublicationPdfJob.last_attempt_at.is_(None),
+                        PublicationPdfJob.last_attempt_at < cooldown_threshold,
+                    ),
+                ),
+            )
+        )
+        .order_by(Publication.updated_at.desc(), Publication.id.desc())
+        .limit(bounded_limit)
+    )
+    return [_queue_candidate_from_publication(publication) for publication in result.scalars()]
+
+
+# ---------------------------------------------------------------------------
+# Tracked / untracked queue SQL builders
+# ---------------------------------------------------------------------------
+
+
+def _tracked_queue_select_base(*, status: str | None) -> Select[tuple]:
+    stmt = (
+        select(
+            PublicationPdfJob.publication_id,
+            Publication.title_raw,
+            Publication.pdf_url,
+            PublicationPdfJob.status,
+            PublicationPdfJob.attempt_count,
+            PublicationPdfJob.last_failure_reason,
+            PublicationPdfJob.last_failure_detail,
+            PublicationPdfJob.last_source,
+            PublicationPdfJob.last_requested_by_user_id,
+            User.email,
+            PublicationPdfJob.queued_at,
+            PublicationPdfJob.last_attempt_at,
+            PublicationPdfJob.resolved_at,
+            PublicationPdfJob.updated_at,
+        )
+        .join(Publication, Publication.id == PublicationPdfJob.publication_id)
+        .outerjoin(User, User.id == PublicationPdfJob.last_requested_by_user_id)
+    )
+    if status:
+        stmt = stmt.where(PublicationPdfJob.status == status)
+    return stmt
+
+
+def _tracked_queue_select(*, limit: int, offset: int, status: str | None) -> Select[tuple]:
+    return (
+        _tracked_queue_select_base(status=status)
+        .order_by(PublicationPdfJob.updated_at.desc())
+        .limit(_bounded_limit(limit))
+        .offset(_bounded_offset(offset))
+    )
+
+
+def _untracked_queue_select_base() -> Select[tuple]:
+    return (
+        select(
+            Publication.id,
+            Publication.title_raw,
+            Publication.pdf_url,
+            literal(PDF_STATUS_UNTRACKED),
+            literal(0),
+            literal(None),
+            literal(None),
+            literal(None),
+            literal(None),
+            literal(None),
+            literal(None),
+            literal(None),
+            literal(None),
+            Publication.updated_at,
+        )
+        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
+        .where(Publication.pdf_url.is_(None))
+        .where(PublicationPdfJob.publication_id.is_(None))
+    )
+
+
+def _untracked_queue_select(*, limit: int, offset: int) -> Select[tuple]:
+    return (
+        _untracked_queue_select_base()
+        .order_by(Publication.updated_at.desc(), Publication.id.desc())
+        .limit(_bounded_limit(limit))
+        .offset(_bounded_offset(offset))
+    )
+
+
+def _all_queue_select(*, limit: int, offset: int) -> Select[tuple]:
+    union_stmt = union_all(
+        _tracked_queue_select_base(status=None),
+        _untracked_queue_select_base(),
+    ).subquery()
+    return (
+        select(union_stmt)
+        .order_by(union_stmt.c.updated_at.desc())
+        .limit(_bounded_limit(limit))
+        .offset(_bounded_offset(offset))
+    )
+
+
+def _tracked_queue_count_select(*, status: str | None) -> Select[tuple]:
+    stmt = select(func.count()).select_from(PublicationPdfJob)
+    if status:
+        stmt = stmt.where(PublicationPdfJob.status == status)
+    return stmt
+
+
+def _untracked_queue_count_select() -> Select[tuple]:
+    return (
+        select(func.count())
+        .select_from(Publication)
+        .outerjoin(PublicationPdfJob, PublicationPdfJob.publication_id == Publication.id)
+        .where(Publication.pdf_url.is_(None))
+        .where(PublicationPdfJob.publication_id.is_(None))
+    )
+
+
+# ---------------------------------------------------------------------------
+# Row hydration
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class PdfQueueListItem:
+    publication_id: int
+    title: str
+    pdf_url: str | None
+    status: str
+    attempt_count: int
+    last_failure_reason: str | None
+    last_failure_detail: str | None
+    last_source: str | None
+    requested_by_user_id: int | None
+    requested_by_email: str | None
+    queued_at: datetime | None
+    last_attempt_at: datetime | None
+    resolved_at: datetime | None
+    updated_at: datetime
+    display_identifier: DisplayIdentifier | None = None
+
+
+def _queue_item_from_row(row: tuple) -> PdfQueueListItem:
+    return PdfQueueListItem(
+        publication_id=int(row[0]),
+        title=str(row[1] or ""),
+        pdf_url=row[2],
+        status=str(row[3] or PDF_STATUS_UNTRACKED),
+        attempt_count=int(row[4] or 0),
+        last_failure_reason=row[5],
+        last_failure_detail=row[6],
+        last_source=row[7],
+        requested_by_user_id=int(row[8]) if row[8] is not None else None,
+        requested_by_email=row[9],
+        queued_at=row[10],
+        last_attempt_at=row[11],
+        resolved_at=row[12],
+        updated_at=row[13],
+    )
+
+
+async def _hydrated_queue_items(
+    db_session: AsyncSession,
+    *,
+    rows: list[tuple],
+) -> list[PdfQueueListItem]:
+    items = [_queue_item_from_row(row) for row in rows]
+    return await identifier_service.overlay_pdf_queue_items_with_display_identifiers(
+        db_session,
+        items=items,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Public listing / counting
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class PdfQueuePage:
+    items: list[PdfQueueListItem]
+    total_count: int
+    limit: int
+    offset: int
+
+
+async def list_pdf_queue_items(
+    db_session: AsyncSession,
+    *,
+    limit: int = 100,
+    offset: int = 0,
+    status: str | None = None,
+) -> list[PdfQueueListItem]:
+    bounded_limit = _bounded_limit(limit)
+    bounded_offset = _bounded_offset(offset)
+    normalized_status = (status or "").strip().lower() or None
+    if normalized_status == PDF_STATUS_UNTRACKED:
+        result = await db_session.execute(
+            _untracked_queue_select(
+                limit=bounded_limit,
+                offset=bounded_offset,
+            )
+        )
+        return await _hydrated_queue_items(db_session, rows=list(result.all()))
+    if normalized_status is None:
+        result = await db_session.execute(
+            _all_queue_select(
+                limit=bounded_limit,
+                offset=bounded_offset,
+            )
+        )
+        return await _hydrated_queue_items(db_session, rows=list(result.all()))
+    result = await db_session.execute(
+        _tracked_queue_select(
+            limit=bounded_limit,
+            offset=bounded_offset,
+            status=normalized_status,
+        )
+    )
+    return await _hydrated_queue_items(db_session, rows=list(result.all()))
+
+
+async def count_pdf_queue_items(
+    db_session: AsyncSession,
+    *,
+    status: str | None = None,
+) -> int:
+    normalized_status = (status or "").strip().lower() or None
+    if normalized_status == PDF_STATUS_UNTRACKED:
+        result = await db_session.execute(_untracked_queue_count_select())
+        return int(result.scalar_one() or 0)
+    tracked_result = await db_session.execute(_tracked_queue_count_select(status=normalized_status))
+    tracked_count = int(tracked_result.scalar_one() or 0)
+    if normalized_status is not None:
+        return tracked_count
+    untracked_result = await db_session.execute(_untracked_queue_count_select())
+    untracked_count = int(untracked_result.scalar_one() or 0)
+    return tracked_count + untracked_count
+
+
+async def list_pdf_queue_page(
+    db_session: AsyncSession,
+    *,
+    limit: int = 100,
+    offset: int = 0,
+    status: str | None = None,
+) -> PdfQueuePage:
+    bounded_limit = _bounded_limit(limit)
+    bounded_offset = _bounded_offset(offset)
+    items = await list_pdf_queue_items(
+        db_session,
+        limit=bounded_limit,
+        offset=bounded_offset,
+        status=status,
+    )
+    total_count = await count_pdf_queue_items(
+        db_session,
+        status=status,
+    )
+    return PdfQueuePage(
+        items=items,
+        total_count=total_count,
+        limit=bounded_limit,
+        offset=bounded_offset,
+    )
diff --git a/app/services/publications/pdf_queue_resolution.py b/app/services/publications/pdf_queue_resolution.py
new file mode 100644
index 0000000..d2d0fea
--- /dev/null
+++ b/app/services/publications/pdf_queue_resolution.py
@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+
+from app.db.models import Publication, PublicationPdfJob, PublicationPdfJobEvent
+from app.db.session import get_session_factory
+from app.logging_utils import structured_log
+from app.services.publication_identifiers import application as identifier_service
+from app.services.publications.pdf_resolution_pipeline import (
+    resolve_publication_pdf_outcome_for_row,
+)
+from app.services.publications.types import PublicationListItem
+from app.services.unpaywall.application import (
+    FAILURE_RESOLUTION_EXCEPTION,
+    OaResolutionOutcome,
+)
+from app.settings import settings
+
+PDF_STATUS_QUEUED = "queued"
+PDF_STATUS_RUNNING = "running"
+PDF_STATUS_RESOLVED = "resolved"
+PDF_STATUS_FAILED = "failed"
+
+PDF_EVENT_ATTEMPT_STARTED = "attempt_started"
+PDF_EVENT_RESOLVED = "resolved"
+PDF_EVENT_FAILED = "failed"
+
+logger = logging.getLogger(__name__)
+_scheduled_tasks: set[asyncio.Task[None]] = set()
+
+
+def _utcnow():
+    from datetime import UTC, datetime
+
+    return datetime.now(UTC)
+
+
+def _event_row(
+    *,
+    publication_id: int,
+    user_id: int | None,
+    event_type: str,
+    status: str | None,
+    source: str | None = None,
+    failure_reason: str | None = None,
+    message: str | None = None,
+) -> PublicationPdfJobEvent:
+    return PublicationPdfJobEvent(
+        publication_id=publication_id,
+        user_id=user_id,
+        event_type=event_type,
+        status=status,
+        source=source,
+        failure_reason=failure_reason,
+        message=message,
+    )
+
+
+def _queued_job(
+    *,
+    publication_id: int,
+    user_id: int,
+) -> PublicationPdfJob:
+    now = _utcnow()
+    return PublicationPdfJob(
+        publication_id=publication_id,
+        status=PDF_STATUS_QUEUED,
+        queued_at=now,
+        last_requested_by_user_id=user_id,
+    )
+
+
+async def _mark_attempt_started(
+    *,
+    publication_id: int,
+    user_id: int,
+) -> None:
+    session_factory = get_session_factory()
+    async with session_factory() as db_session:
+        job = await db_session.get(PublicationPdfJob, publication_id)
+        if job is None:
+            job = _queued_job(publication_id=publication_id, user_id=user_id)
+            db_session.add(job)
+        job.status = PDF_STATUS_RUNNING
+        job.last_attempt_at = _utcnow()
+        job.attempt_count = int(job.attempt_count) + 1
+        db_session.add(
+            _event_row(
+                publication_id=publication_id,
+                user_id=user_id,
+                event_type=PDF_EVENT_ATTEMPT_STARTED,
+                status=PDF_STATUS_RUNNING,
+            )
+        )
+        await db_session.commit()
+
+
+def _failed_outcome(
+    *,
+    row: PublicationListItem,
+) -> OaResolutionOutcome:
+    return OaResolutionOutcome(
+        publication_id=row.publication_id,
+        doi=None,
+        pdf_url=None,
+        failure_reason=FAILURE_RESOLUTION_EXCEPTION,
+        source=None,
+        used_crossref=False,
+    )
+
+
+async def _fetch_outcome_for_row(
+    *,
+    row: PublicationListItem,
+    request_email: str | None,
+    openalex_api_key: str | None = None,
+    allow_arxiv_lookup: bool = True,
+) -> tuple[OaResolutionOutcome, bool]:
+    pipeline_result = await resolve_publication_pdf_outcome_for_row(
+        row=row,
+        request_email=request_email,
+        openalex_api_key=openalex_api_key,
+        allow_arxiv_lookup=allow_arxiv_lookup,
+    )
+    outcome = pipeline_result.outcome
+    if outcome is not None:
+        return outcome, bool(pipeline_result.arxiv_rate_limited)
+    return _failed_outcome(row=row), bool(pipeline_result.arxiv_rate_limited)
+
+
+def _apply_publication_update(
+    publication: Publication,
+    *,
+    pdf_url: str | None,
+) -> None:
+    if pdf_url and publication.pdf_url != pdf_url:
+        publication.pdf_url = pdf_url
+
+
+def _apply_job_outcome(job: PublicationPdfJob, *, outcome: OaResolutionOutcome) -> None:
+    job.last_source = outcome.source
+    if outcome.pdf_url:
+        job.status = PDF_STATUS_RESOLVED
+        job.resolved_at = _utcnow()
+        job.last_failure_reason = None
+        job.last_failure_detail = None
+        return
+    job.status = PDF_STATUS_FAILED
+    job.last_failure_reason = outcome.failure_reason
+    job.last_failure_detail = outcome.failure_reason
+
+
+def _result_event(outcome: OaResolutionOutcome) -> tuple[str, str]:
+    if outcome.pdf_url:
+        return PDF_EVENT_RESOLVED, PDF_STATUS_RESOLVED
+    return PDF_EVENT_FAILED, PDF_STATUS_FAILED
+
+
+async def _persist_outcome(
+    *,
+    publication_id: int,
+    user_id: int,
+    outcome: OaResolutionOutcome,
+) -> None:
+    session_factory = get_session_factory()
+    async with session_factory() as db_session:
+        publication = await db_session.get(Publication, publication_id)
+        job = await db_session.get(PublicationPdfJob, publication_id)
+        if publication is None or job is None:
+            return
+        _apply_publication_update(publication, pdf_url=outcome.pdf_url)
+        await identifier_service.sync_identifiers_for_publication_resolution(
+            db_session,
+            publication=publication,
+            source=outcome.source,
+        )
+        _apply_job_outcome(job, outcome=outcome)
+        event_type, status = _result_event(outcome)
+        db_session.add(
+            _event_row(
+                publication_id=publication_id,
+                user_id=user_id,
+                event_type=event_type,
+                status=status,
+                source=outcome.source,
+                failure_reason=outcome.failure_reason,
+                message=outcome.failure_reason,
+            )
+        )
+        await db_session.commit()
+
+
+async def _resolve_publication_row(
+    *,
+    user_id: int,
+    request_email: str | None,
+    row: PublicationListItem,
+    openalex_api_key: str | None = None,
+    allow_arxiv_lookup: bool = True,
+) -> bool:
+    from app.services.openalex.client import OpenAlexBudgetExhaustedError
+
+    await _mark_attempt_started(publication_id=row.publication_id, user_id=user_id)
+    try:
+        outcome, arxiv_rate_limited = await _fetch_outcome_for_row(
+            row=row,
+            request_email=request_email,
+            openalex_api_key=openalex_api_key,
+            allow_arxiv_lookup=allow_arxiv_lookup,
+        )
+    except OpenAlexBudgetExhaustedError:
+        await _persist_outcome(
+            publication_id=row.publication_id,
+            user_id=user_id,
+            outcome=_failed_outcome(row=row),
+        )
+        raise
+    except Exception as exc:  # pragma: no cover - defensive network boundary
+        structured_log(
+            logger,
+            "warning",
+            "publications.pdf_queue.resolve_failed",
+            publication_id=row.publication_id,
+            error=str(exc),
+        )
+        outcome = _failed_outcome(row=row)
+        arxiv_rate_limited = False
+    await _persist_outcome(
+        publication_id=row.publication_id,
+        user_id=user_id,
+        outcome=outcome,
+    )
+    return bool(arxiv_rate_limited)
+
+
+async def _run_resolution_task(
+    *,
+    user_id: int,
+    request_email: str | None,
+    rows: list[PublicationListItem],
+) -> None:
+    from app.services.openalex.client import OpenAlexBudgetExhaustedError
+    from app.services.settings import application as user_settings_service
+
+    openalex_api_key: str | None = None
+    try:
+        session_factory = get_session_factory()
+        async with session_factory() as key_session:
+            user_settings = await user_settings_service.get_or_create_settings(key_session, user_id=user_id)
+            openalex_api_key = getattr(user_settings, "openalex_api_key", None) or settings.openalex_api_key
+    except Exception:
+        openalex_api_key = settings.openalex_api_key
+
+    arxiv_lookup_allowed = True
+    for row in rows:
+        try:
+            arxiv_rate_limited = await _resolve_publication_row(
+                user_id=user_id,
+                request_email=request_email,
+                row=row,
+                openalex_api_key=openalex_api_key,
+                allow_arxiv_lookup=arxiv_lookup_allowed,
+            )
+            if arxiv_rate_limited and arxiv_lookup_allowed:
+                arxiv_lookup_allowed = False
+                structured_log(
+                    logger,
+                    "warning",
+                    "pdf_queue.arxiv_batch_disabled",
+                    detail="arXiv temporarily disabled for remaining batch after rate limit",
+                )
+        except OpenAlexBudgetExhaustedError:
+            structured_log(
+                logger,
+                "warning",
+                "pdf_queue.budget_exhausted",
+                detail="Stopping PDF resolution batch — OpenAlex daily budget exhausted",
+            )
+            break
+
+
+def _register_task(task: asyncio.Task[None]) -> None:
+    _scheduled_tasks.add(task)
+
+
+def _drop_finished_task(task: asyncio.Task[None]) -> None:
+    _scheduled_tasks.discard(task)
+    try:
+        task.result()
+    except Exception:
+        logger.exception("publications.pdf_queue.task_failed")
+
+
+def schedule_rows(
+    *,
+    user_id: int,
+    request_email: str | None,
+    rows: list[PublicationListItem],
+) -> None:
+    if not rows:
+        return
+    task = asyncio.create_task(
+        _run_resolution_task(
+            user_id=user_id,
+            request_email=request_email,
+            rows=rows,
+        )
+    )
+    _register_task(task)
+    task.add_done_callback(_drop_finished_task)
diff --git a/app/services/scholars/application.py b/app/services/scholars/application.py
index 49f362a..894c371 100644
--- a/app/services/scholars/application.py
+++ b/app/services/scholars/application.py
@@ -1,52 +1,17 @@
 from __future__ import annotations
 
-import asyncio
-import logging
 import os
-import random
-from dataclasses import replace
-from datetime import UTC, datetime, timedelta
-from typing import Any
 from uuid import uuid4
 
-from sqlalchemy import delete, func, select, text
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.db.models import AuthorSearchCacheEntry, AuthorSearchRuntimeState, ScholarProfile
-from app.logging_utils import structured_log
-from app.services.scholar.parser import (
-    ParsedAuthorSearchPage,
-    ParseState,
-    ScholarParserError,
-    parse_author_search_page,
-    parse_profile_page,
-)
+from app.db.models import ScholarProfile
+from app.services.scholar.parser import ScholarParserError, parse_profile_page
 from app.services.scholar.source import ScholarSource
-from app.services.scholars.constants import (
-    ALLOWED_IMAGE_UPLOAD_CONTENT_TYPES,
-    AUTHOR_SEARCH_LOCK_KEY,
-    AUTHOR_SEARCH_LOCK_NAMESPACE,
-    AUTHOR_SEARCH_RUNTIME_STATE_KEY,
-    DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS,
-    DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES,
-    DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD,
-    DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD,
-    DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS,
-    DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS,
-    DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS,
-    DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD,
-    MAX_AUTHOR_SEARCH_LIMIT,
-    SEARCH_CACHED_BLOCK_REASON,
-    SEARCH_COOLDOWN_REASON,
-    SEARCH_DISABLED_REASON,
-)
+from app.services.scholars.author_search import search_author_candidates
+from app.services.scholars.constants import ALLOWED_IMAGE_UPLOAD_CONTENT_TYPES
 from app.services.scholars.exceptions import ScholarServiceError
-from app.services.scholars.search_hints import (
-    _merge_warnings,
-    _policy_blocked_author_search_result,
-    _trim_author_search_result,
-)
 from app.services.scholars.uploads import (
     _ensure_upload_root,
     _resolve_upload_path,
@@ -58,280 +23,22 @@ from app.services.scholars.validators import (
     validate_scholar_id,
 )
 
-logger = logging.getLogger(__name__)
-
-
-async def _acquire_author_search_lock(db_session: AsyncSession) -> None:
-    await db_session.execute(
-        text("SELECT pg_advisory_xact_lock(:namespace, :lock_key)"),
-        {
-            "namespace": AUTHOR_SEARCH_LOCK_NAMESPACE,
-            "lock_key": AUTHOR_SEARCH_LOCK_KEY,
-        },
-    )
-
-
-async def _load_runtime_state_for_update(
-    db_session: AsyncSession,
-) -> AuthorSearchRuntimeState:
-    result = await db_session.execute(
-        select(AuthorSearchRuntimeState)
-        .where(AuthorSearchRuntimeState.state_key == AUTHOR_SEARCH_RUNTIME_STATE_KEY)
-        .with_for_update()
-    )
-    state = result.scalar_one_or_none()
-    if state is not None:
-        return state
-
-    state = AuthorSearchRuntimeState(state_key=AUTHOR_SEARCH_RUNTIME_STATE_KEY)
-    db_session.add(state)
-    await db_session.flush()
-    return state
-
-
-def _serialize_parsed_author_search_page(parsed: ParsedAuthorSearchPage) -> dict:
-    return {
-        "state": parsed.state.value,
-        "state_reason": parsed.state_reason,
-        "marker_counts": {str(key): int(value) for key, value in parsed.marker_counts.items()},
-        "warnings": [str(value) for value in parsed.warnings],
-        "candidates": [
-            {
-                "scholar_id": candidate.scholar_id,
-                "display_name": candidate.display_name,
-                "affiliation": candidate.affiliation,
-                "email_domain": candidate.email_domain,
-                "cited_by_count": candidate.cited_by_count,
-                "interests": [str(interest) for interest in candidate.interests],
-                "profile_url": candidate.profile_url,
-                "profile_image_url": candidate.profile_image_url,
-            }
-            for candidate in parsed.candidates
-        ],
-    }
-
-
-def _payload_state(payload: dict[str, object]) -> ParseState | None:
-    state_raw = str(payload.get("state", "")).strip()
-    try:
-        return ParseState(state_raw)
-    except ValueError:
-        return None
-
-
-def _payload_marker_counts(payload: dict[str, object]) -> dict[str, int]:
-    marker_counts_payload = payload.get("marker_counts")
-    if not isinstance(marker_counts_payload, dict):
-        return {}
-    parsed: dict[str, int] = {}
-    for key, value in marker_counts_payload.items():
-        try:
-            parsed[str(key)] = int(value)
-        except (TypeError, ValueError):
-            continue
-    return parsed
-
-
-def _payload_warnings(payload: dict[str, object]) -> list[str]:
-    warnings_payload = payload.get("warnings")
-    if not isinstance(warnings_payload, list):
-        return []
-    return [str(value) for value in warnings_payload if isinstance(value, str)]
-
-
-def _parse_optional_string(value: object) -> str | None:
-    if value is None:
-        return None
-    normalized = str(value).strip()
-    return normalized or None
-
-
-def _parse_optional_int(value: object) -> int | None:
-    if isinstance(value, int):
-        return value
-    if isinstance(value, str) and value.strip():
-        try:
-            return int(value)
-        except ValueError:
-            return None
-    return None
-
-
-def _normalize_interests(value: object) -> list[str]:
-    if not isinstance(value, list):
-        return []
-    return [str(item) for item in value if isinstance(item, str)]
-
-
-def _deserialize_candidate_payload(value: object) -> dict[str, object] | None:
-    if not isinstance(value, dict):
-        return None
-    scholar_id = str(value.get("scholar_id", "")).strip()
-    display_name = str(value.get("display_name", "")).strip()
-    profile_url = str(value.get("profile_url", "")).strip()
-    if not scholar_id or not display_name or not profile_url:
-        return None
-    return {
-        "scholar_id": scholar_id,
-        "display_name": display_name,
-        "affiliation": _parse_optional_string(value.get("affiliation")),
-        "email_domain": _parse_optional_string(value.get("email_domain")),
-        "cited_by_count": _parse_optional_int(value.get("cited_by_count")),
-        "interests": _normalize_interests(value.get("interests")),
-        "profile_url": profile_url,
-        "profile_image_url": _parse_optional_string(value.get("profile_image_url")),
-    }
-
-
-def _deserialize_candidates(payload: dict[str, object]) -> list[dict[str, Any]]:
-    candidates_payload = payload.get("candidates")
-    if not isinstance(candidates_payload, list):
-        return []
-    normalized: list[dict[str, Any]] = []
-    for value in candidates_payload:
-        candidate = _deserialize_candidate_payload(value)
-        if candidate is not None:
-            normalized.append(candidate)
-    return normalized
-
-
-def _deserialize_parsed_author_search_page(payload: object) -> ParsedAuthorSearchPage | None:
-    if not isinstance(payload, dict):
-        return None
-
-    state = _payload_state(payload)
-    if state is None:
-        return None
-
-    marker_counts = _payload_marker_counts(payload)
-    warnings = _payload_warnings(payload)
-    from app.services.scholar.parser import ScholarSearchCandidate
-
-    normalized_candidates = _deserialize_candidates(payload)
-
-    return ParsedAuthorSearchPage(
-        state=state,
-        state_reason=str(payload.get("state_reason", "")).strip() or "unknown",
-        candidates=[
-            ScholarSearchCandidate(
-                scholar_id=item["scholar_id"],
-                display_name=item["display_name"],
-                affiliation=item["affiliation"],
-                email_domain=item["email_domain"],
-                cited_by_count=item["cited_by_count"],
-                interests=item["interests"],
-                profile_url=item["profile_url"],
-                profile_image_url=item["profile_image_url"],
-            )
-            for item in normalized_candidates
-        ],
-        marker_counts=marker_counts,
-        warnings=warnings,
-    )
-
-
-async def _cache_get_author_search_result(
-    db_session: AsyncSession,
-    *,
-    query_key: str,
-    now_utc: datetime,
-) -> ParsedAuthorSearchPage | None:
-    result = await db_session.execute(
-        select(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key == query_key)
-    )
-    entry = result.scalar_one_or_none()
-    if entry is None:
-        return None
-    expires_at = entry.expires_at
-    if expires_at.tzinfo is None:
-        expires_at = expires_at.replace(tzinfo=UTC)
-    if expires_at <= now_utc:
-        await db_session.delete(entry)
-        return None
-    parsed = _deserialize_parsed_author_search_page(entry.payload)
-    if parsed is None:
-        await db_session.delete(entry)
-        return None
-    return parsed
-
-
-async def _cache_set_author_search_result(
-    db_session: AsyncSession,
-    *,
-    query_key: str,
-    parsed: ParsedAuthorSearchPage,
-    ttl_seconds: float,
-    max_entries: int,
-    now_utc: datetime,
-) -> None:
-    ttl = max(float(ttl_seconds), 0.0)
-    existing_result = await db_session.execute(
-        select(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key == query_key)
-    )
-    existing = existing_result.scalar_one_or_none()
-
-    if ttl <= 0.0:
-        if existing is not None:
-            await db_session.delete(existing)
-        return
-
-    expires_at = now_utc + timedelta(seconds=ttl)
-    payload = _serialize_parsed_author_search_page(parsed)
-    if existing is None:
-        db_session.add(
-            AuthorSearchCacheEntry(
-                query_key=query_key,
-                payload=payload,
-                expires_at=expires_at,
-                cached_at=now_utc,
-                updated_at=now_utc,
-            )
-        )
-    else:
-        existing.payload = payload
-        existing.expires_at = expires_at
-        existing.cached_at = now_utc
-        existing.updated_at = now_utc
-
-    await _prune_author_search_cache(db_session, now_utc=now_utc, max_entries=max_entries)
-
-
-async def _prune_author_search_cache(
-    db_session: AsyncSession,
-    *,
-    now_utc: datetime,
-    max_entries: int,
-) -> None:
-    await db_session.execute(delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.expires_at <= now_utc))
-    bounded_max_entries = max(1, int(max_entries))
-    count_result = await db_session.execute(select(func.count()).select_from(AuthorSearchCacheEntry))
-    entry_count = int(count_result.scalar_one() or 0)
-    overflow = max(0, entry_count - bounded_max_entries)
-    if overflow <= 0:
-        return
-    stale_keys_result = await db_session.execute(
-        select(AuthorSearchCacheEntry.query_key).order_by(AuthorSearchCacheEntry.cached_at.asc()).limit(overflow)
-    )
-    stale_keys = [str(row[0]) for row in stale_keys_result.all()]
-    if stale_keys:
-        await db_session.execute(delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key.in_(stale_keys)))
-
-
-def _is_author_search_block_state(parsed: ParsedAuthorSearchPage) -> bool:
-    return parsed.state == ParseState.BLOCKED_OR_CAPTCHA
-
-
-def _author_search_cooldown_remaining_seconds(
-    runtime_state: AuthorSearchRuntimeState,
-    now_utc: datetime,
-) -> int:
-    cooldown_until = runtime_state.cooldown_until
-    if cooldown_until is None:
-        return 0
-    if cooldown_until.tzinfo is None:
-        cooldown_until = cooldown_until.replace(tzinfo=UTC)
-    remaining_seconds = int((cooldown_until - now_utc).total_seconds())
-    return max(0, remaining_seconds)
+__all__ = [
+    "ScholarServiceError",
+    "clear_profile_image_customization",
+    "create_scholar_for_user",
+    "delete_scholar",
+    "get_user_scholar_by_id",
+    "hydrate_profile_metadata",
+    "list_scholars_for_user",
+    "normalize_display_name",
+    "normalize_profile_image_url",
+    "search_author_candidates",
+    "set_profile_image_override_url",
+    "set_profile_image_upload",
+    "toggle_scholar_enabled",
+    "validate_scholar_id",
+]
 
 
 async def list_scholars_for_user(
@@ -339,6 +46,8 @@ async def list_scholars_for_user(
     *,
     user_id: int,
 ) -> list[ScholarProfile]:
+    from sqlalchemy import select
+
     result = await db_session.execute(
         select(ScholarProfile)
         .where(ScholarProfile.user_id == user_id)
@@ -377,6 +86,8 @@ async def get_user_scholar_by_id(
     user_id: int,
     scholar_profile_id: int,
 ) -> ScholarProfile | None:
+    from sqlalchemy import select
+
     result = await db_session.execute(
         select(ScholarProfile).where(
             ScholarProfile.id == scholar_profile_id,
@@ -411,492 +122,6 @@ async def delete_scholar(
     await db_session.commit()
 
 
-def _normalize_author_search_inputs(query: str, limit: int) -> tuple[str, int, str]:
-    normalized_query = query.strip()
-    if len(normalized_query) < 2:
-        raise ScholarServiceError("Search query must be at least 2 characters.")
-    bounded_limit = max(1, min(int(limit), MAX_AUTHOR_SEARCH_LIMIT))
-    return normalized_query, bounded_limit, normalized_query.casefold()
-
-
-def _disabled_search_result(*, normalized_query: str, bounded_limit: int) -> ParsedAuthorSearchPage:
-    structured_log(
-        logger,
-        "warning",
-        "scholar_search.disabled_by_configuration",
-        query=normalized_query,
-    )
-    return _policy_blocked_author_search_result(
-        reason=SEARCH_DISABLED_REASON,
-        warning_codes=["author_search_disabled_by_configuration"],
-        limit=bounded_limit,
-    )
-
-
-def _normalize_runtime_cooldown_state(
-    runtime_state: AuthorSearchRuntimeState,
-    *,
-    now_utc: datetime,
-) -> bool:
-    if runtime_state.cooldown_until is None:
-        return False
-    cooldown_until = runtime_state.cooldown_until
-    updated = False
-    if cooldown_until.tzinfo is None:
-        cooldown_until = cooldown_until.replace(tzinfo=UTC)
-        runtime_state.cooldown_until = cooldown_until
-        updated = True
-    if now_utc < cooldown_until:
-        return updated
-    structured_log(
-        logger,
-        "info",
-        "scholar_search.cooldown_expired",
-        cooldown_until_utc=cooldown_until.isoformat(),
-    )
-    runtime_state.cooldown_until = None
-    runtime_state.cooldown_rejection_count = 0
-    runtime_state.cooldown_alert_emitted = False
-    return True
-
-
-def _cooldown_warning_codes(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    cooldown_remaining_seconds: int,
-) -> list[str]:
-    warning_codes = [
-        "author_search_cooldown_active",
-        f"author_search_cooldown_remaining_{cooldown_remaining_seconds}s",
-    ]
-    if bool(runtime_state.cooldown_alert_emitted):
-        warning_codes.append("author_search_cooldown_alert_threshold_exceeded")
-    return warning_codes
-
-
-def _emit_cooldown_threshold_alert(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    normalized_query: str,
-    cooldown_rejection_alert_threshold: int,
-) -> bool:
-    runtime_state.cooldown_rejection_count = int(runtime_state.cooldown_rejection_count) + 1
-    threshold = max(1, int(cooldown_rejection_alert_threshold))
-    if int(runtime_state.cooldown_rejection_count) < threshold:
-        return True
-    if bool(runtime_state.cooldown_alert_emitted):
-        return True
-    structured_log(
-        logger,
-        "error",
-        "scholar_search.cooldown_rejection_threshold_exceeded",
-        query=normalized_query,
-        cooldown_rejection_count=int(runtime_state.cooldown_rejection_count),
-        threshold=threshold,
-        cooldown_until_utc=runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
-    )
-    runtime_state.cooldown_alert_emitted = True
-    return True
-
-
-def _cooldown_block_result(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    normalized_query: str,
-    bounded_limit: int,
-    cooldown_rejection_alert_threshold: int,
-    cooldown_remaining_seconds: int,
-) -> ParsedAuthorSearchPage:
-    _emit_cooldown_threshold_alert(
-        runtime_state=runtime_state,
-        normalized_query=normalized_query,
-        cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
-    )
-    structured_log(
-        logger,
-        "warning",
-        "scholar_search.cooldown_active",
-        query=normalized_query,
-        cooldown_remaining_seconds=cooldown_remaining_seconds,
-        cooldown_until_utc=runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
-    )
-    return _policy_blocked_author_search_result(
-        reason=SEARCH_COOLDOWN_REASON,
-        warning_codes=_cooldown_warning_codes(
-            runtime_state=runtime_state,
-            cooldown_remaining_seconds=cooldown_remaining_seconds,
-        ),
-        limit=bounded_limit,
-    )
-
-
-async def _cache_hit_result(
-    db_session: AsyncSession,
-    *,
-    query_key: str,
-    now_utc: datetime,
-    normalized_query: str,
-    bounded_limit: int,
-) -> ParsedAuthorSearchPage | None:
-    cached = await _cache_get_author_search_result(
-        db_session,
-        query_key=query_key,
-        now_utc=now_utc,
-    )
-    if cached is None:
-        return None
-    structured_log(
-        logger,
-        "info",
-        "scholar_search.cache_hit",
-        query=normalized_query,
-        state=cached.state.value,
-        state_reason=cached.state_reason,
-    )
-    state_reason_override = SEARCH_CACHED_BLOCK_REASON if _is_author_search_block_state(cached) else None
-    return _trim_author_search_result(
-        cached,
-        limit=bounded_limit,
-        extra_warnings=["author_search_served_from_cache"],
-        state_reason_override=state_reason_override,
-    )
-
-
-def _throttle_sleep_seconds(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    now_utc: datetime,
-    min_interval_seconds: float,
-    interval_jitter_seconds: float,
-) -> tuple[float, bool]:
-    updated = False
-    if runtime_state.last_live_request_at is None:
-        enforced_wait_seconds = 0.0
-    else:
-        last_live_request_at = runtime_state.last_live_request_at
-        if last_live_request_at.tzinfo is None:
-            last_live_request_at = last_live_request_at.replace(tzinfo=UTC)
-            runtime_state.last_live_request_at = last_live_request_at
-            updated = True
-        enforced_wait_seconds = (
-            last_live_request_at + timedelta(seconds=max(float(min_interval_seconds), 0.0)) - now_utc
-        ).total_seconds()
-    jitter_seconds = random.uniform(0.0, max(float(interval_jitter_seconds), 0.0))
-    return max(0.0, float(enforced_wait_seconds)) + jitter_seconds, updated
-
-
-async def _wait_for_author_search_throttle(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    normalized_query: str,
-    now_utc: datetime,
-    min_interval_seconds: float,
-    interval_jitter_seconds: float,
-) -> bool:
-    sleep_seconds, updated = _throttle_sleep_seconds(
-        runtime_state=runtime_state,
-        now_utc=now_utc,
-        min_interval_seconds=min_interval_seconds,
-        interval_jitter_seconds=interval_jitter_seconds,
-    )
-    if sleep_seconds <= 0.0:
-        return updated
-    structured_log(
-        logger,
-        "info",
-        "scholar_search.throttle_wait",
-        query=normalized_query,
-        sleep_seconds=round(sleep_seconds, 3),
-    )
-    await asyncio.sleep(sleep_seconds)
-    return True
-
-
-async def _fetch_author_search_with_retries(
-    *,
-    source: ScholarSource,
-    normalized_query: str,
-    network_error_retries: int,
-    retry_backoff_seconds: float,
-) -> tuple[ParsedAuthorSearchPage, int, list[str]]:
-    max_attempts = max(1, int(network_error_retries) + 1)
-    parsed: ParsedAuthorSearchPage | None = None
-    retry_warnings: list[str] = []
-    retry_scheduled_count = 0
-    for attempt_index in range(max_attempts):
-        fetch_result = await source.fetch_author_search_html(normalized_query, start=0)
-        try:
-            parsed = parse_author_search_page(fetch_result)
-        except ScholarParserError as exc:
-            parsed = ParsedAuthorSearchPage(
-                state=ParseState.LAYOUT_CHANGED,
-                state_reason=exc.code,
-                candidates=[],
-                marker_counts={},
-                warnings=[exc.code],
-            )
-        if parsed.state != ParseState.NETWORK_ERROR or attempt_index >= max_attempts - 1:
-            break
-        retry_warnings.append("network_retry_scheduled_for_author_search")
-        retry_scheduled_count += 1
-        retry_sleep_seconds = max(float(retry_backoff_seconds), 0.0) * (2**attempt_index)
-        if retry_sleep_seconds > 0:
-            await asyncio.sleep(retry_sleep_seconds)
-    if parsed is None:
-        raise ScholarServiceError("Unable to complete scholar author search.")
-    return parsed, retry_scheduled_count, retry_warnings
-
-
-def _with_retry_warnings(
-    parsed: ParsedAuthorSearchPage,
-    *,
-    retry_warnings: list[str],
-    retry_scheduled_count: int,
-    retry_alert_threshold: int,
-    normalized_query: str,
-) -> ParsedAuthorSearchPage:
-    merged = replace(parsed, warnings=_merge_warnings(parsed.warnings, retry_warnings))
-    threshold = max(1, int(retry_alert_threshold))
-    if retry_scheduled_count < threshold:
-        return merged
-    structured_log(
-        logger,
-        "warning",
-        "scholar_search.retry_threshold_exceeded",
-        query=normalized_query,
-        retry_scheduled_count=retry_scheduled_count,
-        threshold=threshold,
-        final_state=merged.state.value,
-        final_state_reason=merged.state_reason,
-    )
-    return replace(
-        merged,
-        warnings=_merge_warnings(
-            merged.warnings,
-            [f"author_search_retry_threshold_exceeded_{retry_scheduled_count}"],
-        ),
-    )
-
-
-def _apply_block_circuit_breaker(
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    merged_parsed: ParsedAuthorSearchPage,
-    cooldown_block_threshold: int,
-    cooldown_seconds: int,
-    normalized_query: str,
-) -> ParsedAuthorSearchPage:
-    if not _is_author_search_block_state(merged_parsed):
-        runtime_state.consecutive_blocked_count = 0
-        return merged_parsed
-    runtime_state.consecutive_blocked_count = int(runtime_state.consecutive_blocked_count) + 1
-    structured_log(
-        logger,
-        "warning",
-        "scholar_search.block_detected",
-        query=normalized_query,
-        state_reason=merged_parsed.state_reason,
-        consecutive_blocked_count=int(runtime_state.consecutive_blocked_count),
-    )
-    if int(runtime_state.consecutive_blocked_count) < max(1, int(cooldown_block_threshold)):
-        return merged_parsed
-    runtime_state.cooldown_until = datetime.now(UTC) + timedelta(seconds=max(60, int(cooldown_seconds)))
-    runtime_state.consecutive_blocked_count = 0
-    runtime_state.cooldown_rejection_count = 0
-    runtime_state.cooldown_alert_emitted = False
-    structured_log(
-        logger,
-        "error",
-        "scholar_search.cooldown_activated",
-        query=normalized_query,
-        cooldown_until_utc=runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
-    )
-    return replace(
-        merged_parsed,
-        warnings=_merge_warnings(merged_parsed.warnings, ["author_search_circuit_breaker_armed"]),
-    )
-
-
-def _resolve_author_search_cache_ttl_seconds(
-    *,
-    merged_parsed: ParsedAuthorSearchPage,
-    blocked_cache_ttl_seconds: int,
-    cache_ttl_seconds: int,
-) -> int:
-    if _is_author_search_block_state(merged_parsed):
-        return min(max(1, int(blocked_cache_ttl_seconds)), max(1, int(cache_ttl_seconds)))
-    return max(1, int(cache_ttl_seconds))
-
-
-async def _load_locked_runtime_state(
-    db_session: AsyncSession,
-) -> AuthorSearchRuntimeState:
-    await _acquire_author_search_lock(db_session)
-    return await _load_runtime_state_for_update(db_session)
-
-
-async def _cooldown_or_cache_result(
-    db_session: AsyncSession,
-    *,
-    runtime_state: AuthorSearchRuntimeState,
-    query_key: str,
-    normalized_query: str,
-    bounded_limit: int,
-    cooldown_rejection_alert_threshold: int,
-) -> tuple[ParsedAuthorSearchPage | None, bool]:
-    runtime_state_updated = _normalize_runtime_cooldown_state(
-        runtime_state,
-        now_utc=datetime.now(UTC),
-    )
-    cooldown_remaining_seconds = _author_search_cooldown_remaining_seconds(
-        runtime_state,
-        datetime.now(UTC),
-    )
-    if cooldown_remaining_seconds > 0:
-        return (
-            _cooldown_block_result(
-                runtime_state=runtime_state,
-                normalized_query=normalized_query,
-                bounded_limit=bounded_limit,
-                cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
-                cooldown_remaining_seconds=cooldown_remaining_seconds,
-            ),
-            True,
-        )
-    cached_result = await _cache_hit_result(
-        db_session,
-        query_key=query_key,
-        now_utc=datetime.now(UTC),
-        normalized_query=normalized_query,
-        bounded_limit=bounded_limit,
-    )
-    return cached_result, runtime_state_updated
-
-
-async def _perform_live_author_search(
-    db_session: AsyncSession,
-    *,
-    source: ScholarSource,
-    runtime_state: AuthorSearchRuntimeState,
-    normalized_query: str,
-    query_key: str,
-    network_error_retries: int,
-    retry_backoff_seconds: float,
-    min_interval_seconds: float,
-    interval_jitter_seconds: float,
-    retry_alert_threshold: int,
-    cooldown_block_threshold: int,
-    cooldown_seconds: int,
-    blocked_cache_ttl_seconds: int,
-    cache_ttl_seconds: int,
-    cache_max_entries: int,
-) -> tuple[ParsedAuthorSearchPage, bool]:
-    await _wait_for_author_search_throttle(
-        runtime_state=runtime_state,
-        normalized_query=normalized_query,
-        now_utc=datetime.now(UTC),
-        min_interval_seconds=min_interval_seconds,
-        interval_jitter_seconds=interval_jitter_seconds,
-    )
-    parsed, retry_count, retry_warnings = await _fetch_author_search_with_retries(
-        source=source,
-        normalized_query=normalized_query,
-        network_error_retries=network_error_retries,
-        retry_backoff_seconds=retry_backoff_seconds,
-    )
-    runtime_state.last_live_request_at = datetime.now(UTC)
-    merged = _with_retry_warnings(
-        parsed,
-        retry_warnings=retry_warnings,
-        retry_scheduled_count=retry_count,
-        retry_alert_threshold=retry_alert_threshold,
-        normalized_query=normalized_query,
-    )
-    merged = _apply_block_circuit_breaker(
-        runtime_state=runtime_state,
-        merged_parsed=merged,
-        cooldown_block_threshold=cooldown_block_threshold,
-        cooldown_seconds=cooldown_seconds,
-        normalized_query=normalized_query,
-    )
-    ttl_seconds = _resolve_author_search_cache_ttl_seconds(
-        merged_parsed=merged,
-        blocked_cache_ttl_seconds=blocked_cache_ttl_seconds,
-        cache_ttl_seconds=cache_ttl_seconds,
-    )
-    await _cache_set_author_search_result(
-        db_session,
-        query_key=query_key,
-        parsed=merged,
-        ttl_seconds=float(ttl_seconds),
-        max_entries=cache_max_entries,
-        now_utc=datetime.now(UTC),
-    )
-    return merged, True
-
-
-async def search_author_candidates(
-    *,
-    source: ScholarSource,
-    db_session: AsyncSession,
-    query: str,
-    limit: int,
-    network_error_retries: int = 1,
-    retry_backoff_seconds: float = 1.0,
-    search_enabled: bool = True,
-    cache_ttl_seconds: int = 21_600,
-    blocked_cache_ttl_seconds: int = DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS,
-    cache_max_entries: int = DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES,
-    min_interval_seconds: float = DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS,
-    interval_jitter_seconds: float = DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS,
-    cooldown_block_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD,
-    cooldown_seconds: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS,
-    retry_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD,
-    cooldown_rejection_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD,
-) -> ParsedAuthorSearchPage:
-    normalized_query, bounded_limit, query_key = _normalize_author_search_inputs(query, limit)
-    if not search_enabled:
-        return _disabled_search_result(
-            normalized_query=normalized_query,
-            bounded_limit=bounded_limit,
-        )
-
-    runtime_state = await _load_locked_runtime_state(db_session)
-    early_result, runtime_state_updated = await _cooldown_or_cache_result(
-        db_session,
-        runtime_state=runtime_state,
-        query_key=query_key,
-        normalized_query=normalized_query,
-        bounded_limit=bounded_limit,
-        cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
-    )
-    if early_result is not None:
-        await db_session.commit()
-        return early_result
-
-    merged_parsed, live_runtime_updated = await _perform_live_author_search(
-        db_session,
-        source=source,
-        runtime_state=runtime_state,
-        normalized_query=normalized_query,
-        query_key=query_key,
-        network_error_retries=network_error_retries,
-        retry_backoff_seconds=retry_backoff_seconds,
-        min_interval_seconds=min_interval_seconds,
-        interval_jitter_seconds=interval_jitter_seconds,
-        retry_alert_threshold=retry_alert_threshold,
-        cooldown_block_threshold=cooldown_block_threshold,
-        cooldown_seconds=cooldown_seconds,
-        blocked_cache_ttl_seconds=blocked_cache_ttl_seconds,
-        cache_ttl_seconds=cache_ttl_seconds,
-        cache_max_entries=cache_max_entries,
-    )
-    runtime_state_updated = runtime_state_updated or live_runtime_updated
-    if runtime_state_updated:
-        await db_session.commit()
-    return _trim_author_search_result(merged_parsed, limit=bounded_limit)
-
-
 async def hydrate_profile_metadata(
     db_session: AsyncSession,
     *,
diff --git a/app/services/scholars/author_search.py b/app/services/scholars/author_search.py
new file mode 100644
index 0000000..a9a9a02
--- /dev/null
+++ b/app/services/scholars/author_search.py
@@ -0,0 +1,580 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import random
+from dataclasses import replace
+from datetime import UTC, datetime, timedelta
+
+from sqlalchemy import select, text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import AuthorSearchRuntimeState
+from app.logging_utils import structured_log
+from app.services.scholar.parser import (
+    ParsedAuthorSearchPage,
+    ParseState,
+    ScholarParserError,
+    parse_author_search_page,
+)
+from app.services.scholar.source import ScholarSource
+from app.services.scholars.author_search_cache import (
+    cache_get_author_search_result,
+    cache_set_author_search_result,
+)
+from app.services.scholars.constants import (
+    AUTHOR_SEARCH_LOCK_KEY,
+    AUTHOR_SEARCH_LOCK_NAMESPACE,
+    AUTHOR_SEARCH_RUNTIME_STATE_KEY,
+    DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS,
+    DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES,
+    DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD,
+    DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD,
+    DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS,
+    DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS,
+    DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS,
+    DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD,
+    MAX_AUTHOR_SEARCH_LIMIT,
+    SEARCH_CACHED_BLOCK_REASON,
+    SEARCH_COOLDOWN_REASON,
+    SEARCH_DISABLED_REASON,
+)
+from app.services.scholars.exceptions import ScholarServiceError
+from app.services.scholars.search_hints import (
+    _merge_warnings,
+    _policy_blocked_author_search_result,
+    _trim_author_search_result,
+)
+
+logger = logging.getLogger(__name__)
+
+
+async def _acquire_author_search_lock(db_session: AsyncSession) -> None:
+    await db_session.execute(
+        text("SELECT pg_advisory_xact_lock(:namespace, :lock_key)"),
+        {
+            "namespace": AUTHOR_SEARCH_LOCK_NAMESPACE,
+            "lock_key": AUTHOR_SEARCH_LOCK_KEY,
+        },
+    )
+
+
+async def _load_runtime_state_for_update(
+    db_session: AsyncSession,
+) -> AuthorSearchRuntimeState:
+    result = await db_session.execute(
+        select(AuthorSearchRuntimeState)
+        .where(AuthorSearchRuntimeState.state_key == AUTHOR_SEARCH_RUNTIME_STATE_KEY)
+        .with_for_update()
+    )
+    state = result.scalar_one_or_none()
+    if state is not None:
+        return state
+
+    state = AuthorSearchRuntimeState(state_key=AUTHOR_SEARCH_RUNTIME_STATE_KEY)
+    db_session.add(state)
+    await db_session.flush()
+    return state
+
+
+def _is_author_search_block_state(parsed: ParsedAuthorSearchPage) -> bool:
+    return parsed.state == ParseState.BLOCKED_OR_CAPTCHA
+
+
+def _author_search_cooldown_remaining_seconds(
+    runtime_state: AuthorSearchRuntimeState,
+    now_utc: datetime,
+) -> int:
+    cooldown_until = runtime_state.cooldown_until
+    if cooldown_until is None:
+        return 0
+    if cooldown_until.tzinfo is None:
+        cooldown_until = cooldown_until.replace(tzinfo=UTC)
+    remaining_seconds = int((cooldown_until - now_utc).total_seconds())
+    return max(0, remaining_seconds)
+
+
+def _normalize_author_search_inputs(query: str, limit: int) -> tuple[str, int, str]:
+    normalized_query = query.strip()
+    if len(normalized_query) < 2:
+        raise ScholarServiceError("Search query must be at least 2 characters.")
+    bounded_limit = max(1, min(int(limit), MAX_AUTHOR_SEARCH_LIMIT))
+    return normalized_query, bounded_limit, normalized_query.casefold()
+
+
+def _disabled_search_result(*, normalized_query: str, bounded_limit: int) -> ParsedAuthorSearchPage:
+    structured_log(
+        logger,
+        "warning",
+        "scholar_search.disabled_by_configuration",
+        query=normalized_query,
+    )
+    return _policy_blocked_author_search_result(
+        reason=SEARCH_DISABLED_REASON,
+        warning_codes=["author_search_disabled_by_configuration"],
+        limit=bounded_limit,
+    )
+
+
+def _normalize_runtime_cooldown_state(
+    runtime_state: AuthorSearchRuntimeState,
+    *,
+    now_utc: datetime,
+) -> bool:
+    if runtime_state.cooldown_until is None:
+        return False
+    cooldown_until = runtime_state.cooldown_until
+    updated = False
+    if cooldown_until.tzinfo is None:
+        cooldown_until = cooldown_until.replace(tzinfo=UTC)
+        runtime_state.cooldown_until = cooldown_until
+        updated = True
+    if now_utc < cooldown_until:
+        return updated
+    structured_log(
+        logger,
+        "info",
+        "scholar_search.cooldown_expired",
+        cooldown_until_utc=cooldown_until.isoformat(),
+    )
+    runtime_state.cooldown_until = None
+    runtime_state.cooldown_rejection_count = 0
+    runtime_state.cooldown_alert_emitted = False
+    return True
+
+
+def _cooldown_warning_codes(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    cooldown_remaining_seconds: int,
+) -> list[str]:
+    warning_codes = [
+        "author_search_cooldown_active",
+        f"author_search_cooldown_remaining_{cooldown_remaining_seconds}s",
+    ]
+    if bool(runtime_state.cooldown_alert_emitted):
+        warning_codes.append("author_search_cooldown_alert_threshold_exceeded")
+    return warning_codes
+
+
+def _emit_cooldown_threshold_alert(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    normalized_query: str,
+    cooldown_rejection_alert_threshold: int,
+) -> bool:
+    runtime_state.cooldown_rejection_count = int(runtime_state.cooldown_rejection_count) + 1
+    threshold = max(1, int(cooldown_rejection_alert_threshold))
+    if int(runtime_state.cooldown_rejection_count) < threshold:
+        return True
+    if bool(runtime_state.cooldown_alert_emitted):
+        return True
+    structured_log(
+        logger,
+        "error",
+        "scholar_search.cooldown_rejection_threshold_exceeded",
+        query=normalized_query,
+        cooldown_rejection_count=int(runtime_state.cooldown_rejection_count),
+        threshold=threshold,
+        cooldown_until_utc=runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
+    )
+    runtime_state.cooldown_alert_emitted = True
+    return True
+
+
+def _cooldown_block_result(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    normalized_query: str,
+    bounded_limit: int,
+    cooldown_rejection_alert_threshold: int,
+    cooldown_remaining_seconds: int,
+) -> ParsedAuthorSearchPage:
+    _emit_cooldown_threshold_alert(
+        runtime_state=runtime_state,
+        normalized_query=normalized_query,
+        cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
+    )
+    structured_log(
+        logger,
+        "warning",
+        "scholar_search.cooldown_active",
+        query=normalized_query,
+        cooldown_remaining_seconds=cooldown_remaining_seconds,
+        cooldown_until_utc=runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
+    )
+    return _policy_blocked_author_search_result(
+        reason=SEARCH_COOLDOWN_REASON,
+        warning_codes=_cooldown_warning_codes(
+            runtime_state=runtime_state,
+            cooldown_remaining_seconds=cooldown_remaining_seconds,
+        ),
+        limit=bounded_limit,
+    )
+
+
+async def _cache_hit_result(
+    db_session: AsyncSession,
+    *,
+    query_key: str,
+    now_utc: datetime,
+    normalized_query: str,
+    bounded_limit: int,
+) -> ParsedAuthorSearchPage | None:
+    cached = await cache_get_author_search_result(
+        db_session,
+        query_key=query_key,
+        now_utc=now_utc,
+    )
+    if cached is None:
+        return None
+    structured_log(
+        logger,
+        "info",
+        "scholar_search.cache_hit",
+        query=normalized_query,
+        state=cached.state.value,
+        state_reason=cached.state_reason,
+    )
+    state_reason_override = SEARCH_CACHED_BLOCK_REASON if _is_author_search_block_state(cached) else None
+    return _trim_author_search_result(
+        cached,
+        limit=bounded_limit,
+        extra_warnings=["author_search_served_from_cache"],
+        state_reason_override=state_reason_override,
+    )
+
+
+def _throttle_sleep_seconds(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    now_utc: datetime,
+    min_interval_seconds: float,
+    interval_jitter_seconds: float,
+) -> tuple[float, bool]:
+    updated = False
+    if runtime_state.last_live_request_at is None:
+        enforced_wait_seconds = 0.0
+    else:
+        last_live_request_at = runtime_state.last_live_request_at
+        if last_live_request_at.tzinfo is None:
+            last_live_request_at = last_live_request_at.replace(tzinfo=UTC)
+            runtime_state.last_live_request_at = last_live_request_at
+            updated = True
+        enforced_wait_seconds = (
+            last_live_request_at + timedelta(seconds=max(float(min_interval_seconds), 0.0)) - now_utc
+        ).total_seconds()
+    jitter_seconds = random.uniform(0.0, max(float(interval_jitter_seconds), 0.0))
+    return max(0.0, float(enforced_wait_seconds)) + jitter_seconds, updated
+
+
+async def _wait_for_author_search_throttle(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    normalized_query: str,
+    now_utc: datetime,
+    min_interval_seconds: float,
+    interval_jitter_seconds: float,
+) -> bool:
+    sleep_seconds, updated = _throttle_sleep_seconds(
+        runtime_state=runtime_state,
+        now_utc=now_utc,
+        min_interval_seconds=min_interval_seconds,
+        interval_jitter_seconds=interval_jitter_seconds,
+    )
+    if sleep_seconds <= 0.0:
+        return updated
+    structured_log(
+        logger,
+        "info",
+        "scholar_search.throttle_wait",
+        query=normalized_query,
+        sleep_seconds=round(sleep_seconds, 3),
+    )
+    await asyncio.sleep(sleep_seconds)
+    return True
+
+
+async def _fetch_author_search_with_retries(
+    *,
+    source: ScholarSource,
+    normalized_query: str,
+    network_error_retries: int,
+    retry_backoff_seconds: float,
+) -> tuple[ParsedAuthorSearchPage, int, list[str]]:
+    max_attempts = max(1, int(network_error_retries) + 1)
+    parsed: ParsedAuthorSearchPage | None = None
+    retry_warnings: list[str] = []
+    retry_scheduled_count = 0
+    for attempt_index in range(max_attempts):
+        fetch_result = await source.fetch_author_search_html(normalized_query, start=0)
+        try:
+            parsed = parse_author_search_page(fetch_result)
+        except ScholarParserError as exc:
+            parsed = ParsedAuthorSearchPage(
+                state=ParseState.LAYOUT_CHANGED,
+                state_reason=exc.code,
+                candidates=[],
+                marker_counts={},
+                warnings=[exc.code],
+            )
+        if parsed.state != ParseState.NETWORK_ERROR or attempt_index >= max_attempts - 1:
+            break
+        retry_warnings.append("network_retry_scheduled_for_author_search")
+        retry_scheduled_count += 1
+        retry_sleep_seconds = max(float(retry_backoff_seconds), 0.0) * (2**attempt_index)
+        if retry_sleep_seconds > 0:
+            await asyncio.sleep(retry_sleep_seconds)
+    if parsed is None:
+        raise ScholarServiceError("Unable to complete scholar author search.")
+    return parsed, retry_scheduled_count, retry_warnings
+
+
+def _with_retry_warnings(
+    parsed: ParsedAuthorSearchPage,
+    *,
+    retry_warnings: list[str],
+    retry_scheduled_count: int,
+    retry_alert_threshold: int,
+    normalized_query: str,
+) -> ParsedAuthorSearchPage:
+    merged = replace(parsed, warnings=_merge_warnings(parsed.warnings, retry_warnings))
+    threshold = max(1, int(retry_alert_threshold))
+    if retry_scheduled_count < threshold:
+        return merged
+    structured_log(
+        logger,
+        "warning",
+        "scholar_search.retry_threshold_exceeded",
+        query=normalized_query,
+        retry_scheduled_count=retry_scheduled_count,
+        threshold=threshold,
+        final_state=merged.state.value,
+        final_state_reason=merged.state_reason,
+    )
+    return replace(
+        merged,
+        warnings=_merge_warnings(
+            merged.warnings,
+            [f"author_search_retry_threshold_exceeded_{retry_scheduled_count}"],
+        ),
+    )
+
+
+def _apply_block_circuit_breaker(
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    merged_parsed: ParsedAuthorSearchPage,
+    cooldown_block_threshold: int,
+    cooldown_seconds: int,
+    normalized_query: str,
+) -> ParsedAuthorSearchPage:
+    if not _is_author_search_block_state(merged_parsed):
+        runtime_state.consecutive_blocked_count = 0
+        return merged_parsed
+    runtime_state.consecutive_blocked_count = int(runtime_state.consecutive_blocked_count) + 1
+    structured_log(
+        logger,
+        "warning",
+        "scholar_search.block_detected",
+        query=normalized_query,
+        state_reason=merged_parsed.state_reason,
+        consecutive_blocked_count=int(runtime_state.consecutive_blocked_count),
+    )
+    if int(runtime_state.consecutive_blocked_count) < max(1, int(cooldown_block_threshold)):
+        return merged_parsed
+    runtime_state.cooldown_until = datetime.now(UTC) + timedelta(seconds=max(60, int(cooldown_seconds)))
+    runtime_state.consecutive_blocked_count = 0
+    runtime_state.cooldown_rejection_count = 0
+    runtime_state.cooldown_alert_emitted = False
+    structured_log(
+        logger,
+        "error",
+        "scholar_search.cooldown_activated",
+        query=normalized_query,
+        cooldown_until_utc=runtime_state.cooldown_until.isoformat() if runtime_state.cooldown_until else None,
+    )
+    return replace(
+        merged_parsed,
+        warnings=_merge_warnings(merged_parsed.warnings, ["author_search_circuit_breaker_armed"]),
+    )
+
+
+def _resolve_author_search_cache_ttl_seconds(
+    *,
+    merged_parsed: ParsedAuthorSearchPage,
+    blocked_cache_ttl_seconds: int,
+    cache_ttl_seconds: int,
+) -> int:
+    if _is_author_search_block_state(merged_parsed):
+        return min(max(1, int(blocked_cache_ttl_seconds)), max(1, int(cache_ttl_seconds)))
+    return max(1, int(cache_ttl_seconds))
+
+
+async def _load_locked_runtime_state(
+    db_session: AsyncSession,
+) -> AuthorSearchRuntimeState:
+    await _acquire_author_search_lock(db_session)
+    return await _load_runtime_state_for_update(db_session)
+
+
+async def _cooldown_or_cache_result(
+    db_session: AsyncSession,
+    *,
+    runtime_state: AuthorSearchRuntimeState,
+    query_key: str,
+    normalized_query: str,
+    bounded_limit: int,
+    cooldown_rejection_alert_threshold: int,
+) -> tuple[ParsedAuthorSearchPage | None, bool]:
+    runtime_state_updated = _normalize_runtime_cooldown_state(
+        runtime_state,
+        now_utc=datetime.now(UTC),
+    )
+    cooldown_remaining_seconds = _author_search_cooldown_remaining_seconds(
+        runtime_state,
+        datetime.now(UTC),
+    )
+    if cooldown_remaining_seconds > 0:
+        return (
+            _cooldown_block_result(
+                runtime_state=runtime_state,
+                normalized_query=normalized_query,
+                bounded_limit=bounded_limit,
+                cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
+                cooldown_remaining_seconds=cooldown_remaining_seconds,
+            ),
+            True,
+        )
+    cached_result = await _cache_hit_result(
+        db_session,
+        query_key=query_key,
+        now_utc=datetime.now(UTC),
+        normalized_query=normalized_query,
+        bounded_limit=bounded_limit,
+    )
+    return cached_result, runtime_state_updated
+
+
+async def _perform_live_author_search(
+    db_session: AsyncSession,
+    *,
+    source: ScholarSource,
+    runtime_state: AuthorSearchRuntimeState,
+    normalized_query: str,
+    query_key: str,
+    network_error_retries: int,
+    retry_backoff_seconds: float,
+    min_interval_seconds: float,
+    interval_jitter_seconds: float,
+    retry_alert_threshold: int,
+    cooldown_block_threshold: int,
+    cooldown_seconds: int,
+    blocked_cache_ttl_seconds: int,
+    cache_ttl_seconds: int,
+    cache_max_entries: int,
+) -> tuple[ParsedAuthorSearchPage, bool]:
+    await _wait_for_author_search_throttle(
+        runtime_state=runtime_state,
+        normalized_query=normalized_query,
+        now_utc=datetime.now(UTC),
+        min_interval_seconds=min_interval_seconds,
+        interval_jitter_seconds=interval_jitter_seconds,
+    )
+    parsed, retry_count, retry_warnings = await _fetch_author_search_with_retries(
+        source=source,
+        normalized_query=normalized_query,
+        network_error_retries=network_error_retries,
+        retry_backoff_seconds=retry_backoff_seconds,
+    )
+    runtime_state.last_live_request_at = datetime.now(UTC)
+    merged = _with_retry_warnings(
+        parsed,
+        retry_warnings=retry_warnings,
+        retry_scheduled_count=retry_count,
+        retry_alert_threshold=retry_alert_threshold,
+        normalized_query=normalized_query,
+    )
+    merged = _apply_block_circuit_breaker(
+        runtime_state=runtime_state,
+        merged_parsed=merged,
+        cooldown_block_threshold=cooldown_block_threshold,
+        cooldown_seconds=cooldown_seconds,
+        normalized_query=normalized_query,
+    )
+    ttl_seconds = _resolve_author_search_cache_ttl_seconds(
+        merged_parsed=merged,
+        blocked_cache_ttl_seconds=blocked_cache_ttl_seconds,
+        cache_ttl_seconds=cache_ttl_seconds,
+    )
+    await cache_set_author_search_result(
+        db_session,
+        query_key=query_key,
+        parsed=merged,
+        ttl_seconds=float(ttl_seconds),
+        max_entries=cache_max_entries,
+        now_utc=datetime.now(UTC),
+    )
+    return merged, True
+
+
+async def search_author_candidates(
+    *,
+    source: ScholarSource,
+    db_session: AsyncSession,
+    query: str,
+    limit: int,
+    network_error_retries: int = 1,
+    retry_backoff_seconds: float = 1.0,
+    search_enabled: bool = True,
+    cache_ttl_seconds: int = 21_600,
+    blocked_cache_ttl_seconds: int = DEFAULT_AUTHOR_SEARCH_BLOCKED_CACHE_TTL_SECONDS,
+    cache_max_entries: int = DEFAULT_AUTHOR_SEARCH_CACHE_MAX_ENTRIES,
+    min_interval_seconds: float = DEFAULT_AUTHOR_SEARCH_MIN_INTERVAL_SECONDS,
+    interval_jitter_seconds: float = DEFAULT_AUTHOR_SEARCH_INTERVAL_JITTER_SECONDS,
+    cooldown_block_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_BLOCK_THRESHOLD,
+    cooldown_seconds: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_SECONDS,
+    retry_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_RETRY_ALERT_THRESHOLD,
+    cooldown_rejection_alert_threshold: int = DEFAULT_AUTHOR_SEARCH_COOLDOWN_REJECTION_ALERT_THRESHOLD,
+) -> ParsedAuthorSearchPage:
+    normalized_query, bounded_limit, query_key = _normalize_author_search_inputs(query, limit)
+    if not search_enabled:
+        return _disabled_search_result(
+            normalized_query=normalized_query,
+            bounded_limit=bounded_limit,
+        )
+
+    runtime_state = await _load_locked_runtime_state(db_session)
+    early_result, runtime_state_updated = await _cooldown_or_cache_result(
+        db_session,
+        runtime_state=runtime_state,
+        query_key=query_key,
+        normalized_query=normalized_query,
+        bounded_limit=bounded_limit,
+        cooldown_rejection_alert_threshold=cooldown_rejection_alert_threshold,
+    )
+    if early_result is not None:
+        await db_session.commit()
+        return early_result
+
+    merged_parsed, live_runtime_updated = await _perform_live_author_search(
+        db_session,
+        source=source,
+        runtime_state=runtime_state,
+        normalized_query=normalized_query,
+        query_key=query_key,
+        network_error_retries=network_error_retries,
+        retry_backoff_seconds=retry_backoff_seconds,
+        min_interval_seconds=min_interval_seconds,
+        interval_jitter_seconds=interval_jitter_seconds,
+        retry_alert_threshold=retry_alert_threshold,
+        cooldown_block_threshold=cooldown_block_threshold,
+        cooldown_seconds=cooldown_seconds,
+        blocked_cache_ttl_seconds=blocked_cache_ttl_seconds,
+        cache_ttl_seconds=cache_ttl_seconds,
+        cache_max_entries=cache_max_entries,
+    )
+    runtime_state_updated = runtime_state_updated or live_runtime_updated
+    if runtime_state_updated:
+        await db_session.commit()
+    return _trim_author_search_result(merged_parsed, limit=bounded_limit)
diff --git a/app/services/scholars/author_search_cache.py b/app/services/scholars/author_search_cache.py
new file mode 100644
index 0000000..01be986
--- /dev/null
+++ b/app/services/scholars/author_search_cache.py
@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+
+from sqlalchemy import delete, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import AuthorSearchCacheEntry
+from app.services.scholar.parser import (
+    ParsedAuthorSearchPage,
+    ParseState,
+    ScholarSearchCandidate,
+)
+
+
+def _serialize_parsed_author_search_page(parsed: ParsedAuthorSearchPage) -> dict:
+    return {
+        "state": parsed.state.value,
+        "state_reason": parsed.state_reason,
+        "marker_counts": {str(key): int(value) for key, value in parsed.marker_counts.items()},
+        "warnings": [str(value) for value in parsed.warnings],
+        "candidates": [
+            {
+                "scholar_id": candidate.scholar_id,
+                "display_name": candidate.display_name,
+                "affiliation": candidate.affiliation,
+                "email_domain": candidate.email_domain,
+                "cited_by_count": candidate.cited_by_count,
+                "interests": [str(interest) for interest in candidate.interests],
+                "profile_url": candidate.profile_url,
+                "profile_image_url": candidate.profile_image_url,
+            }
+            for candidate in parsed.candidates
+        ],
+    }
+
+
+def _payload_state(payload: dict[str, object]) -> ParseState | None:
+    state_raw = str(payload.get("state", "")).strip()
+    try:
+        return ParseState(state_raw)
+    except ValueError:
+        return None
+
+
+def _payload_marker_counts(payload: dict[str, object]) -> dict[str, int]:
+    marker_counts_payload = payload.get("marker_counts")
+    if not isinstance(marker_counts_payload, dict):
+        return {}
+    parsed: dict[str, int] = {}
+    for key, value in marker_counts_payload.items():
+        try:
+            parsed[str(key)] = int(value)
+        except (TypeError, ValueError):
+            continue
+    return parsed
+
+
+def _payload_warnings(payload: dict[str, object]) -> list[str]:
+    warnings_payload = payload.get("warnings")
+    if not isinstance(warnings_payload, list):
+        return []
+    return [str(value) for value in warnings_payload if isinstance(value, str)]
+
+
+def _parse_optional_string(value: object) -> str | None:
+    if value is None:
+        return None
+    normalized = str(value).strip()
+    return normalized or None
+
+
+def _parse_optional_int(value: object) -> int | None:
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str) and value.strip():
+        try:
+            return int(value)
+        except ValueError:
+            return None
+    return None
+
+
+def _normalize_interests(value: object) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(item) for item in value if isinstance(item, str)]
+
+
+def _deserialize_candidate_payload(value: object) -> dict[str, object] | None:
+    if not isinstance(value, dict):
+        return None
+    scholar_id = str(value.get("scholar_id", "")).strip()
+    display_name = str(value.get("display_name", "")).strip()
+    profile_url = str(value.get("profile_url", "")).strip()
+    if not scholar_id or not display_name or not profile_url:
+        return None
+    return {
+        "scholar_id": scholar_id,
+        "display_name": display_name,
+        "affiliation": _parse_optional_string(value.get("affiliation")),
+        "email_domain": _parse_optional_string(value.get("email_domain")),
+        "cited_by_count": _parse_optional_int(value.get("cited_by_count")),
+        "interests": _normalize_interests(value.get("interests")),
+        "profile_url": profile_url,
+        "profile_image_url": _parse_optional_string(value.get("profile_image_url")),
+    }
+
+
+def _deserialize_candidates(payload: dict[str, object]) -> list[dict[str, object]]:
+    candidates_payload = payload.get("candidates")
+    if not isinstance(candidates_payload, list):
+        return []
+    normalized: list[dict[str, object]] = []
+    for value in candidates_payload:
+        candidate = _deserialize_candidate_payload(value)
+        if candidate is not None:
+            normalized.append(candidate)
+    return normalized
+
+
+def _deserialize_parsed_author_search_page(payload: object) -> ParsedAuthorSearchPage | None:
+    if not isinstance(payload, dict):
+        return None
+
+    state = _payload_state(payload)
+    if state is None:
+        return None
+
+    marker_counts = _payload_marker_counts(payload)
+    warnings = _payload_warnings(payload)
+    normalized_candidates = _deserialize_candidates(payload)
+
+    return ParsedAuthorSearchPage(
+        state=state,
+        state_reason=str(payload.get("state_reason", "")).strip() or "unknown",
+        candidates=[
+            ScholarSearchCandidate(
+                scholar_id=item["scholar_id"],
+                display_name=item["display_name"],
+                affiliation=item["affiliation"],
+                email_domain=item["email_domain"],
+                cited_by_count=item["cited_by_count"],
+                interests=item["interests"],
+                profile_url=item["profile_url"],
+                profile_image_url=item["profile_image_url"],
+            )
+            for item in normalized_candidates
+        ],
+        marker_counts=marker_counts,
+        warnings=warnings,
+    )
+
+
+async def cache_get_author_search_result(
+    db_session: AsyncSession,
+    *,
+    query_key: str,
+    now_utc: datetime,
+) -> ParsedAuthorSearchPage | None:
+    result = await db_session.execute(
+        select(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key == query_key)
+    )
+    entry = result.scalar_one_or_none()
+    if entry is None:
+        return None
+    expires_at = entry.expires_at
+    if expires_at.tzinfo is None:
+        expires_at = expires_at.replace(tzinfo=UTC)
+    if expires_at <= now_utc:
+        await db_session.delete(entry)
+        return None
+    parsed = _deserialize_parsed_author_search_page(entry.payload)
+    if parsed is None:
+        await db_session.delete(entry)
+        return None
+    return parsed
+
+
+async def cache_set_author_search_result(
+    db_session: AsyncSession,
+    *,
+    query_key: str,
+    parsed: ParsedAuthorSearchPage,
+    ttl_seconds: float,
+    max_entries: int,
+    now_utc: datetime,
+) -> None:
+    ttl = max(float(ttl_seconds), 0.0)
+    existing_result = await db_session.execute(
+        select(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key == query_key)
+    )
+    existing = existing_result.scalar_one_or_none()
+
+    if ttl <= 0.0:
+        if existing is not None:
+            await db_session.delete(existing)
+        return
+
+    expires_at = now_utc + timedelta(seconds=ttl)
+    payload = _serialize_parsed_author_search_page(parsed)
+    if existing is None:
+        db_session.add(
+            AuthorSearchCacheEntry(
+                query_key=query_key,
+                payload=payload,
+                expires_at=expires_at,
+                cached_at=now_utc,
+                updated_at=now_utc,
+            )
+        )
+    else:
+        existing.payload = payload
+        existing.expires_at = expires_at
+        existing.cached_at = now_utc
+        existing.updated_at = now_utc
+
+    await prune_author_search_cache(db_session, now_utc=now_utc, max_entries=max_entries)
+
+
+async def prune_author_search_cache(
+    db_session: AsyncSession,
+    *,
+    now_utc: datetime,
+    max_entries: int,
+) -> None:
+    await db_session.execute(delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.expires_at <= now_utc))
+    bounded_max_entries = max(1, int(max_entries))
+    count_result = await db_session.execute(select(func.count()).select_from(AuthorSearchCacheEntry))
+    entry_count = int(count_result.scalar_one() or 0)
+    overflow = max(0, entry_count - bounded_max_entries)
+    if overflow <= 0:
+        return
+    stale_keys_result = await db_session.execute(
+        select(AuthorSearchCacheEntry.query_key).order_by(AuthorSearchCacheEntry.cached_at.asc()).limit(overflow)
+    )
+    stale_keys = [str(row[0]) for row in stale_keys_result.all()]
+    if stale_keys:
+        await db_session.execute(delete(AuthorSearchCacheEntry).where(AuthorSearchCacheEntry.query_key.in_(stale_keys)))
diff --git a/tests/unit/test_publication_pdf_queue_policy.py b/tests/unit/test_publication_pdf_queue_policy.py
index b88cb26..ffc78d7 100644
--- a/tests/unit/test_publication_pdf_queue_policy.py
+++ b/tests/unit/test_publication_pdf_queue_policy.py
@@ -6,7 +6,7 @@ from types import SimpleNamespace
 import pytest
 
 from app.db.models import PublicationPdfJob
-from app.services.publications import pdf_queue
+from app.services.publications import pdf_queue, pdf_queue_resolution
 from app.services.publications.pdf_resolution_pipeline import PipelineOutcome
 from app.services.unpaywall.application import OaResolutionOutcome
 
@@ -150,9 +150,9 @@ async def test_fetch_outcome_for_row_uses_pipeline_outcome(monkeypatch: pytest.M
             scholar_candidates=None,
         )
 
-    monkeypatch.setattr(pdf_queue, "resolve_publication_pdf_outcome_for_row", _fake_pipeline)
+    monkeypatch.setattr(pdf_queue_resolution, "resolve_publication_pdf_outcome_for_row", _fake_pipeline)
 
-    outcome, arxiv_rate_limited = await pdf_queue._fetch_outcome_for_row(
+    outcome, arxiv_rate_limited = await pdf_queue_resolution._fetch_outcome_for_row(
         row=_row(),
         request_email="user@example.com",
     )
@@ -172,15 +172,15 @@ async def test_fetch_outcome_for_row_returns_failed_outcome_when_pipeline_return
         assert allow_arxiv_lookup is True
         return PipelineOutcome(outcome=None, scholar_candidates=None, arxiv_rate_limited=True)
 
-    monkeypatch.setattr(pdf_queue, "resolve_publication_pdf_outcome_for_row", _fake_pipeline)
+    monkeypatch.setattr(pdf_queue_resolution, "resolve_publication_pdf_outcome_for_row", _fake_pipeline)
 
-    outcome, arxiv_rate_limited = await pdf_queue._fetch_outcome_for_row(
+    outcome, arxiv_rate_limited = await pdf_queue_resolution._fetch_outcome_for_row(
         row=_row(),
         request_email="user@example.com",
     )
 
     assert outcome.pdf_url is None
-    assert outcome.failure_reason == pdf_queue.FAILURE_RESOLUTION_EXCEPTION
+    assert outcome.failure_reason == pdf_queue_resolution.FAILURE_RESOLUTION_EXCEPTION
     assert arxiv_rate_limited is True
 
 
@@ -210,11 +210,11 @@ async def test_resolve_publication_row_persists_outcome_and_returns_rate_limit_f
     async def _capture_persist_outcome(*, publication_id: int, user_id: int, outcome: OaResolutionOutcome) -> None:
         captured.append((publication_id, user_id, outcome))
 
-    monkeypatch.setattr(pdf_queue, "_mark_attempt_started", _noop_mark_attempt_started)
-    monkeypatch.setattr(pdf_queue, "_fetch_outcome_for_row", _fake_fetch)
-    monkeypatch.setattr(pdf_queue, "_persist_outcome", _capture_persist_outcome)
+    monkeypatch.setattr(pdf_queue_resolution, "_mark_attempt_started", _noop_mark_attempt_started)
+    monkeypatch.setattr(pdf_queue_resolution, "_fetch_outcome_for_row", _fake_fetch)
+    monkeypatch.setattr(pdf_queue_resolution, "_persist_outcome", _capture_persist_outcome)
 
-    rate_limited = await pdf_queue._resolve_publication_row(
+    rate_limited = await pdf_queue_resolution._resolve_publication_row(
         user_id=42,
         request_email="user@example.com",
         row=_row(),
@@ -252,10 +252,10 @@ async def test_run_resolution_task_disables_arxiv_for_remaining_batch(
         calls.append((int(row.publication_id), bool(allow_arxiv_lookup)))
         return row.publication_id == 1
 
-    monkeypatch.setattr(pdf_queue, "get_session_factory", _raise_session_factory_error)
-    monkeypatch.setattr(pdf_queue, "_resolve_publication_row", _fake_resolve_publication_row)
+    monkeypatch.setattr(pdf_queue_resolution, "get_session_factory", _raise_session_factory_error)
+    monkeypatch.setattr(pdf_queue_resolution, "_resolve_publication_row", _fake_resolve_publication_row)
 
-    await pdf_queue._run_resolution_task(
+    await pdf_queue_resolution._run_resolution_task(
         user_id=42,
         request_email="user@example.com",
         rows=[first, second],
-- 
2.49.1


From 55315299c772dfabc9b56415db98210848391173 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 15:22:12 +0100
Subject: [PATCH 28/38] commit

---
 app/api/schemas/__init__.py                   | 14 +++++++-------
 frontend/src/theme/presets/deutan-blue.js     |  2 +-
 tests/integration/test_deferred_enrichment.py |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/app/api/schemas/__init__.py b/app/api/schemas/__init__.py
index 4114e70..019d86a 100644
--- a/app/api/schemas/__init__.py
+++ b/app/api/schemas/__init__.py
@@ -1,7 +1,7 @@
-from app.api.schemas.admin import *  # noqa: F401, F403
-from app.api.schemas.auth import *  # noqa: F401, F403
-from app.api.schemas.common import *  # noqa: F401, F403
-from app.api.schemas.publications import *  # noqa: F401, F403
-from app.api.schemas.runs import *  # noqa: F401, F403
-from app.api.schemas.scholars import *  # noqa: F401, F403
-from app.api.schemas.settings import *  # noqa: F401, F403
+from app.api.schemas.admin import *  # noqa: F403
+from app.api.schemas.auth import *  # noqa: F403
+from app.api.schemas.common import *  # noqa: F403
+from app.api.schemas.publications import *  # noqa: F403
+from app.api.schemas.runs import *  # noqa: F403
+from app.api.schemas.scholars import *  # noqa: F403
+from app.api.schemas.settings import *  # noqa: F403
diff --git a/frontend/src/theme/presets/deutan-blue.js b/frontend/src/theme/presets/deutan-blue.js
index d8ecba2..1ab3010 100644
--- a/frontend/src/theme/presets/deutan-blue.js
+++ b/frontend/src/theme/presets/deutan-blue.js
@@ -1,6 +1,6 @@
 export default {
   "id": "deutan-blue-75",
-  "label": "Deutan Colorblind - Blue",
+  "label": "Deutan (Colorblind)",
   "description": "Colorblind-oriented theme with blue-led emphasis and deutan-safer state separation.",
   "modes": {
     "light": {
diff --git a/tests/integration/test_deferred_enrichment.py b/tests/integration/test_deferred_enrichment.py
index d026fe3..447bc73 100644
--- a/tests/integration/test_deferred_enrichment.py
+++ b/tests/integration/test_deferred_enrichment.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from datetime import UTC, datetime
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, patch
 
 import pytest
 from sqlalchemy import select
-- 
2.49.1


From f11947aad26f87d545caa599e39f84c1ab24fc3b Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 15:41:23 +0100
Subject: [PATCH 29/38] refactor: extract helpers from oversized router and
 scheduler files

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 DECOMPOSITION_SLICES.md                      |  18 +-
 app/api/routers/run_manual.py                | 237 +++++++++
 app/api/routers/run_serializers.py           | 238 +++++++++
 app/api/routers/runs.py                      | 503 ++-----------------
 app/api/routers/scholar_helpers.py           | 234 +++++++++
 app/api/routers/scholars.py                  | 252 +---------
 app/services/ingestion/queue_runner.py       | 379 ++++++++++++++
 app/services/ingestion/scheduler.py          | 338 +------------
 tests/unit/test_scholars_create_hydration.py |  30 +-
 9 files changed, 1187 insertions(+), 1042 deletions(-)
 create mode 100644 app/api/routers/run_manual.py
 create mode 100644 app/api/routers/run_serializers.py
 create mode 100644 app/api/routers/scholar_helpers.py
 create mode 100644 app/services/ingestion/queue_runner.py

diff --git a/DECOMPOSITION_SLICES.md b/DECOMPOSITION_SLICES.md
index f14f072..4442463 100644
--- a/DECOMPOSITION_SLICES.md
+++ b/DECOMPOSITION_SLICES.md
@@ -29,7 +29,7 @@ This file contains self-contained decomposition prompts ("slices") to bring the
 | 2 | Ingestion: pagination + publication upsert | **DONE** |
 | 3 | Ingestion: enrichment + scholar processing + run completion | **DONE** |
 | 4 | Scholars service + PDF queue | **DONE** |
-| 5 | Routers + scheduler | pending |
+| 5 | Routers + scheduler | **DONE** |
 
 ---
 
@@ -177,9 +177,21 @@ Commit message: `refactor: decompose scholars service and pdf_queue into focused
 
 ---
 
-## Slice 5: Decompose router files and scheduler
+## Slice 5: Decompose router files and scheduler — DONE
 
-**Why:** Three files slightly over the 600-line ceiling. Each needs helper extraction.
+Completed. Extracted helpers from three oversized files:
+
+| File | Lines | Contents |
+|---|---|---|
+| `app/api/routers/run_serializers.py` | 238 | `serialize_run`, `serialize_queue_item`, `normalize_scholar_result`, `manual_run_payload_from_run`, `manual_run_success_payload`, value coercion helpers, idempotency key validation |
+| `app/api/routers/run_manual.py` | 237 | `load_safety_state`, `raise_manual_runs_disabled`, `reused_manual_run_payload`, `run_ingestion_for_manual`, `recover_integrity_error`, `execute_manual_run`, safety/failure raise helpers |
+| `app/api/routers/runs.py` | 440 | Route handlers only + imports |
+| `app/api/routers/scholar_helpers.py` | 234 | `serialize_scholar`, `hydrate_scholar_metadata_if_needed`, `enqueue_initial_scrape_job_for_scholar`, `search_kwargs`, `search_response_data`, `require_user_profile`, `read_uploaded_image` |
+| `app/api/routers/scholars.py` | 406 | Route handlers only + imports |
+| `app/services/ingestion/queue_runner.py` | 379 | `QueueJobRunner` class — drain continuation queue, job lifecycle (drop/retry/reschedule), ingestion dispatch, finalization |
+| `app/services/ingestion/scheduler.py` | 312 | `SchedulerService` — auto-run scheduling, `_run_loop`, `_tick_once`, candidate loading, PDF queue drain |
+
+Also updated one test file (`test_scholars_create_hydration.py`) to monkeypatch `scholar_helpers` instead of the `scholars` router for the 4 helper-related tests.
 
 **Files to create:** `app/api/routers/run_serializers.py`, `app/api/routers/run_manual.py`, `app/api/routers/scholar_helpers.py`, `app/services/ingestion/queue_runner.py`
 
diff --git a/app/api/routers/run_manual.py b/app/api/routers/run_manual.py
new file mode 100644
index 0000000..6360e34
--- /dev/null
+++ b/app/api/routers/run_manual.py
@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from fastapi import Request
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.errors import ApiException
+from app.api.responses import success_payload
+from app.api.routers.run_serializers import manual_run_payload_from_run
+from app.db.models import RunStatus, RunTriggerType
+from app.logging_utils import structured_log
+from app.services.ingestion import application as ingestion_service
+from app.services.ingestion import safety as run_safety_service
+from app.services.runs import application as run_service
+from app.services.settings import application as user_settings_service
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+async def load_safety_state(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+) -> dict[str, Any]:
+    user_settings = await user_settings_service.get_or_create_settings(
+        db_session,
+        user_id=user_id,
+    )
+    previous_safety_state = run_safety_service.get_safety_event_context(user_settings)
+    if run_safety_service.clear_expired_cooldown(user_settings):
+        await db_session.commit()
+        await db_session.refresh(user_settings)
+        structured_log(
+            logger,
+            "info",
+            "api.runs.safety_cooldown_cleared",
+            user_id=user_id,
+            reason=previous_safety_state.get("cooldown_reason"),
+            cooldown_until=previous_safety_state.get("cooldown_until"),
+        )
+    return run_safety_service.get_safety_state_payload(user_settings)
+
+
+def raise_manual_runs_disabled(*, user_id: int, safety_state: dict[str, Any]) -> None:
+    structured_log(
+        logger,
+        "warning",
+        "api.runs.manual_blocked_policy",
+        user_id=user_id,
+        policy={"manual_run_allowed": False},
+        safety_state=safety_state,
+    )
+    raise ApiException(
+        status_code=403,
+        code="manual_runs_disabled",
+        message="Manual checks are disabled by server policy.",
+        details={
+            "policy": {"manual_run_allowed": False},
+            "safety_state": safety_state,
+        },
+    )
+
+
+async def reused_manual_run_payload(
+    db_session: AsyncSession,
+    *,
+    request: Request,
+    user_id: int,
+    idempotency_key: str | None,
+    safety_state: dict[str, Any],
+) -> dict[str, Any] | None:
+    if idempotency_key is None:
+        return None
+    previous_run = await run_service.get_manual_run_by_idempotency_key(
+        db_session,
+        user_id=user_id,
+        idempotency_key=idempotency_key,
+    )
+    if previous_run is None:
+        return None
+    if previous_run.status in (RunStatus.RUNNING, RunStatus.RESOLVING):
+        raise ApiException(
+            status_code=409,
+            code="run_in_progress",
+            message="A run with this idempotency key is still in progress.",
+            details={"run_id": int(previous_run.id), "idempotency_key": idempotency_key},
+        )
+    return success_payload(
+        request,
+        data=manual_run_payload_from_run(
+            previous_run,
+            idempotency_key=idempotency_key,
+            reused_existing_run=True,
+            safety_state=safety_state,
+        ),
+    )
+
+
+async def run_ingestion_for_manual(
+    db_session: AsyncSession,
+    *,
+    ingest_service: ingestion_service.ScholarIngestionService,
+    user_id: int,
+    idempotency_key: str | None,
+):
+    user_settings = await user_settings_service.get_or_create_settings(
+        db_session,
+        user_id=user_id,
+    )
+    return await ingest_service.run_for_user(
+        db_session,
+        user_id=user_id,
+        trigger_type=RunTriggerType.MANUAL,
+        request_delay_seconds=user_settings.request_delay_seconds,
+        network_error_retries=settings.ingestion_network_error_retries,
+        retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
+        max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
+        page_size=settings.ingestion_page_size,
+        auto_queue_continuations=settings.ingestion_continuation_queue_enabled,
+        queue_delay_seconds=settings.ingestion_continuation_base_delay_seconds,
+        idempotency_key=idempotency_key,
+        alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
+        alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
+        alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
+    )
+
+
+async def recover_integrity_error(
+    db_session: AsyncSession,
+    *,
+    request: Request,
+    user_id: int,
+    idempotency_key: str | None,
+    original_exc: IntegrityError,
+) -> dict[str, Any]:
+    if idempotency_key is None:
+        logger.exception(
+            "api.runs.manual_integrity_error",
+            extra={"user_id": user_id},
+        )
+        raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
+    existing_run = await run_service.get_manual_run_by_idempotency_key(
+        db_session,
+        user_id=user_id,
+        idempotency_key=idempotency_key,
+    )
+    if existing_run is None:
+        logger.exception(
+            "api.runs.manual_integrity_error",
+            extra={"user_id": user_id},
+        )
+        raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
+    if existing_run.status in (RunStatus.RUNNING, RunStatus.RESOLVING):
+        raise ApiException(
+            status_code=409,
+            code="run_in_progress",
+            message="A run with this idempotency key is still in progress.",
+            details={"run_id": int(existing_run.id), "idempotency_key": idempotency_key},
+        ) from original_exc
+    return success_payload(
+        request,
+        data=manual_run_payload_from_run(
+            existing_run,
+            idempotency_key=idempotency_key,
+            reused_existing_run=True,
+            safety_state=await load_safety_state(db_session, user_id=user_id),
+        ),
+    )
+
+
+async def execute_manual_run(
+    db_session: AsyncSession,
+    *,
+    request: Request,
+    ingest_service: ingestion_service.ScholarIngestionService,
+    user_id: int,
+    idempotency_key: str | None,
+):
+    try:
+        return await run_ingestion_for_manual(
+            db_session,
+            ingest_service=ingest_service,
+            user_id=user_id,
+            idempotency_key=idempotency_key,
+        )
+    except ingestion_service.RunAlreadyInProgressError as exc:
+        await db_session.rollback()
+        raise ApiException(
+            status_code=409,
+            code="run_in_progress",
+            message="A run is already in progress for this account.",
+        ) from exc
+    except ingestion_service.RunBlockedBySafetyPolicyError as exc:
+        await db_session.rollback()
+        raise_manual_blocked_safety(exc=exc, user_id=user_id)
+    except IntegrityError as exc:
+        await db_session.rollback()
+        return await recover_integrity_error(
+            db_session,
+            request=request,
+            user_id=user_id,
+            idempotency_key=idempotency_key,
+            original_exc=exc,
+        )
+    except Exception as exc:
+        await db_session.rollback()
+        raise_manual_failed(exc=exc, user_id=user_id)
+
+
+def raise_manual_blocked_safety(*, exc, user_id: int) -> None:
+    structured_log(
+        logger,
+        "info",
+        "api.runs.manual_blocked_safety",
+        user_id=user_id,
+        reason=exc.safety_state.get("cooldown_reason"),
+        cooldown_until=exc.safety_state.get("cooldown_until"),
+        cooldown_remaining_seconds=exc.safety_state.get("cooldown_remaining_seconds"),
+    )
+    raise ApiException(
+        status_code=429,
+        code=exc.code,
+        message=exc.message,
+        details={"safety_state": exc.safety_state},
+    ) from exc
+
+
+def raise_manual_failed(*, exc: Exception, user_id: int) -> None:
+    logger.exception(
+        "api.runs.manual_failed",
+        extra={"user_id": user_id},
+    )
+    raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from exc
diff --git a/app/api/routers/run_serializers.py b/app/api/routers/run_serializers.py
new file mode 100644
index 0000000..53db3b5
--- /dev/null
+++ b/app/api/routers/run_serializers.py
@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from app.api.errors import ApiException
+from app.services.runs import application as run_service
+
+IDEMPOTENCY_HEADER = "Idempotency-Key"
+IDEMPOTENCY_MAX_LENGTH = 128
+IDEMPOTENCY_PATTERN = re.compile(r"^[A-Za-z0-9._:-]{8,128}$")
+
+
+def _int_value(value: Any, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _str_value(value: Any) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    return text if text else None
+
+
+def _bool_value(value: Any, default: bool = False) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        lowered = value.strip().lower()
+        if lowered in {"1", "true", "yes", "on"}:
+            return True
+        if lowered in {"0", "false", "no", "off"}:
+            return False
+    return default
+
+
+def normalize_idempotency_key(raw_value: str | None) -> str | None:
+    if raw_value is None:
+        return None
+    candidate = raw_value.strip()
+    if not candidate:
+        return None
+    if len(candidate) > IDEMPOTENCY_MAX_LENGTH or not IDEMPOTENCY_PATTERN.match(candidate):
+        raise ApiException(
+            status_code=400,
+            code="invalid_idempotency_key",
+            message=("Invalid Idempotency-Key. Use 8-128 characters from: A-Z a-z 0-9 . _ : -"),
+        )
+    return candidate
+
+
+def serialize_run(run) -> dict[str, Any]:
+    summary = run_service.extract_run_summary(run.error_log)
+    return {
+        "id": int(run.id),
+        "trigger_type": run.trigger_type.value,
+        "status": run.status.value,
+        "start_dt": run.start_dt,
+        "end_dt": run.end_dt,
+        "scholar_count": int(run.scholar_count or 0),
+        "new_publication_count": int(run.new_pub_count or 0),
+        "failed_count": int(summary["failed_count"]),
+        "partial_count": int(summary["partial_count"]),
+    }
+
+
+def serialize_queue_item(item) -> dict[str, Any]:
+    return {
+        "id": int(item.id),
+        "scholar_profile_id": int(item.scholar_profile_id),
+        "scholar_label": item.scholar_label,
+        "status": item.status,
+        "reason": item.reason,
+        "dropped_reason": item.dropped_reason,
+        "attempt_count": int(item.attempt_count),
+        "resume_cstart": int(item.resume_cstart),
+        "next_attempt_dt": item.next_attempt_dt,
+        "updated_at": item.updated_at,
+        "last_error": item.last_error,
+        "last_run_id": item.last_run_id,
+    }
+
+
+def _normalize_attempt_log(value: Any) -> list[dict[str, Any]]:
+    if not isinstance(value, list):
+        return []
+    normalized: list[dict[str, Any]] = []
+    for item in value:
+        if not isinstance(item, dict):
+            continue
+        normalized.append(
+            {
+                "attempt": _int_value(item.get("attempt"), 0),
+                "cstart": _int_value(item.get("cstart"), 0),
+                "state": _str_value(item.get("state")),
+                "state_reason": _str_value(item.get("state_reason")),
+                "status_code": (_int_value(item.get("status_code")) if item.get("status_code") is not None else None),
+                "fetch_error": _str_value(item.get("fetch_error")),
+            }
+        )
+    return normalized
+
+
+def _normalize_page_logs(value: Any) -> list[dict[str, Any]]:
+    if not isinstance(value, list):
+        return []
+    normalized: list[dict[str, Any]] = []
+    for item in value:
+        if not isinstance(item, dict):
+            continue
+        warning_codes = item.get("warning_codes")
+        normalized.append(
+            {
+                "page": _int_value(item.get("page"), 0),
+                "cstart": _int_value(item.get("cstart"), 0),
+                "state": _str_value(item.get("state")) or "unknown",
+                "state_reason": _str_value(item.get("state_reason")),
+                "status_code": (_int_value(item.get("status_code")) if item.get("status_code") is not None else None),
+                "publication_count": _int_value(item.get("publication_count"), 0),
+                "attempt_count": _int_value(item.get("attempt_count"), 0),
+                "has_show_more_button": _bool_value(item.get("has_show_more_button"), False),
+                "articles_range": _str_value(item.get("articles_range")),
+                "warning_codes": [str(code) for code in (warning_codes if isinstance(warning_codes, list) else [])],
+            }
+        )
+    return normalized
+
+
+def _normalize_debug(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    marker_counts = value.get("marker_counts_nonzero")
+    warning_codes = value.get("warning_codes")
+    return {
+        "status_code": (_int_value(value.get("status_code")) if value.get("status_code") is not None else None),
+        "final_url": _str_value(value.get("final_url")),
+        "fetch_error": _str_value(value.get("fetch_error")),
+        "body_sha256": _str_value(value.get("body_sha256")),
+        "body_length": (_int_value(value.get("body_length")) if value.get("body_length") is not None else None),
+        "has_show_more_button": (
+            _bool_value(value.get("has_show_more_button"), False)
+            if value.get("has_show_more_button") is not None
+            else None
+        ),
+        "articles_range": _str_value(value.get("articles_range")),
+        "state_reason": _str_value(value.get("state_reason")),
+        "warning_codes": [str(code) for code in (warning_codes if isinstance(warning_codes, list) else [])],
+        "marker_counts_nonzero": {
+            str(key): _int_value(count, 0)
+            for key, count in (marker_counts.items() if isinstance(marker_counts, dict) else [])
+        },
+        "page_logs": _normalize_page_logs(value.get("page_logs")),
+        "attempt_log": _normalize_attempt_log(value.get("attempt_log")),
+    }
+
+
+def normalize_scholar_result(value: Any) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        return {
+            "scholar_profile_id": 0,
+            "scholar_id": "unknown",
+            "state": "unknown",
+            "state_reason": None,
+            "outcome": "failed",
+            "attempt_count": 0,
+            "publication_count": 0,
+            "start_cstart": 0,
+            "continuation_cstart": None,
+            "continuation_enqueued": False,
+            "continuation_cleared": False,
+            "warnings": [],
+            "error": None,
+            "debug": None,
+        }
+    warnings = value.get("warnings")
+    return {
+        "scholar_profile_id": _int_value(value.get("scholar_profile_id"), 0),
+        "scholar_id": _str_value(value.get("scholar_id")) or "unknown",
+        "state": _str_value(value.get("state")) or "unknown",
+        "state_reason": _str_value(value.get("state_reason")),
+        "outcome": _str_value(value.get("outcome")) or "failed",
+        "attempt_count": _int_value(value.get("attempt_count"), 0),
+        "publication_count": _int_value(value.get("publication_count"), 0),
+        "start_cstart": _int_value(value.get("start_cstart"), 0),
+        "continuation_cstart": (
+            _int_value(value.get("continuation_cstart")) if value.get("continuation_cstart") is not None else None
+        ),
+        "continuation_enqueued": _bool_value(value.get("continuation_enqueued"), False),
+        "continuation_cleared": _bool_value(value.get("continuation_cleared"), False),
+        "warnings": [str(item) for item in (warnings if isinstance(warnings, list) else [])],
+        "error": _str_value(value.get("error")),
+        "debug": _normalize_debug(value.get("debug")),
+    }
+
+
+def manual_run_payload_from_run(
+    run,
+    *,
+    idempotency_key: str | None,
+    reused_existing_run: bool,
+    safety_state: dict[str, Any],
+) -> dict[str, Any]:
+    summary = run_service.extract_run_summary(run.error_log)
+    return {
+        "run_id": int(run.id),
+        "status": run.status.value,
+        "scholar_count": int(run.scholar_count or 0),
+        "succeeded_count": int(summary["succeeded_count"]),
+        "failed_count": int(summary["failed_count"]),
+        "partial_count": int(summary["partial_count"]),
+        "new_publication_count": int(run.new_pub_count or 0),
+        "reused_existing_run": reused_existing_run,
+        "idempotency_key": idempotency_key,
+        "safety_state": safety_state,
+    }
+
+
+def manual_run_success_payload(
+    *,
+    run_summary,
+    idempotency_key: str | None,
+    safety_state: dict[str, Any],
+) -> dict[str, Any]:
+    return {
+        "run_id": run_summary.crawl_run_id,
+        "status": run_summary.status.value,
+        "scholar_count": run_summary.scholar_count,
+        "succeeded_count": run_summary.succeeded_count,
+        "failed_count": run_summary.failed_count,
+        "partial_count": run_summary.partial_count,
+        "new_publication_count": run_summary.new_publication_count,
+        "reused_existing_run": False,
+        "idempotency_key": idempotency_key,
+        "safety_state": safety_state,
+    }
diff --git a/app/api/routers/runs.py b/app/api/routers/runs.py
index 8821ebf..687f6ce 100644
--- a/app/api/routers/runs.py
+++ b/app/api/routers/runs.py
@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import re
 from typing import Any
 
 from fastapi import APIRouter, Depends, Query, Request
@@ -13,6 +12,21 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from app.api.deps import get_api_current_user
 from app.api.errors import ApiException
 from app.api.responses import success_payload
+from app.api.routers.run_manual import (
+    load_safety_state,
+    raise_manual_blocked_safety,
+    raise_manual_failed,
+    raise_manual_runs_disabled,
+    recover_integrity_error,
+    reused_manual_run_payload,
+)
+from app.api.routers.run_serializers import (
+    IDEMPOTENCY_HEADER,
+    normalize_idempotency_key,
+    normalize_scholar_result,
+    serialize_queue_item,
+    serialize_run,
+)
 from app.api.runtime_deps import get_ingestion_service
 from app.api.schemas import (
     ManualRunEnvelope,
@@ -24,9 +38,7 @@ from app.api.schemas import (
 )
 from app.db.models import RunStatus, RunTriggerType, User
 from app.db.session import get_db_session
-from app.logging_utils import structured_log
 from app.services.ingestion import application as ingestion_service
-from app.services.ingestion import safety as run_safety_service
 from app.services.runs import application as run_service
 from app.services.runs.events import event_generator
 from app.services.settings import application as user_settings_service
@@ -38,453 +50,6 @@ _background_tasks: set[asyncio.Task[Any]] = set()
 router = APIRouter(prefix="/runs", tags=["api-runs"])
 ACTIVE_RUN_STATUSES = {RunStatus.RUNNING, RunStatus.RESOLVING}
 
-IDEMPOTENCY_HEADER = "Idempotency-Key"
-IDEMPOTENCY_MAX_LENGTH = 128
-IDEMPOTENCY_PATTERN = re.compile(r"^[A-Za-z0-9._:-]{8,128}$")
-
-
-def _int_value(value: Any, default: int = 0) -> int:
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        return default
-
-
-def _str_value(value: Any) -> str | None:
-    if value is None:
-        return None
-    text = str(value).strip()
-    return text if text else None
-
-
-def _bool_value(value: Any, default: bool = False) -> bool:
-    if isinstance(value, bool):
-        return value
-    if isinstance(value, str):
-        lowered = value.strip().lower()
-        if lowered in {"1", "true", "yes", "on"}:
-            return True
-        if lowered in {"0", "false", "no", "off"}:
-            return False
-    return default
-
-
-def _normalize_idempotency_key(raw_value: str | None) -> str | None:
-    if raw_value is None:
-        return None
-    candidate = raw_value.strip()
-    if not candidate:
-        return None
-    if len(candidate) > IDEMPOTENCY_MAX_LENGTH or not IDEMPOTENCY_PATTERN.match(candidate):
-        raise ApiException(
-            status_code=400,
-            code="invalid_idempotency_key",
-            message=("Invalid Idempotency-Key. Use 8-128 characters from: A-Z a-z 0-9 . _ : -"),
-        )
-    return candidate
-
-
-def _serialize_run(run) -> dict[str, Any]:
-    summary = run_service.extract_run_summary(run.error_log)
-    return {
-        "id": int(run.id),
-        "trigger_type": run.trigger_type.value,
-        "status": run.status.value,
-        "start_dt": run.start_dt,
-        "end_dt": run.end_dt,
-        "scholar_count": int(run.scholar_count or 0),
-        "new_publication_count": int(run.new_pub_count or 0),
-        "failed_count": int(summary["failed_count"]),
-        "partial_count": int(summary["partial_count"]),
-    }
-
-
-def _serialize_queue_item(item) -> dict[str, Any]:
-    return {
-        "id": int(item.id),
-        "scholar_profile_id": int(item.scholar_profile_id),
-        "scholar_label": item.scholar_label,
-        "status": item.status,
-        "reason": item.reason,
-        "dropped_reason": item.dropped_reason,
-        "attempt_count": int(item.attempt_count),
-        "resume_cstart": int(item.resume_cstart),
-        "next_attempt_dt": item.next_attempt_dt,
-        "updated_at": item.updated_at,
-        "last_error": item.last_error,
-        "last_run_id": item.last_run_id,
-    }
-
-
-def _normalize_attempt_log(value: Any) -> list[dict[str, Any]]:
-    if not isinstance(value, list):
-        return []
-    normalized: list[dict[str, Any]] = []
-    for item in value:
-        if not isinstance(item, dict):
-            continue
-        normalized.append(
-            {
-                "attempt": _int_value(item.get("attempt"), 0),
-                "cstart": _int_value(item.get("cstart"), 0),
-                "state": _str_value(item.get("state")),
-                "state_reason": _str_value(item.get("state_reason")),
-                "status_code": (_int_value(item.get("status_code")) if item.get("status_code") is not None else None),
-                "fetch_error": _str_value(item.get("fetch_error")),
-            }
-        )
-    return normalized
-
-
-def _normalize_page_logs(value: Any) -> list[dict[str, Any]]:
-    if not isinstance(value, list):
-        return []
-    normalized: list[dict[str, Any]] = []
-    for item in value:
-        if not isinstance(item, dict):
-            continue
-        warning_codes = item.get("warning_codes")
-        normalized.append(
-            {
-                "page": _int_value(item.get("page"), 0),
-                "cstart": _int_value(item.get("cstart"), 0),
-                "state": _str_value(item.get("state")) or "unknown",
-                "state_reason": _str_value(item.get("state_reason")),
-                "status_code": (_int_value(item.get("status_code")) if item.get("status_code") is not None else None),
-                "publication_count": _int_value(item.get("publication_count"), 0),
-                "attempt_count": _int_value(item.get("attempt_count"), 0),
-                "has_show_more_button": _bool_value(item.get("has_show_more_button"), False),
-                "articles_range": _str_value(item.get("articles_range")),
-                "warning_codes": [str(code) for code in (warning_codes if isinstance(warning_codes, list) else [])],
-            }
-        )
-    return normalized
-
-
-def _normalize_debug(value: Any) -> dict[str, Any] | None:
-    if not isinstance(value, dict):
-        return None
-    marker_counts = value.get("marker_counts_nonzero")
-    warning_codes = value.get("warning_codes")
-    return {
-        "status_code": (_int_value(value.get("status_code")) if value.get("status_code") is not None else None),
-        "final_url": _str_value(value.get("final_url")),
-        "fetch_error": _str_value(value.get("fetch_error")),
-        "body_sha256": _str_value(value.get("body_sha256")),
-        "body_length": (_int_value(value.get("body_length")) if value.get("body_length") is not None else None),
-        "has_show_more_button": (
-            _bool_value(value.get("has_show_more_button"), False)
-            if value.get("has_show_more_button") is not None
-            else None
-        ),
-        "articles_range": _str_value(value.get("articles_range")),
-        "state_reason": _str_value(value.get("state_reason")),
-        "warning_codes": [str(code) for code in (warning_codes if isinstance(warning_codes, list) else [])],
-        "marker_counts_nonzero": {
-            str(key): _int_value(count, 0)
-            for key, count in (marker_counts.items() if isinstance(marker_counts, dict) else [])
-        },
-        "page_logs": _normalize_page_logs(value.get("page_logs")),
-        "attempt_log": _normalize_attempt_log(value.get("attempt_log")),
-    }
-
-
-def _normalize_scholar_result(value: Any) -> dict[str, Any]:
-    if not isinstance(value, dict):
-        return {
-            "scholar_profile_id": 0,
-            "scholar_id": "unknown",
-            "state": "unknown",
-            "state_reason": None,
-            "outcome": "failed",
-            "attempt_count": 0,
-            "publication_count": 0,
-            "start_cstart": 0,
-            "continuation_cstart": None,
-            "continuation_enqueued": False,
-            "continuation_cleared": False,
-            "warnings": [],
-            "error": None,
-            "debug": None,
-        }
-    warnings = value.get("warnings")
-    return {
-        "scholar_profile_id": _int_value(value.get("scholar_profile_id"), 0),
-        "scholar_id": _str_value(value.get("scholar_id")) or "unknown",
-        "state": _str_value(value.get("state")) or "unknown",
-        "state_reason": _str_value(value.get("state_reason")),
-        "outcome": _str_value(value.get("outcome")) or "failed",
-        "attempt_count": _int_value(value.get("attempt_count"), 0),
-        "publication_count": _int_value(value.get("publication_count"), 0),
-        "start_cstart": _int_value(value.get("start_cstart"), 0),
-        "continuation_cstart": (
-            _int_value(value.get("continuation_cstart")) if value.get("continuation_cstart") is not None else None
-        ),
-        "continuation_enqueued": _bool_value(value.get("continuation_enqueued"), False),
-        "continuation_cleared": _bool_value(value.get("continuation_cleared"), False),
-        "warnings": [str(item) for item in (warnings if isinstance(warnings, list) else [])],
-        "error": _str_value(value.get("error")),
-        "debug": _normalize_debug(value.get("debug")),
-    }
-
-
-def _manual_run_payload_from_run(
-    run,
-    *,
-    idempotency_key: str | None,
-    reused_existing_run: bool,
-    safety_state: dict[str, Any],
-) -> dict[str, Any]:
-    summary = run_service.extract_run_summary(run.error_log)
-    return {
-        "run_id": int(run.id),
-        "status": run.status.value,
-        "scholar_count": int(run.scholar_count or 0),
-        "succeeded_count": int(summary["succeeded_count"]),
-        "failed_count": int(summary["failed_count"]),
-        "partial_count": int(summary["partial_count"]),
-        "new_publication_count": int(run.new_pub_count or 0),
-        "reused_existing_run": reused_existing_run,
-        "idempotency_key": idempotency_key,
-        "safety_state": safety_state,
-    }
-
-
-async def _load_safety_state(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-) -> dict[str, Any]:
-    user_settings = await user_settings_service.get_or_create_settings(
-        db_session,
-        user_id=user_id,
-    )
-    previous_safety_state = run_safety_service.get_safety_event_context(user_settings)
-    if run_safety_service.clear_expired_cooldown(user_settings):
-        await db_session.commit()
-        await db_session.refresh(user_settings)
-        structured_log(
-            logger,
-            "info",
-            "api.runs.safety_cooldown_cleared",
-            user_id=user_id,
-            reason=previous_safety_state.get("cooldown_reason"),
-            cooldown_until=previous_safety_state.get("cooldown_until"),
-        )
-    return run_safety_service.get_safety_state_payload(user_settings)
-
-
-def _raise_manual_runs_disabled(*, user_id: int, safety_state: dict[str, Any]) -> None:
-    structured_log(
-        logger,
-        "warning",
-        "api.runs.manual_blocked_policy",
-        user_id=user_id,
-        policy={"manual_run_allowed": False},
-        safety_state=safety_state,
-    )
-    raise ApiException(
-        status_code=403,
-        code="manual_runs_disabled",
-        message="Manual checks are disabled by server policy.",
-        details={
-            "policy": {"manual_run_allowed": False},
-            "safety_state": safety_state,
-        },
-    )
-
-
-async def _reused_manual_run_payload(
-    db_session: AsyncSession,
-    *,
-    request: Request,
-    user_id: int,
-    idempotency_key: str | None,
-    safety_state: dict[str, Any],
-) -> dict[str, Any] | None:
-    if idempotency_key is None:
-        return None
-    previous_run = await run_service.get_manual_run_by_idempotency_key(
-        db_session,
-        user_id=user_id,
-        idempotency_key=idempotency_key,
-    )
-    if previous_run is None:
-        return None
-    if previous_run.status in (RunStatus.RUNNING, RunStatus.RESOLVING):
-        raise ApiException(
-            status_code=409,
-            code="run_in_progress",
-            message="A run with this idempotency key is still in progress.",
-            details={"run_id": int(previous_run.id), "idempotency_key": idempotency_key},
-        )
-    return success_payload(
-        request,
-        data=_manual_run_payload_from_run(
-            previous_run,
-            idempotency_key=idempotency_key,
-            reused_existing_run=True,
-            safety_state=safety_state,
-        ),
-    )
-
-
-async def _run_ingestion_for_manual(
-    db_session: AsyncSession,
-    *,
-    ingest_service: ingestion_service.ScholarIngestionService,
-    user_id: int,
-    idempotency_key: str | None,
-):
-    user_settings = await user_settings_service.get_or_create_settings(
-        db_session,
-        user_id=user_id,
-    )
-    return await ingest_service.run_for_user(
-        db_session,
-        user_id=user_id,
-        trigger_type=RunTriggerType.MANUAL,
-        request_delay_seconds=user_settings.request_delay_seconds,
-        network_error_retries=settings.ingestion_network_error_retries,
-        retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
-        max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
-        page_size=settings.ingestion_page_size,
-        auto_queue_continuations=settings.ingestion_continuation_queue_enabled,
-        queue_delay_seconds=settings.ingestion_continuation_base_delay_seconds,
-        idempotency_key=idempotency_key,
-        alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
-        alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
-        alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
-    )
-
-
-async def _recover_integrity_error(
-    db_session: AsyncSession,
-    *,
-    request: Request,
-    user_id: int,
-    idempotency_key: str | None,
-    original_exc: IntegrityError,
-) -> dict[str, Any]:
-    if idempotency_key is None:
-        logger.exception(
-            "api.runs.manual_integrity_error",
-            extra={"user_id": user_id},
-        )
-        raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
-    existing_run = await run_service.get_manual_run_by_idempotency_key(
-        db_session,
-        user_id=user_id,
-        idempotency_key=idempotency_key,
-    )
-    if existing_run is None:
-        logger.exception(
-            "api.runs.manual_integrity_error",
-            extra={"user_id": user_id},
-        )
-        raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
-    if existing_run.status in (RunStatus.RUNNING, RunStatus.RESOLVING):
-        raise ApiException(
-            status_code=409,
-            code="run_in_progress",
-            message="A run with this idempotency key is still in progress.",
-            details={"run_id": int(existing_run.id), "idempotency_key": idempotency_key},
-        ) from original_exc
-    return success_payload(
-        request,
-        data=_manual_run_payload_from_run(
-            existing_run,
-            idempotency_key=idempotency_key,
-            reused_existing_run=True,
-            safety_state=await _load_safety_state(db_session, user_id=user_id),
-        ),
-    )
-
-
-async def _execute_manual_run(
-    db_session: AsyncSession,
-    *,
-    request: Request,
-    ingest_service: ingestion_service.ScholarIngestionService,
-    user_id: int,
-    idempotency_key: str | None,
-):
-    try:
-        return await _run_ingestion_for_manual(
-            db_session,
-            ingest_service=ingest_service,
-            user_id=user_id,
-            idempotency_key=idempotency_key,
-        )
-    except ingestion_service.RunAlreadyInProgressError as exc:
-        await db_session.rollback()
-        raise ApiException(
-            status_code=409,
-            code="run_in_progress",
-            message="A run is already in progress for this account.",
-        ) from exc
-    except ingestion_service.RunBlockedBySafetyPolicyError as exc:
-        await db_session.rollback()
-        _raise_manual_blocked_safety(exc=exc, user_id=user_id)
-    except IntegrityError as exc:
-        await db_session.rollback()
-        return await _recover_integrity_error(
-            db_session,
-            request=request,
-            user_id=user_id,
-            idempotency_key=idempotency_key,
-            original_exc=exc,
-        )
-    except Exception as exc:
-        await db_session.rollback()
-        _raise_manual_failed(exc=exc, user_id=user_id)
-
-
-def _raise_manual_blocked_safety(*, exc, user_id: int) -> None:
-    structured_log(
-        logger,
-        "info",
-        "api.runs.manual_blocked_safety",
-        user_id=user_id,
-        reason=exc.safety_state.get("cooldown_reason"),
-        cooldown_until=exc.safety_state.get("cooldown_until"),
-        cooldown_remaining_seconds=exc.safety_state.get("cooldown_remaining_seconds"),
-    )
-    raise ApiException(
-        status_code=429,
-        code=exc.code,
-        message=exc.message,
-        details={"safety_state": exc.safety_state},
-    ) from exc
-
-
-def _raise_manual_failed(*, exc: Exception, user_id: int) -> None:
-    logger.exception(
-        "api.runs.manual_failed",
-        extra={"user_id": user_id},
-    )
-    raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from exc
-
-
-def _manual_run_success_payload(
-    *,
-    run_summary,
-    idempotency_key: str | None,
-    safety_state: dict[str, Any],
-) -> dict[str, Any]:
-    return {
-        "run_id": run_summary.crawl_run_id,
-        "status": run_summary.status.value,
-        "scholar_count": run_summary.scholar_count,
-        "succeeded_count": run_summary.succeeded_count,
-        "failed_count": run_summary.failed_count,
-        "partial_count": run_summary.partial_count,
-        "new_publication_count": run_summary.new_publication_count,
-        "reused_existing_run": False,
-        "idempotency_key": idempotency_key,
-        "safety_state": safety_state,
-    }
-
 
 @router.get(
     "",
@@ -503,14 +68,14 @@ async def list_runs(
         limit=limit,
         failed_only=failed_only,
     )
-    safety_state = await _load_safety_state(
+    safety_state = await load_safety_state(
         db_session,
         user_id=current_user.id,
     )
     return success_payload(
         request,
         data={
-            "runs": [_serialize_run(run) for run in runs],
+            "runs": [serialize_run(run) for run in runs],
             "safety_state": safety_state,
         },
     )
@@ -541,16 +106,16 @@ async def get_run(
     scholar_results = error_log.get("scholar_results")
     if not isinstance(scholar_results, list):
         scholar_results = []
-    safety_state = await _load_safety_state(
+    safety_state = await load_safety_state(
         db_session,
         user_id=current_user.id,
     )
     return success_payload(
         request,
         data={
-            "run": _serialize_run(run),
+            "run": serialize_run(run),
             "summary": run_service.extract_run_summary(error_log),
-            "scholar_results": [_normalize_scholar_result(item) for item in scholar_results],
+            "scholar_results": [normalize_scholar_result(item) for item in scholar_results],
             "safety_state": safety_state,
         },
     )
@@ -595,7 +160,7 @@ async def cancel_run(
     if not isinstance(scholar_results, list):
         scholar_results = []
 
-    safety_state = await _load_safety_state(
+    safety_state = await load_safety_state(
         db_session,
         user_id=current_user.id,
     )
@@ -603,9 +168,9 @@ async def cancel_run(
     return success_payload(
         request,
         data={
-            "run": _serialize_run(run),
+            "run": serialize_run(run),
             "summary": run_service.extract_run_summary(error_log),
-            "scholar_results": [_normalize_scholar_result(item) for item in scholar_results],
+            "scholar_results": [normalize_scholar_result(item) for item in scholar_results],
             "safety_state": safety_state,
         },
     )
@@ -621,12 +186,12 @@ async def run_manual(
     current_user: User = Depends(get_api_current_user),
     ingest_service: ingestion_service.ScholarIngestionService = Depends(get_ingestion_service),
 ):
-    safety_state = await _load_safety_state(db_session, user_id=current_user.id)
+    safety_state = await load_safety_state(db_session, user_id=current_user.id)
     if not settings.ingestion_manual_run_allowed:
-        _raise_manual_runs_disabled(user_id=current_user.id, safety_state=safety_state)
+        raise_manual_runs_disabled(user_id=current_user.id, safety_state=safety_state)
 
-    idempotency_key = _normalize_idempotency_key(request.headers.get(IDEMPOTENCY_HEADER))
-    reused_payload = await _reused_manual_run_payload(
+    idempotency_key = normalize_idempotency_key(request.headers.get(IDEMPOTENCY_HEADER))
+    reused_payload = await reused_manual_run_payload(
         db_session,
         request=request,
         user_id=current_user.id,
@@ -695,12 +260,12 @@ async def run_manual(
                 "new_publication_count": 0,
                 "reused_existing_run": False,
                 "idempotency_key": idempotency_key,
-                "safety_state": await _load_safety_state(db_session, user_id=current_user.id),
+                "safety_state": await load_safety_state(db_session, user_id=current_user.id),
             },
         )
     except ingestion_service.RunBlockedBySafetyPolicyError as exc:
         await db_session.rollback()
-        _raise_manual_blocked_safety(exc=exc, user_id=current_user.id)
+        raise_manual_blocked_safety(exc=exc, user_id=current_user.id)
     except ingestion_service.RunAlreadyInProgressError as exc:
         await db_session.rollback()
         raise ApiException(
@@ -710,7 +275,7 @@ async def run_manual(
         ) from exc
     except IntegrityError as exc:
         await db_session.rollback()
-        return await _recover_integrity_error(
+        return await recover_integrity_error(
             db_session,
             request=request,
             user_id=current_user.id,
@@ -719,7 +284,7 @@ async def run_manual(
         )
     except Exception as exc:
         await db_session.rollback()
-        _raise_manual_failed(exc=exc, user_id=current_user.id)
+        raise_manual_failed(exc=exc, user_id=current_user.id)
 
 
 @router.get(
@@ -740,7 +305,7 @@ async def list_queue_items(
     return success_payload(
         request,
         data={
-            "queue_items": [_serialize_queue_item(item) for item in items],
+            "queue_items": [serialize_queue_item(item) for item in items],
         },
     )
 
@@ -776,7 +341,7 @@ async def retry_queue_item(
         )
     return success_payload(
         request,
-        data=_serialize_queue_item(queue_item),
+        data=serialize_queue_item(queue_item),
     )
 
 
@@ -811,7 +376,7 @@ async def drop_queue_item(
         )
     return success_payload(
         request,
-        data=_serialize_queue_item(dropped),
+        data=serialize_queue_item(dropped),
     )
 
 
diff --git a/app/api/routers/scholar_helpers.py b/app/api/routers/scholar_helpers.py
new file mode 100644
index 0000000..4023a3a
--- /dev/null
+++ b/app/api/routers/scholar_helpers.py
@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from fastapi import UploadFile
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.errors import ApiException
+from app.logging_utils import structured_log
+from app.services.ingestion import queue as ingestion_queue_service
+from app.services.scholar import rate_limit as scholar_rate_limit
+from app.services.scholar.source import ScholarSource
+from app.services.scholars import application as scholar_service
+from app.services.scholars import search_hints as scholar_search_hints
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+CREATE_METADATA_HYDRATION_TIMEOUT_SECONDS = 5.0
+INITIAL_SCHOLAR_SCRAPE_QUEUE_DELAY_SECONDS = 0
+INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON = "scholar_added_initial_scrape"
+
+
+def needs_metadata_hydration(profile) -> bool:
+    if not profile.profile_image_url:
+        return True
+    return not (profile.display_name or "").strip()
+
+
+def is_create_hydration_rate_limited() -> tuple[bool, float]:
+    remaining_seconds = scholar_rate_limit.remaining_scholar_slot_seconds(
+        min_interval_seconds=float(settings.ingestion_min_request_delay_seconds),
+    )
+    return remaining_seconds > 0, remaining_seconds
+
+
+def auto_enqueue_new_scholar_enabled() -> bool:
+    if not settings.scheduler_enabled:
+        return False
+    if not settings.ingestion_automation_allowed:
+        return False
+    return bool(settings.ingestion_continuation_queue_enabled)
+
+
+async def enqueue_initial_scrape_job_for_scholar(
+    db_session: AsyncSession,
+    *,
+    profile,
+    user_id: int,
+) -> bool:
+    if not auto_enqueue_new_scholar_enabled():
+        return False
+    try:
+        await ingestion_queue_service.upsert_job(
+            db_session,
+            user_id=user_id,
+            scholar_profile_id=int(profile.id),
+            resume_cstart=0,
+            reason=INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON,
+            run_id=None,
+            delay_seconds=INITIAL_SCHOLAR_SCRAPE_QUEUE_DELAY_SECONDS,
+        )
+        await db_session.commit()
+    except Exception:
+        await db_session.rollback()
+        structured_log(
+            logger,
+            "warning",
+            "api.scholars.initial_scrape_enqueue_failed",
+            user_id=user_id,
+            scholar_profile_id=profile.id,
+        )
+        return False
+
+    structured_log(
+        logger,
+        "info",
+        "api.scholars.initial_scrape_enqueued",
+        user_id=user_id,
+        scholar_profile_id=profile.id,
+        reason=INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON,
+    )
+    return True
+
+
+def uploaded_image_media_path(scholar_profile_id: int) -> str:
+    return f"/scholar-images/{scholar_profile_id}/upload"
+
+
+def serialize_scholar(profile) -> dict[str, object]:
+    uploaded_image_url = None
+    if profile.profile_image_upload_path:
+        uploaded_image_url = uploaded_image_media_path(int(profile.id))
+
+    profile_image_url, profile_image_source = scholar_search_hints.resolve_profile_image(
+        profile,
+        uploaded_image_url=uploaded_image_url,
+    )
+
+    return {
+        "id": int(profile.id),
+        "scholar_id": profile.scholar_id,
+        "display_name": profile.display_name,
+        "profile_image_url": profile_image_url,
+        "profile_image_source": profile_image_source,
+        "is_enabled": bool(profile.is_enabled),
+        "baseline_completed": bool(profile.baseline_completed),
+        "last_run_dt": profile.last_run_dt,
+        "last_run_status": (profile.last_run_status.value if profile.last_run_status is not None else None),
+    }
+
+
+async def hydrate_scholar_metadata_if_needed(
+    db_session: AsyncSession,
+    *,
+    profile,
+    source: ScholarSource,
+    user_id: int,
+):
+    if not needs_metadata_hydration(profile):
+        return profile
+
+    should_skip, remaining_seconds = is_create_hydration_rate_limited()
+    if should_skip:
+        structured_log(
+            logger,
+            "info",
+            "api.scholars.create_metadata_hydration_skipped",
+            reason="scholar_request_throttle_active",
+            user_id=user_id,
+            scholar_profile_id=profile.id,
+            retry_after_seconds=round(remaining_seconds, 3),
+        )
+        return profile
+
+    try:
+        return await asyncio.wait_for(
+            scholar_service.hydrate_profile_metadata(
+                db_session,
+                profile=profile,
+                source=source,
+            ),
+            timeout=CREATE_METADATA_HYDRATION_TIMEOUT_SECONDS,
+        )
+    except TimeoutError:
+        structured_log(
+            logger,
+            "info",
+            "api.scholars.create_metadata_hydration_skipped",
+            reason="create_timeout",
+            user_id=user_id,
+            scholar_profile_id=profile.id,
+        )
+    except Exception:
+        structured_log(
+            logger,
+            "warning",
+            "api.scholars.create_metadata_hydration_failed",
+            user_id=user_id,
+            scholar_profile_id=profile.id,
+        )
+    return profile
+
+
+def search_kwargs() -> dict[str, Any]:
+    return {
+        "network_error_retries": settings.ingestion_network_error_retries,
+        "retry_backoff_seconds": settings.ingestion_retry_backoff_seconds,
+        "search_enabled": settings.scholar_name_search_enabled,
+        "cache_ttl_seconds": settings.scholar_name_search_cache_ttl_seconds,
+        "blocked_cache_ttl_seconds": settings.scholar_name_search_blocked_cache_ttl_seconds,
+        "cache_max_entries": settings.scholar_name_search_cache_max_entries,
+        "min_interval_seconds": settings.scholar_name_search_min_interval_seconds,
+        "interval_jitter_seconds": settings.scholar_name_search_interval_jitter_seconds,
+        "cooldown_block_threshold": settings.scholar_name_search_cooldown_block_threshold,
+        "cooldown_seconds": settings.scholar_name_search_cooldown_seconds,
+        "retry_alert_threshold": settings.scholar_name_search_alert_retry_count_threshold,
+        "cooldown_rejection_alert_threshold": (settings.scholar_name_search_alert_cooldown_rejections_threshold),
+    }
+
+
+def search_response_data(query: str, parsed) -> dict[str, object]:
+    return {
+        "query": query.strip(),
+        "state": parsed.state.value,
+        "state_reason": parsed.state_reason,
+        "action_hint": scholar_search_hints.scrape_state_hint(
+            state=parsed.state,
+            state_reason=parsed.state_reason,
+        ),
+        "candidates": [
+            {
+                "scholar_id": item.scholar_id,
+                "display_name": item.display_name,
+                "affiliation": item.affiliation,
+                "email_domain": item.email_domain,
+                "cited_by_count": item.cited_by_count,
+                "interests": item.interests,
+                "profile_url": item.profile_url,
+                "profile_image_url": item.profile_image_url,
+            }
+            for item in parsed.candidates
+        ],
+        "warnings": parsed.warnings,
+    }
+
+
+async def read_uploaded_image(image: UploadFile) -> bytes:
+    try:
+        return await image.read()
+    finally:
+        await image.close()
+
+
+async def require_user_profile(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_profile_id: int,
+):
+    profile = await scholar_service.get_user_scholar_by_id(
+        db_session,
+        user_id=user_id,
+        scholar_profile_id=scholar_profile_id,
+    )
+    if profile is None:
+        raise ApiException(
+            status_code=404,
+            code="scholar_not_found",
+            message="Scholar not found.",
+        )
+    return profile
diff --git a/app/api/routers/scholars.py b/app/api/routers/scholars.py
index 87fd04a..7095471 100644
--- a/app/api/routers/scholars.py
+++ b/app/api/routers/scholars.py
@@ -1,8 +1,6 @@
 from __future__ import annotations
 
-import asyncio
 import logging
-from typing import Any
 
 from fastapi import APIRouter, Depends, File, Query, Request, UploadFile
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -10,6 +8,15 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from app.api.deps import get_api_current_user
 from app.api.errors import ApiException
 from app.api.responses import success_payload
+from app.api.routers.scholar_helpers import (
+    enqueue_initial_scrape_job_for_scholar,
+    hydrate_scholar_metadata_if_needed,
+    read_uploaded_image,
+    require_user_profile,
+    search_kwargs,
+    search_response_data,
+    serialize_scholar,
+)
 from app.api.runtime_deps import get_scholar_source
 from app.api.schemas import (
     DataExportEnvelope,
@@ -25,231 +32,14 @@ from app.api.schemas import (
 from app.db.models import User
 from app.db.session import get_db_session
 from app.logging_utils import structured_log
-from app.services.ingestion import queue as ingestion_queue_service
 from app.services.portability import application as import_export_service
-from app.services.scholar import rate_limit as scholar_rate_limit
 from app.services.scholar.source import ScholarSource
 from app.services.scholars import application as scholar_service
-from app.services.scholars import search_hints as scholar_search_hints
 from app.settings import settings
 
 logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/scholars", tags=["api-scholars"])
-CREATE_METADATA_HYDRATION_TIMEOUT_SECONDS = 5.0
-INITIAL_SCHOLAR_SCRAPE_QUEUE_DELAY_SECONDS = 0
-INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON = "scholar_added_initial_scrape"
-
-
-def _needs_metadata_hydration(profile) -> bool:
-    if not profile.profile_image_url:
-        return True
-    return not (profile.display_name or "").strip()
-
-
-def _is_create_hydration_rate_limited() -> tuple[bool, float]:
-    remaining_seconds = scholar_rate_limit.remaining_scholar_slot_seconds(
-        min_interval_seconds=float(settings.ingestion_min_request_delay_seconds),
-    )
-    return remaining_seconds > 0, remaining_seconds
-
-
-def _auto_enqueue_new_scholar_enabled() -> bool:
-    if not settings.scheduler_enabled:
-        return False
-    if not settings.ingestion_automation_allowed:
-        return False
-    return bool(settings.ingestion_continuation_queue_enabled)
-
-
-async def _enqueue_initial_scrape_job_for_scholar(
-    db_session: AsyncSession,
-    *,
-    profile,
-    user_id: int,
-) -> bool:
-    if not _auto_enqueue_new_scholar_enabled():
-        return False
-    try:
-        await ingestion_queue_service.upsert_job(
-            db_session,
-            user_id=user_id,
-            scholar_profile_id=int(profile.id),
-            resume_cstart=0,
-            reason=INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON,
-            run_id=None,
-            delay_seconds=INITIAL_SCHOLAR_SCRAPE_QUEUE_DELAY_SECONDS,
-        )
-        await db_session.commit()
-    except Exception:
-        await db_session.rollback()
-        structured_log(
-            logger,
-            "warning",
-            "api.scholars.initial_scrape_enqueue_failed",
-            user_id=user_id,
-            scholar_profile_id=profile.id,
-        )
-        return False
-
-    structured_log(
-        logger,
-        "info",
-        "api.scholars.initial_scrape_enqueued",
-        user_id=user_id,
-        scholar_profile_id=profile.id,
-        reason=INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON,
-    )
-    return True
-
-
-def _uploaded_image_media_path(scholar_profile_id: int) -> str:
-    return f"/scholar-images/{scholar_profile_id}/upload"
-
-
-def _serialize_scholar(profile) -> dict[str, object]:
-    uploaded_image_url = None
-    if profile.profile_image_upload_path:
-        uploaded_image_url = _uploaded_image_media_path(int(profile.id))
-
-    profile_image_url, profile_image_source = scholar_search_hints.resolve_profile_image(
-        profile,
-        uploaded_image_url=uploaded_image_url,
-    )
-
-    return {
-        "id": int(profile.id),
-        "scholar_id": profile.scholar_id,
-        "display_name": profile.display_name,
-        "profile_image_url": profile_image_url,
-        "profile_image_source": profile_image_source,
-        "is_enabled": bool(profile.is_enabled),
-        "baseline_completed": bool(profile.baseline_completed),
-        "last_run_dt": profile.last_run_dt,
-        "last_run_status": (profile.last_run_status.value if profile.last_run_status is not None else None),
-    }
-
-
-async def _hydrate_scholar_metadata_if_needed(
-    db_session: AsyncSession,
-    *,
-    profile,
-    source: ScholarSource,
-    user_id: int,
-):
-    if not _needs_metadata_hydration(profile):
-        return profile
-
-    should_skip, remaining_seconds = _is_create_hydration_rate_limited()
-    if should_skip:
-        structured_log(
-            logger,
-            "info",
-            "api.scholars.create_metadata_hydration_skipped",
-            reason="scholar_request_throttle_active",
-            user_id=user_id,
-            scholar_profile_id=profile.id,
-            retry_after_seconds=round(remaining_seconds, 3),
-        )
-        return profile
-
-    try:
-        return await asyncio.wait_for(
-            scholar_service.hydrate_profile_metadata(
-                db_session,
-                profile=profile,
-                source=source,
-            ),
-            timeout=CREATE_METADATA_HYDRATION_TIMEOUT_SECONDS,
-        )
-    except TimeoutError:
-        structured_log(
-            logger,
-            "info",
-            "api.scholars.create_metadata_hydration_skipped",
-            reason="create_timeout",
-            user_id=user_id,
-            scholar_profile_id=profile.id,
-        )
-    except Exception:
-        structured_log(
-            logger,
-            "warning",
-            "api.scholars.create_metadata_hydration_failed",
-            user_id=user_id,
-            scholar_profile_id=profile.id,
-        )
-    return profile
-
-
-def _search_kwargs() -> dict[str, Any]:
-    return {
-        "network_error_retries": settings.ingestion_network_error_retries,
-        "retry_backoff_seconds": settings.ingestion_retry_backoff_seconds,
-        "search_enabled": settings.scholar_name_search_enabled,
-        "cache_ttl_seconds": settings.scholar_name_search_cache_ttl_seconds,
-        "blocked_cache_ttl_seconds": settings.scholar_name_search_blocked_cache_ttl_seconds,
-        "cache_max_entries": settings.scholar_name_search_cache_max_entries,
-        "min_interval_seconds": settings.scholar_name_search_min_interval_seconds,
-        "interval_jitter_seconds": settings.scholar_name_search_interval_jitter_seconds,
-        "cooldown_block_threshold": settings.scholar_name_search_cooldown_block_threshold,
-        "cooldown_seconds": settings.scholar_name_search_cooldown_seconds,
-        "retry_alert_threshold": settings.scholar_name_search_alert_retry_count_threshold,
-        "cooldown_rejection_alert_threshold": (settings.scholar_name_search_alert_cooldown_rejections_threshold),
-    }
-
-
-def _search_response_data(query: str, parsed) -> dict[str, object]:
-    return {
-        "query": query.strip(),
-        "state": parsed.state.value,
-        "state_reason": parsed.state_reason,
-        "action_hint": scholar_search_hints.scrape_state_hint(
-            state=parsed.state,
-            state_reason=parsed.state_reason,
-        ),
-        "candidates": [
-            {
-                "scholar_id": item.scholar_id,
-                "display_name": item.display_name,
-                "affiliation": item.affiliation,
-                "email_domain": item.email_domain,
-                "cited_by_count": item.cited_by_count,
-                "interests": item.interests,
-                "profile_url": item.profile_url,
-                "profile_image_url": item.profile_image_url,
-            }
-            for item in parsed.candidates
-        ],
-        "warnings": parsed.warnings,
-    }
-
-
-async def _read_uploaded_image(image: UploadFile) -> bytes:
-    try:
-        return await image.read()
-    finally:
-        await image.close()
-
-
-async def _require_user_profile(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_profile_id: int,
-):
-    profile = await scholar_service.get_user_scholar_by_id(
-        db_session,
-        user_id=user_id,
-        scholar_profile_id=scholar_profile_id,
-    )
-    if profile is None:
-        raise ApiException(
-            status_code=404,
-            code="scholar_not_found",
-            message="Scholar not found.",
-        )
-    return profile
 
 
 @router.get(
@@ -268,7 +58,7 @@ async def list_scholars(
     return success_payload(
         request,
         data={
-            "scholars": [_serialize_scholar(profile) for profile in scholars],
+            "scholars": [serialize_scholar(profile) for profile in scholars],
         },
     )
 
@@ -354,13 +144,13 @@ async def create_scholar(
             message=str(exc),
         ) from exc
     structured_log(logger, "info", "api.scholars.created", user_id=current_user.id, scholar_profile_id=created.id)
-    did_queue_initial_scrape = await _enqueue_initial_scrape_job_for_scholar(
+    did_queue_initial_scrape = await enqueue_initial_scrape_job_for_scholar(
         db_session,
         profile=created,
         user_id=current_user.id,
     )
     if not did_queue_initial_scrape:
-        created = await _hydrate_scholar_metadata_if_needed(
+        created = await hydrate_scholar_metadata_if_needed(
             db_session,
             profile=created,
             source=source,
@@ -369,7 +159,7 @@ async def create_scholar(
 
     return success_payload(
         request,
-        data=_serialize_scholar(created),
+        data=serialize_scholar(created),
     )
 
 
@@ -391,7 +181,7 @@ async def search_scholars(
             db_session=db_session,
             query=query,
             limit=limit,
-            **_search_kwargs(),
+            **search_kwargs(),
         )
     except scholar_service.ScholarServiceError as exc:
         raise ApiException(
@@ -411,7 +201,7 @@ async def search_scholars(
     )
     return success_payload(
         request,
-        data=_search_response_data(query, parsed),
+        data=search_response_data(query, parsed),
     )
 
 
@@ -447,7 +237,7 @@ async def toggle_scholar(
     )
     return success_payload(
         request,
-        data=_serialize_scholar(updated),
+        data=serialize_scholar(updated),
     )
 
 
@@ -528,7 +318,7 @@ async def update_scholar_image_url(
     )
     return success_payload(
         request,
-        data=_serialize_scholar(updated),
+        data=serialize_scholar(updated),
     )
 
 
@@ -543,13 +333,13 @@ async def upload_scholar_image(
     db_session: AsyncSession = Depends(get_db_session),
     current_user: User = Depends(get_api_current_user),
 ):
-    profile = await _require_user_profile(
+    profile = await require_user_profile(
         db_session,
         user_id=current_user.id,
         scholar_profile_id=scholar_profile_id,
     )
 
-    image_bytes = await _read_uploaded_image(image)
+    image_bytes = await read_uploaded_image(image)
     try:
         updated = await scholar_service.set_profile_image_upload(
             db_session,
@@ -578,7 +368,7 @@ async def upload_scholar_image(
     )
     return success_payload(
         request,
-        data=_serialize_scholar(updated),
+        data=serialize_scholar(updated),
     )
 
 
@@ -612,5 +402,5 @@ async def clear_scholar_image_customization(
     structured_log(logger, "info", "api.scholars.image_cleared", user_id=current_user.id, scholar_profile_id=updated.id)
     return success_payload(
         request,
-        data=_serialize_scholar(updated),
+        data=serialize_scholar(updated),
     )
diff --git a/app/services/ingestion/queue_runner.py b/app/services/ingestion/queue_runner.py
new file mode 100644
index 0000000..82baab3
--- /dev/null
+++ b/app/services/ingestion/queue_runner.py
@@ -0,0 +1,379 @@
+from __future__ import annotations
+
+import logging
+from datetime import UTC, datetime
+
+from sqlalchemy import select
+
+from app.db.models import QueueItemStatus, RunTriggerType, ScholarProfile, UserSetting
+from app.db.session import get_session_factory
+from app.logging_utils import structured_log
+from app.services.ingestion import queue as queue_service
+from app.services.ingestion.application import (
+    RunAlreadyInProgressError,
+    RunBlockedBySafetyPolicyError,
+    ScholarIngestionService,
+)
+from app.services.scholar.source import LiveScholarSource
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+def _effective_request_delay_seconds(value: int | None, *, floor: int) -> int:
+    try:
+        parsed = int(value) if value is not None else floor
+    except (TypeError, ValueError):
+        parsed = floor
+    return max(floor, parsed)
+
+
+class QueueJobRunner:
+    def __init__(
+        self,
+        *,
+        tick_seconds: int,
+        network_error_retries: int,
+        retry_backoff_seconds: float,
+        max_pages_per_scholar: int,
+        page_size: int,
+        continuation_queue_enabled: bool,
+        continuation_base_delay_seconds: int,
+        continuation_max_delay_seconds: int,
+        continuation_max_attempts: int,
+        queue_batch_size: int,
+    ) -> None:
+        self._tick_seconds = tick_seconds
+        self._network_error_retries = network_error_retries
+        self._retry_backoff_seconds = retry_backoff_seconds
+        self._max_pages_per_scholar = max_pages_per_scholar
+        self._page_size = page_size
+        self._continuation_queue_enabled = continuation_queue_enabled
+        self._continuation_base_delay_seconds = continuation_base_delay_seconds
+        self._continuation_max_delay_seconds = continuation_max_delay_seconds
+        self._continuation_max_attempts = continuation_max_attempts
+        self._queue_batch_size = queue_batch_size
+        self._source = LiveScholarSource()
+
+    async def drain_continuation_queue(self) -> None:
+        now = datetime.now(UTC)
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            jobs = await queue_service.list_due_jobs(
+                session,
+                now=now,
+                limit=self._queue_batch_size,
+            )
+        for job in jobs:
+            await self._run_queue_job(job)
+
+    async def _drop_queue_job_if_max_attempts(
+        self,
+        job: queue_service.ContinuationQueueJob,
+    ) -> bool:
+        if job.attempt_count < self._continuation_max_attempts:
+            return False
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            dropped = await queue_service.mark_dropped(
+                session,
+                job_id=job.id,
+                reason="max_attempts_reached",
+            )
+            await session.commit()
+        if dropped is not None:
+            structured_log(
+                logger,
+                "warning",
+                "scheduler.queue_item_dropped_max_attempts",
+                queue_item_id=job.id,
+                user_id=job.user_id,
+                scholar_profile_id=job.scholar_profile_id,
+                attempt_count=job.attempt_count,
+                max_attempts=self._continuation_max_attempts,
+            )
+        return True
+
+    async def _mark_queue_job_retrying(
+        self,
+        job: queue_service.ContinuationQueueJob,
+    ) -> bool:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            queue_item = await queue_service.mark_retrying(session, job_id=job.id)
+            await session.commit()
+        if queue_item is None:
+            return False
+        return queue_item.status != QueueItemStatus.DROPPED.value
+
+    async def _queue_job_has_available_scholar(
+        self,
+        job: queue_service.ContinuationQueueJob,
+    ) -> bool:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            scholar_result = await session.execute(
+                select(ScholarProfile.id).where(
+                    ScholarProfile.user_id == job.user_id,
+                    ScholarProfile.id == job.scholar_profile_id,
+                    ScholarProfile.is_enabled.is_(True),
+                )
+            )
+            scholar_id = scholar_result.scalar_one_or_none()
+            if scholar_id is not None:
+                return True
+            dropped = await queue_service.mark_dropped(
+                session,
+                job_id=job.id,
+                reason="scholar_unavailable",
+            )
+            await session.commit()
+        if dropped is not None:
+            structured_log(
+                logger,
+                "info",
+                "scheduler.queue_item_dropped_scholar_unavailable",
+                queue_item_id=job.id,
+                user_id=job.user_id,
+                scholar_profile_id=job.scholar_profile_id,
+            )
+        return False
+
+    async def _reschedule_queue_job_lock_active(self, job: queue_service.ContinuationQueueJob) -> None:
+        session_factory = get_session_factory()
+        async with session_factory() as recovery_session:
+            await queue_service.reschedule_job(
+                recovery_session,
+                job_id=job.id,
+                delay_seconds=max(self._tick_seconds, 15),
+                reason="user_run_lock_active",
+                error="run_already_in_progress",
+            )
+            await recovery_session.commit()
+        structured_log(
+            logger,
+            "info",
+            "scheduler.queue_item_deferred_lock",
+            queue_item_id=job.id,
+            user_id=job.user_id,
+        )
+
+    async def _reschedule_queue_job_safety_cooldown(
+        self,
+        job: queue_service.ContinuationQueueJob,
+        exc: RunBlockedBySafetyPolicyError,
+    ) -> None:
+        cooldown_remaining_seconds = max(
+            self._tick_seconds,
+            int(exc.safety_state.get("cooldown_remaining_seconds") or 0),
+        )
+        session_factory = get_session_factory()
+        async with session_factory() as recovery_session:
+            await queue_service.reschedule_job(
+                recovery_session,
+                job_id=job.id,
+                delay_seconds=max(self._tick_seconds, cooldown_remaining_seconds),
+                reason="scrape_safety_cooldown",
+                error=str(exc.message),
+            )
+            await recovery_session.commit()
+        structured_log(
+            logger,
+            "info",
+            "scheduler.queue_item_deferred_safety_cooldown",
+            queue_item_id=job.id,
+            user_id=job.user_id,
+            reason=exc.safety_state.get("cooldown_reason"),
+            cooldown_remaining_seconds=cooldown_remaining_seconds,
+        )
+
+    async def _reschedule_queue_job_after_exception(
+        self,
+        job: queue_service.ContinuationQueueJob,
+        *,
+        exc: Exception,
+    ) -> None:
+        session_factory = get_session_factory()
+        async with session_factory() as recovery_session:
+            queue_item = await queue_service.increment_attempt_count(recovery_session, job_id=job.id)
+            if queue_item is None:
+                await recovery_session.commit()
+                return
+            if int(queue_item.attempt_count) >= self._continuation_max_attempts:
+                await queue_service.mark_dropped(
+                    recovery_session,
+                    job_id=job.id,
+                    reason="scheduler_exception_max_attempts",
+                    error=str(exc),
+                )
+                await recovery_session.commit()
+                structured_log(
+                    logger,
+                    "warning",
+                    "scheduler.queue_item_dropped_after_exception",
+                    queue_item_id=job.id,
+                    user_id=job.user_id,
+                    attempt_count=queue_item.attempt_count,
+                )
+                return
+            delay_seconds = queue_service.compute_backoff_seconds(
+                base_seconds=self._continuation_base_delay_seconds,
+                attempt_count=int(queue_item.attempt_count),
+                max_seconds=self._continuation_max_delay_seconds,
+            )
+            await queue_service.reschedule_job(
+                recovery_session,
+                job_id=job.id,
+                delay_seconds=delay_seconds,
+                reason="scheduler_exception",
+                error=str(exc),
+            )
+            await recovery_session.commit()
+        logger.exception("scheduler.queue_item_run_failed", extra={"queue_item_id": job.id, "user_id": job.user_id})
+
+    async def _load_request_delay_for_user(self, user_id: int, *, floor: int) -> int:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            result = await session.execute(
+                select(UserSetting.request_delay_seconds).where(UserSetting.user_id == user_id)
+            )
+            delay = result.scalar_one_or_none()
+        return _effective_request_delay_seconds(delay, floor=floor)
+
+    async def _run_ingestion_for_queue_job(
+        self,
+        job: queue_service.ContinuationQueueJob,
+        *,
+        request_delay_floor: int,
+    ):
+        request_delay_seconds = await self._load_request_delay_for_user(job.user_id, floor=request_delay_floor)
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            ingestion = ScholarIngestionService(source=self._source)
+            try:
+                return await ingestion.run_for_user(
+                    session,
+                    user_id=job.user_id,
+                    trigger_type=RunTriggerType.SCHEDULED,
+                    request_delay_seconds=request_delay_seconds,
+                    network_error_retries=self._network_error_retries,
+                    retry_backoff_seconds=self._retry_backoff_seconds,
+                    rate_limit_retries=settings.ingestion_rate_limit_retries,
+                    rate_limit_backoff_seconds=settings.ingestion_rate_limit_backoff_seconds,
+                    max_pages_per_scholar=self._max_pages_per_scholar,
+                    page_size=self._page_size,
+                    scholar_profile_ids={job.scholar_profile_id},
+                    start_cstart_by_scholar_id={job.scholar_profile_id: job.resume_cstart},
+                    auto_queue_continuations=self._continuation_queue_enabled,
+                    queue_delay_seconds=self._continuation_base_delay_seconds,
+                    alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
+                    alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
+                    alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
+                )
+            except RunAlreadyInProgressError:
+                await session.rollback()
+                await self._reschedule_queue_job_lock_active(job)
+            except RunBlockedBySafetyPolicyError as exc:
+                await session.rollback()
+                await self._reschedule_queue_job_safety_cooldown(job, exc)
+            except Exception as exc:
+                await session.rollback()
+                await self._reschedule_queue_job_after_exception(job, exc=exc)
+        return None
+
+    async def _finalize_queue_job_after_run(self, job: queue_service.ContinuationQueueJob, run_summary) -> None:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            if int(run_summary.failed_count) <= 0:
+                queue_item = await queue_service.reset_attempt_count(session, job_id=job.id)
+                await session.commit()
+                if queue_item is None:
+                    structured_log(
+                        logger,
+                        "info",
+                        "scheduler.queue_item_resolved",
+                        queue_item_id=job.id,
+                        user_id=job.user_id,
+                        run_id=run_summary.crawl_run_id,
+                        status=run_summary.status.value,
+                    )
+                    return
+                structured_log(
+                    logger,
+                    "info",
+                    "scheduler.queue_item_progressed",
+                    queue_item_id=job.id,
+                    user_id=job.user_id,
+                    run_id=run_summary.crawl_run_id,
+                    status=run_summary.status.value,
+                    attempt_count=int(queue_item.attempt_count),
+                )
+                return
+            queue_item = await queue_service.increment_attempt_count(session, job_id=job.id)
+            if queue_item is None:
+                await session.commit()
+                structured_log(
+                    logger,
+                    "info",
+                    "scheduler.queue_item_resolved",
+                    queue_item_id=job.id,
+                    user_id=job.user_id,
+                    run_id=run_summary.crawl_run_id,
+                    status=run_summary.status.value,
+                )
+                return
+            if int(queue_item.attempt_count) >= self._continuation_max_attempts:
+                await queue_service.mark_dropped(session, job_id=job.id, reason="max_attempts_after_run")
+                await session.commit()
+                structured_log(
+                    logger,
+                    "warning",
+                    "scheduler.queue_item_dropped_max_attempts_after_run",
+                    queue_item_id=job.id,
+                    user_id=job.user_id,
+                    attempt_count=queue_item.attempt_count,
+                    run_id=run_summary.crawl_run_id,
+                    status=run_summary.status.value,
+                )
+                return
+            delay_seconds = queue_service.compute_backoff_seconds(
+                base_seconds=self._continuation_base_delay_seconds,
+                attempt_count=int(queue_item.attempt_count),
+                max_seconds=self._continuation_max_delay_seconds,
+            )
+            await queue_service.reschedule_job(
+                session,
+                job_id=job.id,
+                delay_seconds=delay_seconds,
+                reason=queue_item.reason,
+                error=queue_item.last_error,
+            )
+            await session.commit()
+        structured_log(
+            logger,
+            "info",
+            "scheduler.queue_item_rescheduled_failed",
+            queue_item_id=job.id,
+            user_id=job.user_id,
+            run_id=run_summary.crawl_run_id,
+            status=run_summary.status.value,
+            attempt_count=int(queue_item.attempt_count),
+            delay_seconds=delay_seconds,
+        )
+
+    async def _run_queue_job(self, job: queue_service.ContinuationQueueJob) -> None:
+        if await self._drop_queue_job_if_max_attempts(job):
+            return
+        if not await self._mark_queue_job_retrying(job):
+            return
+        if not await self._queue_job_has_available_scholar(job):
+            return
+        from app.services.settings import application as user_settings_service
+
+        request_delay_floor = user_settings_service.resolve_request_delay_minimum(
+            settings.ingestion_min_request_delay_seconds,
+        )
+        run_summary = await self._run_ingestion_for_queue_job(job, request_delay_floor=request_delay_floor)
+        if run_summary is None:
+            return
+        await self._finalize_queue_job_after_run(job, run_summary)
diff --git a/app/services/ingestion/scheduler.py b/app/services/ingestion/scheduler.py
index 12ba3ef..975cb53 100644
--- a/app/services/ingestion/scheduler.py
+++ b/app/services/ingestion/scheduler.py
@@ -6,24 +6,21 @@ from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
 
 from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import (
     CrawlRun,
-    QueueItemStatus,
     RunTriggerType,
-    ScholarProfile,
     User,
     UserSetting,
 )
 from app.db.session import get_session_factory
 from app.logging_utils import structured_log
-from app.services.ingestion import queue as queue_service
 from app.services.ingestion.application import (
     RunAlreadyInProgressError,
     RunBlockedBySafetyPolicyError,
     ScholarIngestionService,
 )
+from app.services.ingestion.queue_runner import QueueJobRunner
 from app.services.scholar.source import LiveScholarSource
 from app.services.settings import application as user_settings_service
 from app.settings import settings
@@ -85,6 +82,18 @@ class SchedulerService:
         self._queue_batch_size = max(1, int(queue_batch_size))
         self._task: asyncio.Task[None] | None = None
         self._source = LiveScholarSource()
+        self._queue_runner = QueueJobRunner(
+            tick_seconds=self._tick_seconds,
+            network_error_retries=self._network_error_retries,
+            retry_backoff_seconds=self._retry_backoff_seconds,
+            max_pages_per_scholar=self._max_pages_per_scholar,
+            page_size=self._page_size,
+            continuation_queue_enabled=self._continuation_queue_enabled,
+            continuation_base_delay_seconds=self._continuation_base_delay_seconds,
+            continuation_max_delay_seconds=self._continuation_max_delay_seconds,
+            continuation_max_attempts=self._continuation_max_attempts,
+            queue_batch_size=self._queue_batch_size,
+        )
 
     async def start(self) -> None:
         if not self._enabled:
@@ -136,7 +145,7 @@ class SchedulerService:
 
     async def _tick_once(self) -> None:
         if self._continuation_queue_enabled:
-            await self._drain_continuation_queue()
+            await self._queue_runner.drain_continuation_queue()
 
         await self._drain_pdf_queue()
 
@@ -281,313 +290,6 @@ class SchedulerService:
             new_publication_count=run_summary.new_publication_count,
         )
 
-    async def _drain_continuation_queue(self) -> None:
-        now = datetime.now(UTC)
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            jobs = await queue_service.list_due_jobs(
-                session,
-                now=now,
-                limit=self._queue_batch_size,
-            )
-        for job in jobs:
-            await self._run_queue_job(job)
-
-    async def _drop_queue_job_if_max_attempts(
-        self,
-        job: queue_service.ContinuationQueueJob,
-    ) -> bool:
-        if job.attempt_count < self._continuation_max_attempts:
-            return False
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            dropped = await queue_service.mark_dropped(
-                session,
-                job_id=job.id,
-                reason="max_attempts_reached",
-            )
-            await session.commit()
-        if dropped is not None:
-            structured_log(
-                logger,
-                "warning",
-                "scheduler.queue_item_dropped_max_attempts",
-                queue_item_id=job.id,
-                user_id=job.user_id,
-                scholar_profile_id=job.scholar_profile_id,
-                attempt_count=job.attempt_count,
-                max_attempts=self._continuation_max_attempts,
-            )
-        return True
-
-    async def _mark_queue_job_retrying(
-        self,
-        job: queue_service.ContinuationQueueJob,
-    ) -> bool:
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            queue_item = await queue_service.mark_retrying(session, job_id=job.id)
-            await session.commit()
-        if queue_item is None:
-            return False
-        return queue_item.status != QueueItemStatus.DROPPED.value
-
-    async def _queue_job_has_available_scholar(
-        self,
-        job: queue_service.ContinuationQueueJob,
-    ) -> bool:
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            scholar_result = await session.execute(
-                select(ScholarProfile.id).where(
-                    ScholarProfile.user_id == job.user_id,
-                    ScholarProfile.id == job.scholar_profile_id,
-                    ScholarProfile.is_enabled.is_(True),
-                )
-            )
-            scholar_id = scholar_result.scalar_one_or_none()
-            if scholar_id is not None:
-                return True
-            dropped = await queue_service.mark_dropped(
-                session,
-                job_id=job.id,
-                reason="scholar_unavailable",
-            )
-            await session.commit()
-        if dropped is not None:
-            structured_log(
-                logger,
-                "info",
-                "scheduler.queue_item_dropped_scholar_unavailable",
-                queue_item_id=job.id,
-                user_id=job.user_id,
-                scholar_profile_id=job.scholar_profile_id,
-            )
-        return False
-
-    async def _reschedule_queue_job_lock_active(self, job: queue_service.ContinuationQueueJob) -> None:
-        session_factory = get_session_factory()
-        async with session_factory() as recovery_session:
-            await queue_service.reschedule_job(
-                recovery_session,
-                job_id=job.id,
-                delay_seconds=max(self._tick_seconds, 15),
-                reason="user_run_lock_active",
-                error="run_already_in_progress",
-            )
-            await recovery_session.commit()
-        structured_log(
-            logger,
-            "info",
-            "scheduler.queue_item_deferred_lock",
-            queue_item_id=job.id,
-            user_id=job.user_id,
-        )
-
-    async def _reschedule_queue_job_safety_cooldown(
-        self,
-        job: queue_service.ContinuationQueueJob,
-        exc: RunBlockedBySafetyPolicyError,
-    ) -> None:
-        cooldown_remaining_seconds = max(
-            self._tick_seconds,
-            int(exc.safety_state.get("cooldown_remaining_seconds") or 0),
-        )
-        session_factory = get_session_factory()
-        async with session_factory() as recovery_session:
-            await queue_service.reschedule_job(
-                recovery_session,
-                job_id=job.id,
-                delay_seconds=max(self._tick_seconds, cooldown_remaining_seconds),
-                reason="scrape_safety_cooldown",
-                error=str(exc.message),
-            )
-            await recovery_session.commit()
-        structured_log(
-            logger,
-            "info",
-            "scheduler.queue_item_deferred_safety_cooldown",
-            queue_item_id=job.id,
-            user_id=job.user_id,
-            reason=exc.safety_state.get("cooldown_reason"),
-            cooldown_remaining_seconds=cooldown_remaining_seconds,
-        )
-
-    async def _reschedule_queue_job_after_exception(
-        self,
-        job: queue_service.ContinuationQueueJob,
-        *,
-        exc: Exception,
-    ) -> None:
-        session_factory = get_session_factory()
-        async with session_factory() as recovery_session:
-            queue_item = await queue_service.increment_attempt_count(recovery_session, job_id=job.id)
-            if queue_item is None:
-                await recovery_session.commit()
-                return
-            if int(queue_item.attempt_count) >= self._continuation_max_attempts:
-                await queue_service.mark_dropped(
-                    recovery_session,
-                    job_id=job.id,
-                    reason="scheduler_exception_max_attempts",
-                    error=str(exc),
-                )
-                await recovery_session.commit()
-                structured_log(
-                    logger,
-                    "warning",
-                    "scheduler.queue_item_dropped_after_exception",
-                    queue_item_id=job.id,
-                    user_id=job.user_id,
-                    attempt_count=queue_item.attempt_count,
-                )
-                return
-            delay_seconds = queue_service.compute_backoff_seconds(
-                base_seconds=self._continuation_base_delay_seconds,
-                attempt_count=int(queue_item.attempt_count),
-                max_seconds=self._continuation_max_delay_seconds,
-            )
-            await queue_service.reschedule_job(
-                recovery_session,
-                job_id=job.id,
-                delay_seconds=delay_seconds,
-                reason="scheduler_exception",
-                error=str(exc),
-            )
-            await recovery_session.commit()
-        logger.exception("scheduler.queue_item_run_failed", extra={"queue_item_id": job.id, "user_id": job.user_id})
-
-    async def _run_ingestion_for_queue_job(
-        self,
-        job: queue_service.ContinuationQueueJob,
-    ):
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            request_delay_seconds = await self._load_request_delay_for_user(session, user_id=job.user_id)
-            ingestion = ScholarIngestionService(source=self._source)
-            try:
-                return await ingestion.run_for_user(
-                    session,
-                    user_id=job.user_id,
-                    trigger_type=RunTriggerType.SCHEDULED,
-                    request_delay_seconds=request_delay_seconds,
-                    network_error_retries=self._network_error_retries,
-                    retry_backoff_seconds=self._retry_backoff_seconds,
-                    rate_limit_retries=settings.ingestion_rate_limit_retries,
-                    rate_limit_backoff_seconds=settings.ingestion_rate_limit_backoff_seconds,
-                    max_pages_per_scholar=self._max_pages_per_scholar,
-                    page_size=self._page_size,
-                    scholar_profile_ids={job.scholar_profile_id},
-                    start_cstart_by_scholar_id={job.scholar_profile_id: job.resume_cstart},
-                    auto_queue_continuations=self._continuation_queue_enabled,
-                    queue_delay_seconds=self._continuation_base_delay_seconds,
-                    alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
-                    alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
-                    alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
-                )
-            except RunAlreadyInProgressError:
-                await session.rollback()
-                await self._reschedule_queue_job_lock_active(job)
-            except RunBlockedBySafetyPolicyError as exc:
-                await session.rollback()
-                await self._reschedule_queue_job_safety_cooldown(job, exc)
-            except Exception as exc:
-                await session.rollback()
-                await self._reschedule_queue_job_after_exception(job, exc=exc)
-        return None
-
-    async def _finalize_queue_job_after_run(self, job: queue_service.ContinuationQueueJob, run_summary) -> None:
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            if int(run_summary.failed_count) <= 0:
-                queue_item = await queue_service.reset_attempt_count(session, job_id=job.id)
-                await session.commit()
-                if queue_item is None:
-                    structured_log(
-                        logger,
-                        "info",
-                        "scheduler.queue_item_resolved",
-                        queue_item_id=job.id,
-                        user_id=job.user_id,
-                        run_id=run_summary.crawl_run_id,
-                        status=run_summary.status.value,
-                    )
-                    return
-                structured_log(
-                    logger,
-                    "info",
-                    "scheduler.queue_item_progressed",
-                    queue_item_id=job.id,
-                    user_id=job.user_id,
-                    run_id=run_summary.crawl_run_id,
-                    status=run_summary.status.value,
-                    attempt_count=int(queue_item.attempt_count),
-                )
-                return
-            queue_item = await queue_service.increment_attempt_count(session, job_id=job.id)
-            if queue_item is None:
-                await session.commit()
-                structured_log(
-                    logger,
-                    "info",
-                    "scheduler.queue_item_resolved",
-                    queue_item_id=job.id,
-                    user_id=job.user_id,
-                    run_id=run_summary.crawl_run_id,
-                    status=run_summary.status.value,
-                )
-                return
-            if int(queue_item.attempt_count) >= self._continuation_max_attempts:
-                await queue_service.mark_dropped(session, job_id=job.id, reason="max_attempts_after_run")
-                await session.commit()
-                structured_log(
-                    logger,
-                    "warning",
-                    "scheduler.queue_item_dropped_max_attempts_after_run",
-                    queue_item_id=job.id,
-                    user_id=job.user_id,
-                    attempt_count=queue_item.attempt_count,
-                    run_id=run_summary.crawl_run_id,
-                    status=run_summary.status.value,
-                )
-                return
-            delay_seconds = queue_service.compute_backoff_seconds(
-                base_seconds=self._continuation_base_delay_seconds,
-                attempt_count=int(queue_item.attempt_count),
-                max_seconds=self._continuation_max_delay_seconds,
-            )
-            await queue_service.reschedule_job(
-                session,
-                job_id=job.id,
-                delay_seconds=delay_seconds,
-                reason=queue_item.reason,
-                error=queue_item.last_error,
-            )
-            await session.commit()
-        structured_log(
-            logger,
-            "info",
-            "scheduler.queue_item_rescheduled_failed",
-            queue_item_id=job.id,
-            user_id=job.user_id,
-            run_id=run_summary.crawl_run_id,
-            status=run_summary.status.value,
-            attempt_count=int(queue_item.attempt_count),
-            delay_seconds=delay_seconds,
-        )
-
-    async def _run_queue_job(self, job: queue_service.ContinuationQueueJob) -> None:
-        if await self._drop_queue_job_if_max_attempts(job):
-            return
-        if not await self._mark_queue_job_retrying(job):
-            return
-        if not await self._queue_job_has_available_scholar(job):
-            return
-        run_summary = await self._run_ingestion_for_queue_job(job)
-        if run_summary is None:
-            return
-        await self._finalize_queue_job_after_run(job, run_summary)
-
     async def _drain_pdf_queue(self) -> None:
         from app.services.publications.pdf_queue import drain_ready_jobs
 
@@ -608,15 +310,3 @@ class SchedulerService:
                     )
             except Exception:
                 logger.exception("scheduler.pdf_queue_drain_failed", extra={})
-
-    async def _load_request_delay_for_user(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_id: int,
-    ) -> int:
-        result = await db_session.execute(
-            select(UserSetting.request_delay_seconds).where(UserSetting.user_id == user_id)
-        )
-        delay = result.scalar_one_or_none()
-        return _effective_request_delay_seconds(delay)
diff --git a/tests/unit/test_scholars_create_hydration.py b/tests/unit/test_scholars_create_hydration.py
index b452b44..0694b32 100644
--- a/tests/unit/test_scholars_create_hydration.py
+++ b/tests/unit/test_scholars_create_hydration.py
@@ -2,7 +2,7 @@ from types import SimpleNamespace
 
 import pytest
 
-from app.api.routers import scholars as scholars_router
+from app.api.routers import scholar_helpers
 
 
 class _FakeSession:
@@ -31,17 +31,17 @@ async def test_create_hydration_skips_when_global_throttle_active(
         raise AssertionError("hydrate_profile_metadata should not run when throttle is active")
 
     monkeypatch.setattr(
-        scholars_router.scholar_rate_limit,
+        scholar_helpers.scholar_rate_limit,
         "remaining_scholar_slot_seconds",
         lambda **_kwargs: 3.5,
     )
     monkeypatch.setattr(
-        scholars_router.scholar_service,
+        scholar_helpers.scholar_service,
         "hydrate_profile_metadata",
         _fail_hydration,
     )
 
-    result = await scholars_router._hydrate_scholar_metadata_if_needed(
+    result = await scholar_helpers.hydrate_scholar_metadata_if_needed(
         db_session=None,
         profile=profile,
         source=object(),
@@ -66,17 +66,17 @@ async def test_create_hydration_runs_when_throttle_is_clear(
         return profile
 
     monkeypatch.setattr(
-        scholars_router.scholar_rate_limit,
+        scholar_helpers.scholar_rate_limit,
         "remaining_scholar_slot_seconds",
         lambda **_kwargs: 0.0,
     )
     monkeypatch.setattr(
-        scholars_router.scholar_service,
+        scholar_helpers.scholar_service,
         "hydrate_profile_metadata",
         _hydrate_profile_metadata,
     )
 
-    result = await scholars_router._hydrate_scholar_metadata_if_needed(
+    result = await scholar_helpers.hydrate_scholar_metadata_if_needed(
         db_session=None,
         profile=profile,
         source=object(),
@@ -98,17 +98,17 @@ async def test_initial_scrape_job_enqueued_on_create(
         upsert_calls.append(kwargs)
 
     monkeypatch.setattr(
-        scholars_router,
-        "_auto_enqueue_new_scholar_enabled",
+        scholar_helpers,
+        "auto_enqueue_new_scholar_enabled",
         lambda: True,
     )
     monkeypatch.setattr(
-        scholars_router.ingestion_queue_service,
+        scholar_helpers.ingestion_queue_service,
         "upsert_job",
         _fake_upsert_job,
     )
 
-    queued = await scholars_router._enqueue_initial_scrape_job_for_scholar(
+    queued = await scholar_helpers.enqueue_initial_scrape_job_for_scholar(
         session,
         profile=profile,
         user_id=9,
@@ -117,7 +117,7 @@ async def test_initial_scrape_job_enqueued_on_create(
     assert queued is True
     assert session.commits == 1
     assert session.rollbacks == 0
-    assert upsert_calls[0]["reason"] == scholars_router.INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON
+    assert upsert_calls[0]["reason"] == scholar_helpers.INITIAL_SCHOLAR_SCRAPE_QUEUE_REASON
 
 
 @pytest.mark.asyncio
@@ -128,12 +128,12 @@ async def test_initial_scrape_job_not_enqueued_when_disabled(
     session = _FakeSession()
 
     monkeypatch.setattr(
-        scholars_router,
-        "_auto_enqueue_new_scholar_enabled",
+        scholar_helpers,
+        "auto_enqueue_new_scholar_enabled",
         lambda: False,
     )
 
-    queued = await scholars_router._enqueue_initial_scrape_job_for_scholar(
+    queued = await scholar_helpers.enqueue_initial_scrape_job_for_scholar(
         session,
         profile=profile,
         user_id=11,
-- 
2.49.1


From 74249fa24c5c427135d2ff0e569097ae1d53854b Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 15:49:27 +0100
Subject: [PATCH 30/38] fix: resolve all mypy type errors across service
 modules

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/services/arxiv/client.py                   |  2 +-
 app/services/dbops/application.py              | 10 +++++-----
 app/services/ingestion/scheduler.py            |  7 ++++---
 app/services/ingestion/scholar_processing.py   |  2 +-
 app/services/portability/exporting.py          |  2 +-
 app/services/publications/pdf_queue_queries.py |  7 ++++---
 app/services/publications/queries.py           |  9 +++++----
 app/services/publications/read_state.py        | 10 ++++++----
 app/services/runs/queue_queries.py             |  4 +++-
 app/services/scholars/author_search_cache.py   | 17 +++++++++--------
 10 files changed, 39 insertions(+), 31 deletions(-)

diff --git a/app/services/arxiv/client.py b/app/services/arxiv/client.py
index 27f048f..41de63d 100644
--- a/app/services/arxiv/client.py
+++ b/app/services/arxiv/client.py
@@ -232,7 +232,7 @@ async def _request_arxiv_feed(
         timeout_value = _timeout_seconds(timeout_seconds)
         headers = {"User-Agent": f"scholar-scraper/1.0 (mailto:{_contact_email(request_email)})"}
         async with httpx.AsyncClient(timeout=timeout_value, follow_redirects=True, headers=headers) as client:
-            return await client.get(_ARXIV_API_URL, params=params)
+            return await client.get(_ARXIV_API_URL, params=params)  # type: ignore[arg-type]
 
     return await run_with_global_arxiv_limit(
         fetch=_fetch,
diff --git a/app/services/dbops/application.py b/app/services/dbops/application.py
index 7c59033..a5fa077 100644
--- a/app/services/dbops/application.py
+++ b/app/services/dbops/application.py
@@ -3,7 +3,7 @@ from __future__ import annotations
 from datetime import UTC, datetime
 from typing import Any
 
-from sqlalchemy import delete, exists, func, select, update
+from sqlalchemy import CursorResult, delete, exists, func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import DataRepairJob, IngestionQueueItem, Publication, ScholarProfile, ScholarPublication
@@ -152,7 +152,7 @@ def _job_summary(
 
 
 async def _delete_links_for_targets(db_session: AsyncSession, *, target_scholar_profile_ids: list[int]) -> int:
-    result = await db_session.execute(
+    result: CursorResult[Any] = await db_session.execute(  # type: ignore[assignment]
         delete(ScholarPublication).where(ScholarPublication.scholar_profile_id.in_(target_scholar_profile_ids))
     )
     return int(result.rowcount or 0)
@@ -167,7 +167,7 @@ async def _delete_queue_for_targets(
     stmt = delete(IngestionQueueItem).where(IngestionQueueItem.scholar_profile_id.in_(target_scholar_profile_ids))
     if user_id is not None:
         stmt = stmt.where(IngestionQueueItem.user_id == user_id)
-    result = await db_session.execute(stmt)
+    result: CursorResult[Any] = await db_session.execute(stmt)  # type: ignore[assignment]
     return int(result.rowcount or 0)
 
 
@@ -180,7 +180,7 @@ async def _reset_scholar_tracking_state(
     stmt = update(ScholarProfile).where(ScholarProfile.id.in_(target_scholar_profile_ids))
     if user_id is not None:
         stmt = stmt.where(ScholarProfile.user_id == user_id)
-    result = await db_session.execute(
+    result: CursorResult[Any] = await db_session.execute(  # type: ignore[assignment]
         stmt.values(
             baseline_completed=False,
             last_initial_page_fingerprint_sha256=None,
@@ -193,7 +193,7 @@ async def _reset_scholar_tracking_state(
 
 
 async def _delete_orphan_publications(db_session: AsyncSession) -> int:
-    result = await db_session.execute(
+    result: CursorResult[Any] = await db_session.execute(  # type: ignore[assignment]
         delete(Publication).where(~exists(select(1).where(ScholarPublication.publication_id == Publication.id)))
     )
     return int(result.rowcount or 0)
diff --git a/app/services/ingestion/scheduler.py b/app/services/ingestion/scheduler.py
index 975cb53..23b70d0 100644
--- a/app/services/ingestion/scheduler.py
+++ b/app/services/ingestion/scheduler.py
@@ -4,6 +4,7 @@ import asyncio
 import logging
 from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
+from typing import Any
 
 from sqlalchemy import select
 
@@ -158,7 +159,7 @@ class SchedulerService:
                 continue
             await self._run_candidate(candidate)
 
-    async def _load_candidate_rows(self) -> list[tuple]:
+    async def _load_candidate_rows(self) -> list[Any]:
         session_factory = get_session_factory()
         async with session_factory() as session:
             result = await session.execute(
@@ -173,10 +174,10 @@ class SchedulerService:
                 .where(User.is_active.is_(True), UserSetting.auto_run_enabled.is_(True))
                 .order_by(UserSetting.user_id.asc())
             )
-            return result.all()
+            return list(result.all())
 
     @staticmethod
-    def _candidate_from_row(row: tuple, *, now_utc: datetime) -> _AutoRunCandidate | None:
+    def _candidate_from_row(row: Any, *, now_utc: datetime) -> _AutoRunCandidate | None:
         user_id, run_interval_minutes, request_delay_seconds, cooldown_until, cooldown_reason = row
         if cooldown_until is not None and cooldown_until.tzinfo is None:
             cooldown_until = cooldown_until.replace(tzinfo=UTC)
diff --git a/app/services/ingestion/scholar_processing.py b/app/services/ingestion/scholar_processing.py
index 393f85c..3096dee 100644
--- a/app/services/ingestion/scholar_processing.py
+++ b/app/services/ingestion/scholar_processing.py
@@ -547,7 +547,7 @@ async def run_scholar_iteration(
     queue_delay_seconds: int,
 ) -> RunProgress:
     progress = RunProgress()
-    scholar_kwargs = {
+    scholar_kwargs: dict[str, Any] = {
         "request_delay_seconds": request_delay_seconds,
         "network_error_retries": network_error_retries,
         "retry_backoff_seconds": retry_backoff_seconds,
diff --git a/app/services/portability/exporting.py b/app/services/portability/exporting.py
index cd88cc6..0589498 100644
--- a/app/services/portability/exporting.py
+++ b/app/services/portability/exporting.py
@@ -23,7 +23,7 @@ def _serialize_export_scholar(profile: ScholarProfile) -> dict[str, Any]:
     }
 
 
-def _serialize_export_publication(row: tuple[Any, ...]) -> dict[str, Any]:
+def _serialize_export_publication(row: Any) -> dict[str, Any]:
     (
         scholar_id,
         cluster_id,
diff --git a/app/services/publications/pdf_queue_queries.py b/app/services/publications/pdf_queue_queries.py
index d8dad1f..a0ee0b2 100644
--- a/app/services/publications/pdf_queue_queries.py
+++ b/app/services/publications/pdf_queue_queries.py
@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
+from typing import Any
 
 from sqlalchemy import Select, and_, func, literal, or_, select, union_all
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -43,7 +44,7 @@ def _retry_item_label(display_name: str | None, scholar_id: str | None) -> str:
 def _retry_item_from_publication(
     publication: Publication,
     *,
-    link_row: tuple | None,
+    link_row: Any | None,
 ) -> PublicationListItem:
     if link_row is None:
         scholar_profile_id = 0
@@ -270,7 +271,7 @@ class PdfQueueListItem:
     display_identifier: DisplayIdentifier | None = None
 
 
-def _queue_item_from_row(row: tuple) -> PdfQueueListItem:
+def _queue_item_from_row(row: Any) -> PdfQueueListItem:
     return PdfQueueListItem(
         publication_id=int(row[0]),
         title=str(row[1] or ""),
@@ -292,7 +293,7 @@ def _queue_item_from_row(row: tuple) -> PdfQueueListItem:
 async def _hydrated_queue_items(
     db_session: AsyncSession,
     *,
-    rows: list[tuple],
+    rows: list[Any],
 ) -> list[PdfQueueListItem]:
     items = [_queue_item_from_row(row) for row in rows]
     return await identifier_service.overlay_pdf_queue_items_with_display_identifiers(
diff --git a/app/services/publications/queries.py b/app/services/publications/queries.py
index fb03b61..2de11d6 100644
--- a/app/services/publications/queries.py
+++ b/app/services/publications/queries.py
@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 from datetime import datetime
+from typing import Any
 
-from sqlalchemy import Select, case, func, select
+from sqlalchemy import Select, case, false as sa_false, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import (
@@ -124,7 +125,7 @@ def publications_query(
         stmt = stmt.where(ScholarPublication.is_read.is_(False))
     if mode == MODE_LATEST:
         if latest_run_id is None:
-            return stmt.where(False)
+            return stmt.where(sa_false())
         stmt = stmt.where(ScholarPublication.first_seen_run_id == latest_run_id)
     if snapshot_before is not None:
         stmt = stmt.where(ScholarPublication.created_at <= snapshot_before)
@@ -195,7 +196,7 @@ async def get_publication_item_for_user(
 
 
 def publication_list_item_from_row(
-    row: tuple,
+    row: Any,
     *,
     latest_run_id: int | None,
 ) -> PublicationListItem:
@@ -232,7 +233,7 @@ def publication_list_item_from_row(
     )
 
 
-def unread_item_from_row(row: tuple) -> UnreadPublicationItem:
+def unread_item_from_row(row: Any) -> UnreadPublicationItem:
     (
         publication_id,
         scholar_profile_id,
diff --git a/app/services/publications/read_state.py b/app/services/publications/read_state.py
index b816d59..2a56b61 100644
--- a/app/services/publications/read_state.py
+++ b/app/services/publications/read_state.py
@@ -1,6 +1,8 @@
 from __future__ import annotations
 
-from sqlalchemy import select, tuple_, update
+from typing import Any
+
+from sqlalchemy import CursorResult, select, tuple_, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import ScholarProfile, ScholarPublication
@@ -34,7 +36,7 @@ async def mark_all_unread_as_read_for_user(
         )
         .values(is_read=True)
     )
-    result = await db_session.execute(stmt)
+    result: CursorResult[Any] = await db_session.execute(stmt)  # type: ignore[assignment]
     await db_session.commit()
     return int(result.rowcount or 0)
 
@@ -62,7 +64,7 @@ async def mark_selected_as_read_for_user(
         )
         .values(is_read=True)
     )
-    result = await db_session.execute(stmt)
+    result: CursorResult[Any] = await db_session.execute(stmt)  # type: ignore[assignment]
     await db_session.commit()
     return int(result.rowcount or 0)
 
@@ -85,6 +87,6 @@ async def set_publication_favorite_for_user(
         )
         .values(is_favorite=bool(is_favorite))
     )
-    result = await db_session.execute(stmt)
+    result: CursorResult[Any] = await db_session.execute(stmt)  # type: ignore[assignment]
     await db_session.commit()
     return int(result.rowcount or 0)
diff --git a/app/services/runs/queue_queries.py b/app/services/runs/queue_queries.py
index 588a47e..2d1127a 100644
--- a/app/services/runs/queue_queries.py
+++ b/app/services/runs/queue_queries.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Any
+
 from sqlalchemy import and_, select
 
 from app.db.models import IngestionQueueItem, ScholarProfile
@@ -38,7 +40,7 @@ def queue_item_select(*, user_id: int):
     )
 
 
-def queue_list_item_from_row(row: tuple) -> QueueListItem:
+def queue_list_item_from_row(row: Any) -> QueueListItem:
     (
         item_id,
         scholar_profile_id,
diff --git a/app/services/scholars/author_search_cache.py b/app/services/scholars/author_search_cache.py
index 01be986..a0bab2f 100644
--- a/app/services/scholars/author_search_cache.py
+++ b/app/services/scholars/author_search_cache.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from datetime import UTC, datetime, timedelta
+from typing import cast
 
 from sqlalchemy import delete, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -136,14 +137,14 @@ def _deserialize_parsed_author_search_page(payload: object) -> ParsedAuthorSearc
         state_reason=str(payload.get("state_reason", "")).strip() or "unknown",
         candidates=[
             ScholarSearchCandidate(
-                scholar_id=item["scholar_id"],
-                display_name=item["display_name"],
-                affiliation=item["affiliation"],
-                email_domain=item["email_domain"],
-                cited_by_count=item["cited_by_count"],
-                interests=item["interests"],
-                profile_url=item["profile_url"],
-                profile_image_url=item["profile_image_url"],
+                scholar_id=cast(str, item["scholar_id"]),
+                display_name=cast(str, item["display_name"]),
+                affiliation=cast("str | None", item["affiliation"]),
+                email_domain=cast("str | None", item["email_domain"]),
+                cited_by_count=cast("int | None", item["cited_by_count"]),
+                interests=cast("list[str]", item["interests"]),
+                profile_url=cast(str, item["profile_url"]),
+                profile_image_url=cast("str | None", item["profile_image_url"]),
             )
             for item in normalized_candidates
         ],
-- 
2.49.1


From 3fd9132176807108dd6a6e83a1d0395e49ff8ac5 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 16:07:24 +0100
Subject: [PATCH 31/38] refactor: fix naming, remove duplicate code from
 decomposition
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Rename _int_or_default → int_or_default (public API, was using private convention)
- Extract shared pdf_queue utilities (utcnow, event_row, queued_job, status constants) to pdf_queue_common.py to avoid circular imports
- Consolidate _effective_request_delay_seconds into queue_runner.py with explicit floor parameter
- Update tests to match new function locations and names

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/services/ingestion/application.py         |  8 +--
 app/services/ingestion/queue_runner.py        |  4 +-
 app/services/ingestion/run_completion.py      |  8 +--
 app/services/ingestion/scheduler.py           | 22 ++----
 app/services/publications/pdf_queue.py        | 57 ++++------------
 app/services/publications/pdf_queue_common.py | 49 ++++++++++++++
 .../publications/pdf_queue_resolution.py      | 67 +++++--------------
 .../unit/test_publication_pdf_queue_policy.py | 10 +--
 tests/unit/test_request_delay_policy.py       |  7 +-
 9 files changed, 104 insertions(+), 128 deletions(-)
 create mode 100644 app/services/publications/pdf_queue_common.py

diff --git a/app/services/ingestion/application.py b/app/services/ingestion/application.py
index f1a906e..01e4dd1 100644
--- a/app/services/ingestion/application.py
+++ b/app/services/ingestion/application.py
@@ -22,7 +22,7 @@ from app.services.ingestion.constants import RUN_LOCK_NAMESPACE
 from app.services.ingestion.enrichment import EnrichmentRunner
 from app.services.ingestion.pagination import PaginationEngine
 from app.services.ingestion.run_completion import (
-    _int_or_default,
+    int_or_default,
     complete_run_for_user,
     run_execution_summary,
 )
@@ -135,7 +135,7 @@ class ScholarIngestionService:
         policy_minimum = user_settings_service.resolve_request_delay_minimum(
             settings.ingestion_min_request_delay_seconds
         )
-        return max(policy_minimum, _int_or_default(value, policy_minimum))
+        return max(policy_minimum, int_or_default(value, policy_minimum))
 
     async def _load_user_settings_for_run(
         self,
@@ -333,13 +333,13 @@ class ScholarIngestionService:
         alert_retry_scheduled_threshold: int = 3,
     ) -> tuple[CrawlRun, list[ScholarProfile], dict[int, int]]:
         effective_delay = self._effective_request_delay_seconds(request_delay_seconds)
-        if effective_delay != _int_or_default(request_delay_seconds, effective_delay):
+        if effective_delay != int_or_default(request_delay_seconds, effective_delay):
             structured_log(
                 logger,
                 "warning",
                 "ingestion.delay_coerced",
                 user_id=user_id,
-                requested_request_delay_seconds=_int_or_default(request_delay_seconds, 0),
+                requested_request_delay_seconds=int_or_default(request_delay_seconds, 0),
                 effective_request_delay_seconds=effective_delay,
                 policy_minimum_request_delay_seconds=user_settings_service.resolve_request_delay_minimum(
                     settings.ingestion_min_request_delay_seconds
diff --git a/app/services/ingestion/queue_runner.py b/app/services/ingestion/queue_runner.py
index 82baab3..4eaaa98 100644
--- a/app/services/ingestion/queue_runner.py
+++ b/app/services/ingestion/queue_runner.py
@@ -20,7 +20,7 @@ from app.settings import settings
 logger = logging.getLogger(__name__)
 
 
-def _effective_request_delay_seconds(value: int | None, *, floor: int) -> int:
+def effective_request_delay_seconds(value: int | None, *, floor: int) -> int:
     try:
         parsed = int(value) if value is not None else floor
     except (TypeError, ValueError):
@@ -238,7 +238,7 @@ class QueueJobRunner:
                 select(UserSetting.request_delay_seconds).where(UserSetting.user_id == user_id)
             )
             delay = result.scalar_one_or_none()
-        return _effective_request_delay_seconds(delay, floor=floor)
+        return effective_request_delay_seconds(delay, floor=floor)
 
     async def _run_ingestion_for_queue_job(
         self,
diff --git a/app/services/ingestion/run_completion.py b/app/services/ingestion/run_completion.py
index 450550d..b50f770 100644
--- a/app/services/ingestion/run_completion.py
+++ b/app/services/ingestion/run_completion.py
@@ -35,7 +35,7 @@ from app.settings import settings
 logger = logging.getLogger(__name__)
 
 
-def _int_or_default(value: Any, default: int = 0) -> int:
+def int_or_default(value: Any, default: int = 0) -> int:
     try:
         return int(value)
     except (TypeError, ValueError):
@@ -68,7 +68,7 @@ def summarize_failures(
     scholars_with_retries_count = 0
     retry_exhausted_count = 0
     for entry in scholar_results:
-        retries_for_entry = max(0, _int_or_default(entry.get("attempt_count"), 0) - 1)
+        retries_for_entry = max(0, int_or_default(entry.get("attempt_count"), 0) - 1)
         if retries_for_entry > 0:
             retries_scheduled_count += retries_for_entry
             scholars_with_retries_count += 1
@@ -347,7 +347,7 @@ def find_scholar_result_index(
     scholar_profile_id: int,
 ) -> int | None:
     for index, result_entry in enumerate(scholar_results):
-        current_scholar_id = _int_or_default(result_entry.get("scholar_profile_id"), 0)
+        current_scholar_id = int_or_default(result_entry.get("scholar_profile_id"), 0)
         if current_scholar_id == scholar_profile_id:
             return index
     return None
@@ -372,7 +372,7 @@ def apply_outcome_to_progress(
     progress: RunProgress,
     outcome: ScholarProcessingOutcome,
 ) -> None:
-    scholar_profile_id = _int_or_default(outcome.result_entry.get("scholar_profile_id"), 0)
+    scholar_profile_id = int_or_default(outcome.result_entry.get("scholar_profile_id"), 0)
     if scholar_profile_id <= 0:
         raise RuntimeError("Scholar outcome missing valid scholar_profile_id.")
     prior_index = find_scholar_result_index(
diff --git a/app/services/ingestion/scheduler.py b/app/services/ingestion/scheduler.py
index 23b70d0..1e5f08c 100644
--- a/app/services/ingestion/scheduler.py
+++ b/app/services/ingestion/scheduler.py
@@ -21,7 +21,7 @@ from app.services.ingestion.application import (
     RunBlockedBySafetyPolicyError,
     ScholarIngestionService,
 )
-from app.services.ingestion.queue_runner import QueueJobRunner
+from app.services.ingestion.queue_runner import QueueJobRunner, effective_request_delay_seconds
 from app.services.scholar.source import LiveScholarSource
 from app.services.settings import application as user_settings_service
 from app.settings import settings
@@ -29,19 +29,6 @@ from app.settings import settings
 logger = logging.getLogger(__name__)
 
 
-def _request_delay_floor_seconds() -> int:
-    return user_settings_service.resolve_request_delay_minimum(settings.ingestion_min_request_delay_seconds)
-
-
-def _effective_request_delay_seconds(value: int | None) -> int:
-    floor = _request_delay_floor_seconds()
-    try:
-        parsed = int(value) if value is not None else floor
-    except (TypeError, ValueError):
-        parsed = floor
-    return max(floor, parsed)
-
-
 @dataclass(frozen=True)
 class _AutoRunCandidate:
     user_id: int
@@ -195,7 +182,12 @@ class SchedulerService:
         return _AutoRunCandidate(
             user_id=int(user_id),
             run_interval_minutes=int(run_interval_minutes),
-            request_delay_seconds=_effective_request_delay_seconds(request_delay_seconds),
+            request_delay_seconds=effective_request_delay_seconds(
+                request_delay_seconds,
+                floor=user_settings_service.resolve_request_delay_minimum(
+                    settings.ingestion_min_request_delay_seconds
+                ),
+            ),
             cooldown_until=cooldown_until,
             cooldown_reason=(str(cooldown_reason).strip() if cooldown_reason else None),
         )
diff --git a/app/services/publications/pdf_queue.py b/app/services/publications/pdf_queue.py
index eef0d61..25f2437 100644
--- a/app/services/publications/pdf_queue.py
+++ b/app/services/publications/pdf_queue.py
@@ -2,16 +2,24 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
-from datetime import UTC, datetime
+from datetime import datetime
 
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import (
     PublicationPdfJob,
-    PublicationPdfJobEvent,
     User,
 )
+from app.services.publications.pdf_queue_common import (
+    PDF_STATUS_FAILED,
+    PDF_STATUS_QUEUED,
+    PDF_STATUS_RESOLVED,
+    PDF_STATUS_RUNNING,
+    event_row,
+    queued_job,
+    utcnow,
+)
 from app.services.publications.pdf_queue_queries import (
     missing_pdf_candidates,
     retry_item_for_publication_id,
@@ -21,10 +29,6 @@ from app.services.publications.types import PublicationListItem
 from app.settings import settings
 
 PDF_STATUS_UNTRACKED = "untracked"
-PDF_STATUS_QUEUED = "queued"
-PDF_STATUS_RUNNING = "running"
-PDF_STATUS_RESOLVED = "resolved"
-PDF_STATUS_FAILED = "failed"
 
 PDF_EVENT_QUEUED = "queued"
 
@@ -43,10 +47,6 @@ class PdfBulkQueueResult:
     queued_count: int
 
 
-def _utcnow() -> datetime:
-    return datetime.now(UTC)
-
-
 def _publication_ids(rows: list[PublicationListItem]) -> list[int]:
     return sorted({row.publication_id for row in rows})
 
@@ -122,7 +122,7 @@ def _cooldown_active(
 ) -> bool:
     if last_attempt_at is None:
         return False
-    elapsed = (_utcnow() - last_attempt_at).total_seconds()
+    elapsed = (utcnow() - last_attempt_at).total_seconds()
     return elapsed < _retry_interval_seconds_for_attempt_count(int(attempt_count))
 
 
@@ -147,37 +147,8 @@ def _can_enqueue_job(
     )
 
 
-def _event_row(
-    *,
-    publication_id: int,
-    user_id: int | None,
-    event_type: str,
-    status: str | None,
-) -> PublicationPdfJobEvent:
-    return PublicationPdfJobEvent(
-        publication_id=publication_id,
-        user_id=user_id,
-        event_type=event_type,
-        status=status,
-    )
-
-
-def _queued_job(
-    *,
-    publication_id: int,
-    user_id: int,
-) -> PublicationPdfJob:
-    now = _utcnow()
-    return PublicationPdfJob(
-        publication_id=publication_id,
-        status=PDF_STATUS_QUEUED,
-        queued_at=now,
-        last_requested_by_user_id=user_id,
-    )
-
-
 def _mark_job_queued(job: PublicationPdfJob, *, user_id: int) -> None:
-    now = _utcnow()
+    now = utcnow()
     job.status = PDF_STATUS_QUEUED
     job.queued_at = now
     job.last_requested_by_user_id = user_id
@@ -236,13 +207,13 @@ async def _enqueue_rows(
         if not _can_enqueue_job(job, force_retry=force_retry):
             continue
         if job is None:
-            job = _queued_job(publication_id=row.publication_id, user_id=user_id)
+            job = queued_job(publication_id=row.publication_id, user_id=user_id)
             jobs[row.publication_id] = job
             db_session.add(job)
         else:
             _mark_job_queued(job, user_id=user_id)
         db_session.add(
-            _event_row(
+            event_row(
                 publication_id=row.publication_id,
                 user_id=user_id,
                 event_type=PDF_EVENT_QUEUED,
diff --git a/app/services/publications/pdf_queue_common.py b/app/services/publications/pdf_queue_common.py
new file mode 100644
index 0000000..46c2143
--- /dev/null
+++ b/app/services/publications/pdf_queue_common.py
@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from app.db.models import PublicationPdfJob, PublicationPdfJobEvent
+
+PDF_STATUS_QUEUED = "queued"
+PDF_STATUS_RUNNING = "running"
+PDF_STATUS_RESOLVED = "resolved"
+PDF_STATUS_FAILED = "failed"
+
+
+def utcnow() -> datetime:
+    return datetime.now(UTC)
+
+
+def event_row(
+    *,
+    publication_id: int,
+    user_id: int | None,
+    event_type: str,
+    status: str | None,
+    source: str | None = None,
+    failure_reason: str | None = None,
+    message: str | None = None,
+) -> PublicationPdfJobEvent:
+    return PublicationPdfJobEvent(
+        publication_id=publication_id,
+        user_id=user_id,
+        event_type=event_type,
+        status=status,
+        source=source,
+        failure_reason=failure_reason,
+        message=message,
+    )
+
+
+def queued_job(
+    *,
+    publication_id: int,
+    user_id: int,
+) -> PublicationPdfJob:
+    now = utcnow()
+    return PublicationPdfJob(
+        publication_id=publication_id,
+        status=PDF_STATUS_QUEUED,
+        queued_at=now,
+        last_requested_by_user_id=user_id,
+    )
diff --git a/app/services/publications/pdf_queue_resolution.py b/app/services/publications/pdf_queue_resolution.py
index d2d0fea..2e02a65 100644
--- a/app/services/publications/pdf_queue_resolution.py
+++ b/app/services/publications/pdf_queue_resolution.py
@@ -3,10 +3,19 @@ from __future__ import annotations
 import asyncio
 import logging
 
-from app.db.models import Publication, PublicationPdfJob, PublicationPdfJobEvent
+from app.db.models import Publication, PublicationPdfJob
 from app.db.session import get_session_factory
 from app.logging_utils import structured_log
 from app.services.publication_identifiers import application as identifier_service
+from app.services.publications.pdf_queue_common import (
+    PDF_STATUS_FAILED,
+    PDF_STATUS_QUEUED,
+    PDF_STATUS_RESOLVED,
+    PDF_STATUS_RUNNING,
+    event_row,
+    queued_job,
+    utcnow,
+)
 from app.services.publications.pdf_resolution_pipeline import (
     resolve_publication_pdf_outcome_for_row,
 )
@@ -17,11 +26,6 @@ from app.services.unpaywall.application import (
 )
 from app.settings import settings
 
-PDF_STATUS_QUEUED = "queued"
-PDF_STATUS_RUNNING = "running"
-PDF_STATUS_RESOLVED = "resolved"
-PDF_STATUS_FAILED = "failed"
-
 PDF_EVENT_ATTEMPT_STARTED = "attempt_started"
 PDF_EVENT_RESOLVED = "resolved"
 PDF_EVENT_FAILED = "failed"
@@ -30,47 +34,6 @@ logger = logging.getLogger(__name__)
 _scheduled_tasks: set[asyncio.Task[None]] = set()
 
 
-def _utcnow():
-    from datetime import UTC, datetime
-
-    return datetime.now(UTC)
-
-
-def _event_row(
-    *,
-    publication_id: int,
-    user_id: int | None,
-    event_type: str,
-    status: str | None,
-    source: str | None = None,
-    failure_reason: str | None = None,
-    message: str | None = None,
-) -> PublicationPdfJobEvent:
-    return PublicationPdfJobEvent(
-        publication_id=publication_id,
-        user_id=user_id,
-        event_type=event_type,
-        status=status,
-        source=source,
-        failure_reason=failure_reason,
-        message=message,
-    )
-
-
-def _queued_job(
-    *,
-    publication_id: int,
-    user_id: int,
-) -> PublicationPdfJob:
-    now = _utcnow()
-    return PublicationPdfJob(
-        publication_id=publication_id,
-        status=PDF_STATUS_QUEUED,
-        queued_at=now,
-        last_requested_by_user_id=user_id,
-    )
-
-
 async def _mark_attempt_started(
     *,
     publication_id: int,
@@ -80,13 +43,13 @@ async def _mark_attempt_started(
     async with session_factory() as db_session:
         job = await db_session.get(PublicationPdfJob, publication_id)
         if job is None:
-            job = _queued_job(publication_id=publication_id, user_id=user_id)
+            job = queued_job(publication_id=publication_id, user_id=user_id)
             db_session.add(job)
         job.status = PDF_STATUS_RUNNING
-        job.last_attempt_at = _utcnow()
+        job.last_attempt_at = utcnow()
         job.attempt_count = int(job.attempt_count) + 1
         db_session.add(
-            _event_row(
+            event_row(
                 publication_id=publication_id,
                 user_id=user_id,
                 event_type=PDF_EVENT_ATTEMPT_STARTED,
@@ -142,7 +105,7 @@ def _apply_job_outcome(job: PublicationPdfJob, *, outcome: OaResolutionOutcome)
     job.last_source = outcome.source
     if outcome.pdf_url:
         job.status = PDF_STATUS_RESOLVED
-        job.resolved_at = _utcnow()
+        job.resolved_at = utcnow()
         job.last_failure_reason = None
         job.last_failure_detail = None
         return
@@ -178,7 +141,7 @@ async def _persist_outcome(
         _apply_job_outcome(job, outcome=outcome)
         event_type, status = _result_event(outcome)
         db_session.add(
-            _event_row(
+            event_row(
                 publication_id=publication_id,
                 user_id=user_id,
                 event_type=event_type,
diff --git a/tests/unit/test_publication_pdf_queue_policy.py b/tests/unit/test_publication_pdf_queue_policy.py
index ffc78d7..ca909a6 100644
--- a/tests/unit/test_publication_pdf_queue_policy.py
+++ b/tests/unit/test_publication_pdf_queue_policy.py
@@ -48,7 +48,7 @@ def _row(
 
 def test_pdf_queue_auto_enqueue_blocks_recent_attempt(monkeypatch: pytest.MonkeyPatch) -> None:
     now = datetime(2026, 2, 21, 12, 0, tzinfo=UTC)
-    monkeypatch.setattr(pdf_queue, "_utcnow", lambda: now)
+    monkeypatch.setattr(pdf_queue, "utcnow", lambda: now)
     monkeypatch.setattr(pdf_queue, "_auto_retry_first_interval_seconds", lambda: 3_600)
     monkeypatch.setattr(pdf_queue, "_auto_retry_interval_seconds", lambda: 86_400)
     monkeypatch.setattr(pdf_queue, "_auto_retry_max_attempts", lambda: 3)
@@ -62,7 +62,7 @@ def test_pdf_queue_auto_enqueue_blocks_recent_attempt(monkeypatch: pytest.Monkey
 
 def test_pdf_queue_auto_enqueue_blocks_recent_first_retry(monkeypatch: pytest.MonkeyPatch) -> None:
     now = datetime(2026, 2, 21, 12, 0, tzinfo=UTC)
-    monkeypatch.setattr(pdf_queue, "_utcnow", lambda: now)
+    monkeypatch.setattr(pdf_queue, "utcnow", lambda: now)
     monkeypatch.setattr(pdf_queue, "_auto_retry_first_interval_seconds", lambda: 3_600)
     monkeypatch.setattr(pdf_queue, "_auto_retry_interval_seconds", lambda: 86_400)
     monkeypatch.setattr(pdf_queue, "_auto_retry_max_attempts", lambda: 3)
@@ -76,7 +76,7 @@ def test_pdf_queue_auto_enqueue_blocks_recent_first_retry(monkeypatch: pytest.Mo
 
 def test_pdf_queue_auto_enqueue_blocks_after_max_attempts(monkeypatch: pytest.MonkeyPatch) -> None:
     now = datetime(2026, 2, 21, 12, 0, tzinfo=UTC)
-    monkeypatch.setattr(pdf_queue, "_utcnow", lambda: now)
+    monkeypatch.setattr(pdf_queue, "utcnow", lambda: now)
     monkeypatch.setattr(pdf_queue, "_auto_retry_first_interval_seconds", lambda: 3_600)
     monkeypatch.setattr(pdf_queue, "_auto_retry_interval_seconds", lambda: 86_400)
     monkeypatch.setattr(pdf_queue, "_auto_retry_max_attempts", lambda: 3)
@@ -90,7 +90,7 @@ def test_pdf_queue_auto_enqueue_blocks_after_max_attempts(monkeypatch: pytest.Mo
 
 def test_pdf_queue_auto_enqueue_blocks_second_retry_within_day(monkeypatch: pytest.MonkeyPatch) -> None:
     now = datetime(2026, 2, 21, 12, 0, tzinfo=UTC)
-    monkeypatch.setattr(pdf_queue, "_utcnow", lambda: now)
+    monkeypatch.setattr(pdf_queue, "utcnow", lambda: now)
     monkeypatch.setattr(pdf_queue, "_auto_retry_first_interval_seconds", lambda: 3_600)
     monkeypatch.setattr(pdf_queue, "_auto_retry_interval_seconds", lambda: 86_400)
     monkeypatch.setattr(pdf_queue, "_auto_retry_max_attempts", lambda: 3)
@@ -106,7 +106,7 @@ def test_pdf_queue_manual_requeue_bypasses_cooldown_and_max_attempts(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     now = datetime(2026, 2, 21, 12, 0, tzinfo=UTC)
-    monkeypatch.setattr(pdf_queue, "_utcnow", lambda: now)
+    monkeypatch.setattr(pdf_queue, "utcnow", lambda: now)
     monkeypatch.setattr(pdf_queue, "_auto_retry_first_interval_seconds", lambda: 3_600)
     monkeypatch.setattr(pdf_queue, "_auto_retry_interval_seconds", lambda: 86_400)
     monkeypatch.setattr(pdf_queue, "_auto_retry_max_attempts", lambda: 3)
diff --git a/tests/unit/test_request_delay_policy.py b/tests/unit/test_request_delay_policy.py
index 680e53d..411ae3c 100644
--- a/tests/unit/test_request_delay_policy.py
+++ b/tests/unit/test_request_delay_policy.py
@@ -4,6 +4,7 @@ from datetime import UTC, datetime
 
 from app.services.ingestion import scheduler as scheduler_module
 from app.services.ingestion.application import ScholarIngestionService
+from app.services.ingestion.queue_runner import effective_request_delay_seconds
 from app.settings import settings
 
 
@@ -25,9 +26,9 @@ def test_ingestion_effective_request_delay_respects_policy_minimum() -> None:
 def test_scheduler_effective_request_delay_respects_policy_minimum() -> None:
     previous = _set_policy_minimum(9)
     try:
-        assert scheduler_module._effective_request_delay_seconds(None) == 9
-        assert scheduler_module._effective_request_delay_seconds(6) == 9
-        assert scheduler_module._effective_request_delay_seconds(11) == 11
+        assert effective_request_delay_seconds(None, floor=9) == 9
+        assert effective_request_delay_seconds(6, floor=9) == 9
+        assert effective_request_delay_seconds(11, floor=9) == 11
     finally:
         object.__setattr__(settings, "ingestion_min_request_delay_seconds", previous)
 
-- 
2.49.1


From 2a6e573a523433ef3b29a6228bc5347f7594a46a Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 16:18:21 +0100
Subject: [PATCH 32/38] refactor: extract helpers from long functions in
 ingestion core

- Extract _load_unenriched_publications, _enrich_batch, _flush_and_sweep_duplicates from enrich_pending_publications
- Extract _sanitize_titles shared helper for title cleaning
- Extract _run_iteration_and_complete and _inline_enrich_and_finalize from run_for_user
- Extract _run_first_pass and _run_depth_pass from run_scholar_iteration
- Extract _finalize_successful_queue_job and _finalize_failed_queue_job from _finalize_queue_job_after_run

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/services/ingestion/application.py        |  59 ++++-
 app/services/ingestion/enrichment.py         | 223 ++++++++++---------
 app/services/ingestion/queue_runner.py       | 138 ++++++------
 app/services/ingestion/scholar_processing.py | 160 ++++++++-----
 4 files changed, 345 insertions(+), 235 deletions(-)

diff --git a/app/services/ingestion/application.py b/app/services/ingestion/application.py
index 01e4dd1..3f0ad48 100644
--- a/app/services/ingestion/application.py
+++ b/app/services/ingestion/application.py
@@ -576,6 +576,46 @@ class ScholarIngestionService:
             alert_network_failure_threshold=alert_network_failure_threshold,
             alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
         )
+        progress, failure_summary, alert_summary = await self._run_iteration_and_complete(
+            db_session,
+            run=run,
+            scholars=scholars,
+            user_id=user_id,
+            start_cstart_map=start_cstart_map,
+            paging=paging,
+            thresholds=thresholds,
+            auto_queue_continuations=auto_queue_continuations,
+            queue_delay_seconds=queue_delay_seconds,
+            idempotency_key=idempotency_key,
+        )
+        user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=user_id)
+        await self._inline_enrich_and_finalize(
+            db_session, run=run, user_settings=user_settings, intended_final_status=run.status
+        )
+        _log_run_completed(
+            run=run,
+            user_id=user_id,
+            scholars=scholars,
+            progress=progress,
+            failure_summary=failure_summary,
+            alert_summary=alert_summary,
+        )
+        return run_execution_summary(run=run, scholars=scholars, progress=progress)
+
+    async def _run_iteration_and_complete(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        scholars: list[ScholarProfile],
+        user_id: int,
+        start_cstart_map: dict[int, int],
+        paging: dict[str, Any],
+        thresholds: dict[str, Any],
+        auto_queue_continuations: bool,
+        queue_delay_seconds: int,
+        idempotency_key: str | None,
+    ) -> tuple[RunProgress, RunFailureSummary, RunAlertSummary]:
         progress = await run_scholar_iteration(
             db_session,
             pagination=self._pagination,
@@ -601,6 +641,16 @@ class ScholarIngestionService:
         if intended_final_status not in (RunStatus.CANCELED,):
             run.status = RunStatus.RESOLVING
         await db_session.commit()
+        return progress, failure_summary, alert_summary
+
+    async def _inline_enrich_and_finalize(
+        self,
+        db_session: AsyncSession,
+        *,
+        run: CrawlRun,
+        user_settings: Any,
+        intended_final_status: RunStatus,
+    ) -> None:
         try:
             await self._enrichment.enrich_pending_publications(
                 db_session,
@@ -612,15 +662,6 @@ class ScholarIngestionService:
         if run.status == RunStatus.RESOLVING:
             run.status = intended_final_status
         await db_session.commit()
-        _log_run_completed(
-            run=run,
-            user_id=user_id,
-            scholars=scholars,
-            progress=progress,
-            failure_summary=failure_summary,
-            alert_summary=alert_summary,
-        )
-        return run_execution_summary(run=run, scholars=scholars, progress=progress)
 
     async def _try_acquire_user_lock(
         self,
diff --git a/app/services/ingestion/enrichment.py b/app/services/ingestion/enrichment.py
index e63a6aa..9232efb 100644
--- a/app/services/ingestion/enrichment.py
+++ b/app/services/ingestion/enrichment.py
@@ -25,6 +25,18 @@ from app.settings import settings
 logger = logging.getLogger(__name__)
 
 
+def _sanitize_titles(publications: list) -> list[str]:
+    titles = []
+    for p in publications:
+        raw = getattr(p, "title_raw", None) or getattr(p, "title", None)
+        if not raw or not raw.strip():
+            continue
+        safe = " ".join(re.sub(r"[^\w\s]", " ", raw).split())
+        if safe:
+            titles.append(safe)
+    return titles
+
+
 class EnrichmentRunner:
     """Post-run OpenAlex enrichment logic.
 
@@ -44,31 +56,15 @@ class EnrichmentRunner:
             raise RuntimeError(f"Missing crawl_run for run_id={run_id}.")
         return status == RunStatus.CANCELED
 
-    async def enrich_pending_publications(
+    async def _load_unenriched_publications(
         self,
         db_session: AsyncSession,
         *,
         run_id: int,
-        openalex_api_key: str | None = None,
-    ) -> None:
-        """Enrich unenriched publications with OpenAlex data.
-
-        Stops immediately on budget exhaustion (429 with $0 remaining).
-        Sleeps 60s and continues on transient rate limits.
-        """
-        from app.services.openalex.client import (
-            OpenAlexBudgetExhaustedError,
-            OpenAlexClient,
-            OpenAlexRateLimitError,
-        )
-        from app.services.openalex.matching import find_best_match
-
+    ) -> tuple[int, list[Publication]]:
         run_result = await db_session.execute(select(CrawlRun.user_id).where(CrawlRun.id == run_id))
         user_id = run_result.scalar_one()
-
-        now = datetime.now(UTC)
-        cooldown_threshold = now - timedelta(days=7)
-
+        cooldown_threshold = datetime.now(UTC) - timedelta(days=7)
         stmt = (
             select(Publication)
             .join(ScholarPublication)
@@ -84,88 +80,51 @@ class EnrichmentRunner:
             .distinct()
         )
         result = await db_session.execute(stmt)
-        publications = list(result.scalars().all())
+        return user_id, list(result.scalars().all())
 
-        if not publications:
-            return
+    async def _enrich_batch(
+        self,
+        db_session: AsyncSession,
+        *,
+        batch: list[Publication],
+        run_id: int,
+        openalex_works: list,
+        now: datetime,
+        arxiv_lookup_allowed: bool,
+    ) -> tuple[bool, bool]:
+        from app.services.openalex.matching import find_best_match
 
-        resolved_key = openalex_api_key or settings.openalex_api_key
-        client = OpenAlexClient(api_key=resolved_key, mailto=settings.crossref_api_mailto)
-        batch_size = 25
-        arxiv_lookup_allowed = True
-
-        for i in range(0, len(publications), batch_size):
+        for p in batch:
             if await self.run_is_canceled(db_session, run_id=run_id):
                 logger.info("ingestion.enrichment_aborted", extra={"run_id": run_id})
-                return
-            batch = publications[i : i + batch_size]
-            titles = [
-                " ".join(re.sub(r"[^\w\s]", " ", p.title_raw).split())
-                for p in batch
-                if p.title_raw and p.title_raw.strip()
-            ]
-
-            if not titles:
-                continue
-
-            try:
-                openalex_works = await client.get_works_by_filter(
-                    {"title.search": "|".join(titles)}, limit=batch_size * 3
-                )
-            except OpenAlexBudgetExhaustedError:
-                structured_log(
-                    logger,
-                    "warning",
-                    "ingestion.openalex_budget_exhausted",
-                    run_id=run_id,
-                )
-                break
-            except OpenAlexRateLimitError:
-                structured_log(
-                    logger,
-                    "warning",
-                    "ingestion.openalex_rate_limited",
-                    run_id=run_id,
-                )
-                await asyncio.sleep(60)
-                continue
-            except Exception as e:
-                structured_log(
-                    logger,
-                    "warning",
-                    "ingestion.openalex_enrichment_failed",
-                    error=str(e),
-                    run_id=run_id,
-                )
-                continue
-
-            for p in batch:
-                if await self.run_is_canceled(db_session, run_id=run_id):
-                    logger.info("ingestion.enrichment_aborted", extra={"run_id": run_id})
-                    return
-
-                p.openalex_last_attempt_at = now
-                arxiv_lookup_allowed = await self._discover_identifiers_for_enrichment(
-                    db_session,
-                    publication=p,
-                    run_id=run_id,
-                    allow_arxiv_lookup=arxiv_lookup_allowed,
-                )
-
-                match = find_best_match(
-                    target_title=p.title_raw,
-                    target_year=p.year,
-                    target_authors=p.author_text or "",
-                    candidates=openalex_works,
-                )
-                if match:
-                    p.year = match.publication_year or p.year
-                    p.citation_count = match.cited_by_count or p.citation_count
-                    p.pdf_url = match.oa_url or p.pdf_url
-                    p.openalex_enriched = True
+                return False, arxiv_lookup_allowed
+            p.openalex_last_attempt_at = now
+            arxiv_lookup_allowed = await self._discover_identifiers_for_enrichment(
+                db_session,
+                publication=p,
+                run_id=run_id,
+                allow_arxiv_lookup=arxiv_lookup_allowed,
+            )
+            match = find_best_match(
+                target_title=p.title_raw,
+                target_year=p.year,
+                target_authors=p.author_text or "",
+                candidates=openalex_works,
+            )
+            if match:
+                p.year = match.publication_year or p.year
+                p.citation_count = match.cited_by_count or p.citation_count
+                p.pdf_url = match.oa_url or p.pdf_url
+                p.openalex_enriched = True
+        return True, arxiv_lookup_allowed
 
+    async def _flush_and_sweep_duplicates(
+        self,
+        db_session: AsyncSession,
+        *,
+        run_id: int,
+    ) -> None:
         await db_session.flush()
-
         from app.services.publications.dedup import sweep_identifier_duplicates
 
         merge_count = await sweep_identifier_duplicates(db_session)
@@ -178,6 +137,64 @@ class EnrichmentRunner:
                 run_id=run_id,
             )
 
+    async def enrich_pending_publications(
+        self,
+        db_session: AsyncSession,
+        *,
+        run_id: int,
+        openalex_api_key: str | None = None,
+    ) -> None:
+        from app.services.openalex.client import (
+            OpenAlexBudgetExhaustedError,
+            OpenAlexClient,
+            OpenAlexRateLimitError,
+        )
+
+        _, publications = await self._load_unenriched_publications(db_session, run_id=run_id)
+        if not publications:
+            return
+
+        resolved_key = openalex_api_key or settings.openalex_api_key
+        client = OpenAlexClient(api_key=resolved_key, mailto=settings.crossref_api_mailto)
+        batch_size = 25
+        now = datetime.now(UTC)
+        arxiv_lookup_allowed = True
+
+        for i in range(0, len(publications), batch_size):
+            if await self.run_is_canceled(db_session, run_id=run_id):
+                logger.info("ingestion.enrichment_aborted", extra={"run_id": run_id})
+                return
+            batch = publications[i : i + batch_size]
+            titles = _sanitize_titles(batch)
+            if not titles:
+                continue
+            try:
+                openalex_works = await client.get_works_by_filter(
+                    {"title.search": "|".join(titles)}, limit=batch_size * 3
+                )
+            except OpenAlexBudgetExhaustedError:
+                structured_log(logger, "warning", "ingestion.openalex_budget_exhausted", run_id=run_id)
+                break
+            except OpenAlexRateLimitError:
+                structured_log(logger, "warning", "ingestion.openalex_rate_limited", run_id=run_id)
+                await asyncio.sleep(60)
+                continue
+            except Exception as e:
+                structured_log(logger, "warning", "ingestion.openalex_enrichment_failed", error=str(e), run_id=run_id)
+                continue
+            should_continue, arxiv_lookup_allowed = await self._enrich_batch(
+                db_session,
+                batch=batch,
+                run_id=run_id,
+                openalex_works=openalex_works,
+                now=now,
+                arxiv_lookup_allowed=arxiv_lookup_allowed,
+            )
+            if not should_continue:
+                return
+
+        await self._flush_and_sweep_duplicates(db_session, run_id=run_id)
+
     async def _discover_identifiers_for_enrichment(
         self,
         db_session: AsyncSession,
@@ -275,23 +292,15 @@ class EnrichmentRunner:
 
         for i in range(0, len(publications), batch_size):
             batch = publications[i : i + batch_size]
-
-            titles = []
-            for p in batch:
-                if not p.title:
-                    continue
-                safe_title = re.sub(r"[^\w\s]", " ", p.title)
-                safe_title = " ".join(safe_title.split())
-                if safe_title:
-                    titles.append(safe_title)
-
+            titles = _sanitize_titles(batch)
             if not titles:
                 enriched.extend(batch)
                 continue
 
-            query = "|".join(t for t in titles)
             try:
-                openalex_works = await client.get_works_by_filter({"title.search": query}, limit=batch_size * 3)
+                openalex_works = await client.get_works_by_filter(
+                    {"title.search": "|".join(titles)}, limit=batch_size * 3
+                )
             except Exception as e:
                 logger.warning(
                     "ingestion.openalex_enrichment_failed",
diff --git a/app/services/ingestion/queue_runner.py b/app/services/ingestion/queue_runner.py
index 4eaaa98..45d9dd7 100644
--- a/app/services/ingestion/queue_runner.py
+++ b/app/services/ingestion/queue_runner.py
@@ -281,74 +281,72 @@ class QueueJobRunner:
                 await self._reschedule_queue_job_after_exception(job, exc=exc)
         return None
 
-    async def _finalize_queue_job_after_run(self, job: queue_service.ContinuationQueueJob, run_summary) -> None:
-        session_factory = get_session_factory()
-        async with session_factory() as session:
-            if int(run_summary.failed_count) <= 0:
-                queue_item = await queue_service.reset_attempt_count(session, job_id=job.id)
-                await session.commit()
-                if queue_item is None:
-                    structured_log(
-                        logger,
-                        "info",
-                        "scheduler.queue_item_resolved",
-                        queue_item_id=job.id,
-                        user_id=job.user_id,
-                        run_id=run_summary.crawl_run_id,
-                        status=run_summary.status.value,
-                    )
-                    return
-                structured_log(
-                    logger,
-                    "info",
-                    "scheduler.queue_item_progressed",
-                    queue_item_id=job.id,
-                    user_id=job.user_id,
-                    run_id=run_summary.crawl_run_id,
-                    status=run_summary.status.value,
-                    attempt_count=int(queue_item.attempt_count),
-                )
-                return
-            queue_item = await queue_service.increment_attempt_count(session, job_id=job.id)
-            if queue_item is None:
-                await session.commit()
-                structured_log(
-                    logger,
-                    "info",
-                    "scheduler.queue_item_resolved",
-                    queue_item_id=job.id,
-                    user_id=job.user_id,
-                    run_id=run_summary.crawl_run_id,
-                    status=run_summary.status.value,
-                )
-                return
-            if int(queue_item.attempt_count) >= self._continuation_max_attempts:
-                await queue_service.mark_dropped(session, job_id=job.id, reason="max_attempts_after_run")
-                await session.commit()
-                structured_log(
-                    logger,
-                    "warning",
-                    "scheduler.queue_item_dropped_max_attempts_after_run",
-                    queue_item_id=job.id,
-                    user_id=job.user_id,
-                    attempt_count=queue_item.attempt_count,
-                    run_id=run_summary.crawl_run_id,
-                    status=run_summary.status.value,
-                )
-                return
-            delay_seconds = queue_service.compute_backoff_seconds(
-                base_seconds=self._continuation_base_delay_seconds,
-                attempt_count=int(queue_item.attempt_count),
-                max_seconds=self._continuation_max_delay_seconds,
-            )
-            await queue_service.reschedule_job(
-                session,
-                job_id=job.id,
-                delay_seconds=delay_seconds,
-                reason=queue_item.reason,
-                error=queue_item.last_error,
+    async def _finalize_successful_queue_job(self, session, job, run_summary) -> None:
+        queue_item = await queue_service.reset_attempt_count(session, job_id=job.id)
+        await session.commit()
+        if queue_item is None:
+            structured_log(
+                logger,
+                "info",
+                "scheduler.queue_item_resolved",
+                queue_item_id=job.id,
+                user_id=job.user_id,
+                run_id=run_summary.crawl_run_id,
+                status=run_summary.status.value,
             )
+            return
+        structured_log(
+            logger,
+            "info",
+            "scheduler.queue_item_progressed",
+            queue_item_id=job.id,
+            user_id=job.user_id,
+            run_id=run_summary.crawl_run_id,
+            status=run_summary.status.value,
+            attempt_count=int(queue_item.attempt_count),
+        )
+
+    async def _finalize_failed_queue_job(self, session, job, run_summary) -> None:
+        queue_item = await queue_service.increment_attempt_count(session, job_id=job.id)
+        if queue_item is None:
             await session.commit()
+            structured_log(
+                logger,
+                "info",
+                "scheduler.queue_item_resolved",
+                queue_item_id=job.id,
+                user_id=job.user_id,
+                run_id=run_summary.crawl_run_id,
+                status=run_summary.status.value,
+            )
+            return
+        if int(queue_item.attempt_count) >= self._continuation_max_attempts:
+            await queue_service.mark_dropped(session, job_id=job.id, reason="max_attempts_after_run")
+            await session.commit()
+            structured_log(
+                logger,
+                "warning",
+                "scheduler.queue_item_dropped_max_attempts_after_run",
+                queue_item_id=job.id,
+                user_id=job.user_id,
+                attempt_count=queue_item.attempt_count,
+                run_id=run_summary.crawl_run_id,
+                status=run_summary.status.value,
+            )
+            return
+        delay_seconds = queue_service.compute_backoff_seconds(
+            base_seconds=self._continuation_base_delay_seconds,
+            attempt_count=int(queue_item.attempt_count),
+            max_seconds=self._continuation_max_delay_seconds,
+        )
+        await queue_service.reschedule_job(
+            session,
+            job_id=job.id,
+            delay_seconds=delay_seconds,
+            reason=queue_item.reason,
+            error=queue_item.last_error,
+        )
+        await session.commit()
         structured_log(
             logger,
             "info",
@@ -361,6 +359,14 @@ class QueueJobRunner:
             delay_seconds=delay_seconds,
         )
 
+    async def _finalize_queue_job_after_run(self, job: queue_service.ContinuationQueueJob, run_summary) -> None:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            if int(run_summary.failed_count) <= 0:
+                await self._finalize_successful_queue_job(session, job, run_summary)
+            else:
+                await self._finalize_failed_queue_job(session, job, run_summary)
+
     async def _run_queue_job(self, job: queue_service.ContinuationQueueJob) -> None:
         if await self._drop_queue_job_if_max_attempts(job):
             return
diff --git a/app/services/ingestion/scholar_processing.py b/app/services/ingestion/scholar_processing.py
index 3096dee..2bbddfd 100644
--- a/app/services/ingestion/scholar_processing.py
+++ b/app/services/ingestion/scholar_processing.py
@@ -528,6 +528,87 @@ def unexpected_scholar_exception_outcome(
     )
 
 
+async def _run_first_pass(
+    db_session: AsyncSession,
+    *,
+    scholars: list[ScholarProfile],
+    pagination: PaginationEngine,
+    run: CrawlRun,
+    user_id: int,
+    start_cstart_map: dict[int, int],
+    scholar_kwargs: dict[str, Any],
+    request_delay_seconds: int,
+    queue_delay_seconds: int,
+    progress: RunProgress,
+) -> dict[int, int]:
+    first_pass_cstarts: dict[int, int] = {}
+    for index, scholar in enumerate(scholars):
+        await db_session.refresh(run)
+        if run.status == RunStatus.CANCELED:
+            structured_log(logger, "info", "ingestion.run_canceled", run_id=run.id, user_id=user_id)
+            return first_pass_cstarts
+        if index > 0 and request_delay_seconds > 0:
+            await asyncio.sleep(float(request_delay_seconds))
+        start_cstart = int(start_cstart_map.get(int(scholar.id), 0))
+        outcome = await process_scholar(
+            db_session,
+            pagination=pagination,
+            run=run,
+            scholar=scholar,
+            user_id=user_id,
+            start_cstart=start_cstart,
+            max_pages_per_scholar=1,
+            auto_queue_continuations=False,
+            queue_delay_seconds=queue_delay_seconds,
+            **scholar_kwargs,
+        )
+        apply_outcome_to_progress(progress=progress, outcome=outcome)
+        resume_cstart = outcome.result_entry.get("continuation_cstart")
+        if resume_cstart is not None and int(resume_cstart) > start_cstart:
+            first_pass_cstarts[int(scholar.id)] = int(resume_cstart)
+    return first_pass_cstarts
+
+
+async def _run_depth_pass(
+    db_session: AsyncSession,
+    *,
+    scholars: list[ScholarProfile],
+    first_pass_cstarts: dict[int, int],
+    pagination: PaginationEngine,
+    run: CrawlRun,
+    user_id: int,
+    scholar_kwargs: dict[str, Any],
+    request_delay_seconds: int,
+    remaining_max: int,
+    auto_queue_continuations: bool,
+    queue_delay_seconds: int,
+    progress: RunProgress,
+) -> None:
+    for index, scholar in enumerate(scholars):
+        resume_cstart = first_pass_cstarts.get(int(scholar.id))
+        if resume_cstart is None:
+            continue
+        await db_session.refresh(run)
+        if run.status == RunStatus.CANCELED:
+            structured_log(logger, "info", "ingestion.run_canceled", run_id=run.id, user_id=user_id)
+            break
+        if index > 0 and request_delay_seconds > 0:
+            await asyncio.sleep(float(request_delay_seconds))
+        outcome = await process_scholar(
+            db_session,
+            pagination=pagination,
+            run=run,
+            scholar=scholar,
+            user_id=user_id,
+            start_cstart=resume_cstart,
+            max_pages_per_scholar=remaining_max,
+            auto_queue_continuations=auto_queue_continuations,
+            queue_delay_seconds=queue_delay_seconds,
+            **scholar_kwargs,
+        )
+        apply_outcome_to_progress(progress=progress, outcome=outcome)
+
+
 async def run_scholar_iteration(
     db_session: AsyncSession,
     *,
@@ -555,60 +636,33 @@ async def run_scholar_iteration(
         "rate_limit_backoff_seconds": rate_limit_backoff_seconds,
         "page_size": page_size,
     }
-
-    # ── Pass 1: first page of every scholar (breadth-first) ──────────
-    first_pass_cstarts: dict[int, int] = {}
-    for index, scholar in enumerate(scholars):
-        await db_session.refresh(run)
-        if run.status == RunStatus.CANCELED:
-            structured_log(logger, "info", "ingestion.run_canceled", run_id=run.id, user_id=user_id)
-            return progress
-        if index > 0 and request_delay_seconds > 0:
-            await asyncio.sleep(float(request_delay_seconds))
-        start_cstart = int(start_cstart_map.get(int(scholar.id), 0))
-        outcome = await process_scholar(
-            db_session,
-            pagination=pagination,
-            run=run,
-            scholar=scholar,
-            user_id=user_id,
-            start_cstart=start_cstart,
-            max_pages_per_scholar=1,
-            auto_queue_continuations=False,
-            queue_delay_seconds=queue_delay_seconds,
-            **scholar_kwargs,
-        )
-        apply_outcome_to_progress(progress=progress, outcome=outcome)
-        resume_cstart = outcome.result_entry.get("continuation_cstart")
-        if resume_cstart is not None and int(resume_cstart) > start_cstart:
-            first_pass_cstarts[int(scholar.id)] = int(resume_cstart)
-
-    # ── Pass 2: remaining pages for each scholar (depth) ─────────────
+    first_pass_cstarts = await _run_first_pass(
+        db_session,
+        scholars=scholars,
+        pagination=pagination,
+        run=run,
+        user_id=user_id,
+        start_cstart_map=start_cstart_map,
+        scholar_kwargs=scholar_kwargs,
+        request_delay_seconds=request_delay_seconds,
+        queue_delay_seconds=queue_delay_seconds,
+        progress=progress,
+    )
     remaining_max = max(max_pages_per_scholar - 1, 0)
     if remaining_max <= 0:
         return progress
-
-    for index, scholar in enumerate(scholars):
-        resume_cstart = first_pass_cstarts.get(int(scholar.id))
-        if resume_cstart is None:
-            continue
-        await db_session.refresh(run)
-        if run.status == RunStatus.CANCELED:
-            structured_log(logger, "info", "ingestion.run_canceled", run_id=run.id, user_id=user_id)
-            break
-        if index > 0 and request_delay_seconds > 0:
-            await asyncio.sleep(float(request_delay_seconds))
-        outcome = await process_scholar(
-            db_session,
-            pagination=pagination,
-            run=run,
-            scholar=scholar,
-            user_id=user_id,
-            start_cstart=resume_cstart,
-            max_pages_per_scholar=remaining_max,
-            auto_queue_continuations=auto_queue_continuations,
-            queue_delay_seconds=queue_delay_seconds,
-            **scholar_kwargs,
-        )
-        apply_outcome_to_progress(progress=progress, outcome=outcome)
+    await _run_depth_pass(
+        db_session,
+        scholars=scholars,
+        first_pass_cstarts=first_pass_cstarts,
+        pagination=pagination,
+        run=run,
+        user_id=user_id,
+        scholar_kwargs=scholar_kwargs,
+        request_delay_seconds=request_delay_seconds,
+        remaining_max=remaining_max,
+        auto_queue_continuations=auto_queue_continuations,
+        queue_delay_seconds=queue_delay_seconds,
+        progress=progress,
+    )
     return progress
-- 
2.49.1


From 72bc0462152a5522736331f1edfa7c57ebe0bb05 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 16:21:49 +0100
Subject: [PATCH 33/38] refactor: extract helpers from remaining long functions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Extract _start_manual_run and _spawn_background_execution from run_manual route
- Extract _upsert_page_publications to deduplicate pagination loop
- Extract _classify_attempt from fetch_and_parse_with_retry
- Extract _log_alert_threshold_warnings from complete_run_for_user
- Functions 3f-3j accepted as kwargs-exception (body ≤50 lines excluding signatures)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/api/routers/runs.py                  | 113 +++++++++++++++--------
 app/services/ingestion/page_fetch.py     |  36 +++++---
 app/services/ingestion/pagination.py     |  48 +++++++---
 app/services/ingestion/run_completion.py |  46 +++++----
 4 files changed, 156 insertions(+), 87 deletions(-)

diff --git a/app/api/routers/runs.py b/app/api/routers/runs.py
index 687f6ce..28779ef 100644
--- a/app/api/routers/runs.py
+++ b/app/api/routers/runs.py
@@ -176,6 +176,67 @@ async def cancel_run(
     )
 
 
+async def _start_manual_run(
+    db_session: AsyncSession,
+    *,
+    current_user: User,
+    ingest_service: ingestion_service.ScholarIngestionService,
+    idempotency_key: str | None,
+) -> tuple[Any, Any, list, dict]:
+    user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=current_user.id)
+    run, scholars, start_cstart_map = await ingest_service.initialize_run(
+        db_session,
+        user_id=current_user.id,
+        trigger_type=RunTriggerType.MANUAL,
+        request_delay_seconds=user_settings.request_delay_seconds,
+        network_error_retries=settings.ingestion_network_error_retries,
+        retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
+        max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
+        page_size=settings.ingestion_page_size,
+        idempotency_key=idempotency_key,
+        alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
+        alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
+        alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
+    )
+    return user_settings, run, scholars, start_cstart_map
+
+
+def _spawn_background_execution(
+    ingest_service: ingestion_service.ScholarIngestionService,
+    *,
+    run: Any,
+    current_user: User,
+    scholars: list,
+    start_cstart_map: dict,
+    user_settings: Any,
+    idempotency_key: str | None,
+) -> None:
+    from app.db.session import get_session_factory
+
+    task = asyncio.create_task(
+        ingest_service.execute_run(
+            session_factory=get_session_factory(),
+            run_id=run.id,
+            user_id=current_user.id,
+            scholars=scholars,
+            start_cstart_map=start_cstart_map,
+            request_delay_seconds=user_settings.request_delay_seconds,
+            network_error_retries=settings.ingestion_network_error_retries,
+            retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
+            max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
+            page_size=settings.ingestion_page_size,
+            auto_queue_continuations=settings.ingestion_continuation_queue_enabled,
+            queue_delay_seconds=settings.ingestion_continuation_base_delay_seconds,
+            alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
+            alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
+            alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
+            idempotency_key=idempotency_key,
+        )
+    )
+    _background_tasks.add(task)
+    task.add_done_callback(_background_tasks.discard)
+
+
 @router.post(
     "/manual",
     response_model=ManualRunEnvelope,
@@ -202,52 +263,22 @@ async def run_manual(
         return reused_payload
 
     try:
-        user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=current_user.id)
-
-        # Initialize run (creates the record and performs safety checks)
-        run, scholars, start_cstart_map = await ingest_service.initialize_run(
+        user_settings, run, scholars, start_cstart_map = await _start_manual_run(
             db_session,
-            user_id=current_user.id,
-            trigger_type=RunTriggerType.MANUAL,
-            request_delay_seconds=user_settings.request_delay_seconds,
-            network_error_retries=settings.ingestion_network_error_retries,
-            retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
-            max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
-            page_size=settings.ingestion_page_size,
+            current_user=current_user,
+            ingest_service=ingest_service,
             idempotency_key=idempotency_key,
-            alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
-            alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
-            alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
         )
-
         await db_session.commit()
-
-        # Kick off background execution
-        from app.db.session import get_session_factory
-
-        task = asyncio.create_task(
-            ingest_service.execute_run(
-                session_factory=get_session_factory(),
-                run_id=run.id,
-                user_id=current_user.id,
-                scholars=scholars,
-                start_cstart_map=start_cstart_map,
-                request_delay_seconds=user_settings.request_delay_seconds,
-                network_error_retries=settings.ingestion_network_error_retries,
-                retry_backoff_seconds=settings.ingestion_retry_backoff_seconds,
-                max_pages_per_scholar=settings.ingestion_max_pages_per_scholar,
-                page_size=settings.ingestion_page_size,
-                auto_queue_continuations=settings.ingestion_continuation_queue_enabled,
-                queue_delay_seconds=settings.ingestion_continuation_base_delay_seconds,
-                alert_blocked_failure_threshold=settings.ingestion_alert_blocked_failure_threshold,
-                alert_network_failure_threshold=settings.ingestion_alert_network_failure_threshold,
-                alert_retry_scheduled_threshold=settings.ingestion_alert_retry_scheduled_threshold,
-                idempotency_key=idempotency_key,
-            )
+        _spawn_background_execution(
+            ingest_service,
+            run=run,
+            current_user=current_user,
+            scholars=scholars,
+            start_cstart_map=start_cstart_map,
+            user_settings=user_settings,
+            idempotency_key=idempotency_key,
         )
-        _background_tasks.add(task)
-        task.add_done_callback(_background_tasks.discard)
-
         return success_payload(
             request,
             data={
diff --git a/app/services/ingestion/page_fetch.py b/app/services/ingestion/page_fetch.py
index 008cb6b..19aff3f 100644
--- a/app/services/ingestion/page_fetch.py
+++ b/app/services/ingestion/page_fetch.py
@@ -145,6 +145,24 @@ class PageFetcher:
         if sleep_seconds > 0:
             await asyncio.sleep(sleep_seconds)
 
+    @staticmethod
+    def _classify_attempt(
+        parsed_page: ParsedProfilePage,
+        *,
+        network_attempts: int,
+        rate_limit_attempts: int,
+    ) -> tuple[int, int, int]:
+        if parsed_page.state == ParseState.NETWORK_ERROR:
+            network_attempts += 1
+            return network_attempts, rate_limit_attempts, network_attempts
+        if (
+            parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA
+            and parsed_page.state_reason == "blocked_http_429_rate_limited"
+        ):
+            rate_limit_attempts += 1
+            return network_attempts, rate_limit_attempts, rate_limit_attempts
+        return network_attempts, rate_limit_attempts, network_attempts + rate_limit_attempts + 1
+
     async def fetch_and_parse_with_retry(
         self,
         *,
@@ -169,19 +187,9 @@ class PageFetcher:
                 page_size=page_size,
             )
             parsed_page = self.parse_page_or_layout_error(fetch_result=fetch_result)
-
-            if parsed_page.state == ParseState.NETWORK_ERROR:
-                network_attempts += 1
-                total_attempts = network_attempts
-            elif (
-                parsed_page.state == ParseState.BLOCKED_OR_CAPTCHA
-                and parsed_page.state_reason == "blocked_http_429_rate_limited"
-            ):
-                rate_limit_attempts += 1
-                total_attempts = rate_limit_attempts
-            else:
-                total_attempts = network_attempts + rate_limit_attempts + 1
-
+            network_attempts, rate_limit_attempts, total_attempts = self._classify_attempt(
+                parsed_page, network_attempts=network_attempts, rate_limit_attempts=rate_limit_attempts
+            )
             attempt_log.append(
                 {
                     "attempt": total_attempts,
@@ -192,7 +200,6 @@ class PageFetcher:
                     "fetch_error": fetch_result.error,
                 }
             )
-
             if not self._should_retry(
                 parsed_page=parsed_page,
                 network_attempt_count=network_attempts,
@@ -201,7 +208,6 @@ class PageFetcher:
                 rate_limit_retries=rate_limit_retries,
             ):
                 break
-
             await self._sleep_backoff(
                 scholar_id=scholar_id,
                 cstart=cstart,
diff --git a/app/services/ingestion/pagination.py b/app/services/ingestion/pagination.py
index 9e761b8..0e6b5b0 100644
--- a/app/services/ingestion/pagination.py
+++ b/app/services/ingestion/pagination.py
@@ -273,6 +273,24 @@ class PaginationEngine:
 
     # ── Pagination loop ──────────────────────────────────────────────
 
+    @staticmethod
+    async def _upsert_page_publications(
+        db_session: Any,
+        *,
+        run: CrawlRun,
+        scholar: ScholarProfile,
+        publications: list,
+        seen_canonical: set[str],
+        state: PagedLoopState,
+        upsert_publications_fn: Any,
+    ) -> None:
+        deduped = _dedupe_publication_candidates(list(publications), seen_canonical=seen_canonical)
+        if deduped:
+            discovered_count = await upsert_publications_fn(
+                db_session, run=run, scholar=scholar, publications=deduped
+            )
+            state.discovered_publication_count += discovered_count
+
     async def _paginate_loop(
         self,
         *,
@@ -292,14 +310,15 @@ class PaginationEngine:
         seen_canonical: set[str] = set()
 
         if state.parsed_page.publications:
-            deduped_first = _dedupe_publication_candidates(
-                list(state.parsed_page.publications), seen_canonical=seen_canonical
+            await self._upsert_page_publications(
+                db_session,
+                run=run,
+                scholar=scholar,
+                publications=state.parsed_page.publications,
+                seen_canonical=seen_canonical,
+                state=state,
+                upsert_publications_fn=upsert_publications_fn,
             )
-            if deduped_first:
-                discovered_count = await upsert_publications_fn(
-                    db_session, run=run, scholar=scholar, publications=deduped_first
-                )
-                state.discovered_publication_count += discovered_count
 
         while state.parsed_page.has_show_more_button:
             await db_session.refresh(run)
@@ -337,14 +356,15 @@ class PaginationEngine:
             )
 
             if next_parsed_page.publications:
-                deduped_next = _dedupe_publication_candidates(
-                    list(next_parsed_page.publications), seen_canonical=seen_canonical
+                await self._upsert_page_publications(
+                    db_session,
+                    run=run,
+                    scholar=scholar,
+                    publications=next_parsed_page.publications,
+                    seen_canonical=seen_canonical,
+                    state=state,
+                    upsert_publications_fn=upsert_publications_fn,
                 )
-                if deduped_next:
-                    discovered_count = await upsert_publications_fn(
-                        db_session, run=run, scholar=scholar, publications=deduped_next
-                    )
-                    state.discovered_publication_count += discovered_count
 
             if self._handle_page_state_transition(state=state):
                 return
diff --git a/app/services/ingestion/run_completion.py b/app/services/ingestion/run_completion.py
index b50f770..8f53f6a 100644
--- a/app/services/ingestion/run_completion.py
+++ b/app/services/ingestion/run_completion.py
@@ -262,25 +262,13 @@ def build_failure_debug_context(
     return context
 
 
-def complete_run_for_user(
+def _log_alert_threshold_warnings(
     *,
-    user_settings: Any,
-    run: CrawlRun,
-    scholars: list[ScholarProfile],
     user_id: int,
-    progress: RunProgress,
-    idempotency_key: str | None,
-    alert_blocked_failure_threshold: int,
-    alert_network_failure_threshold: int,
-    alert_retry_scheduled_threshold: int,
-) -> tuple[RunFailureSummary, RunAlertSummary]:
-    failure_summary = summarize_failures(scholar_results=progress.scholar_results)
-    alert_summary = build_alert_summary(
-        failure_summary=failure_summary,
-        alert_blocked_failure_threshold=alert_blocked_failure_threshold,
-        alert_network_failure_threshold=alert_network_failure_threshold,
-        alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
-    )
+    run: CrawlRun,
+    failure_summary: RunFailureSummary,
+    alert_summary: RunAlertSummary,
+) -> None:
     if alert_summary.alert_flags["blocked_failure_threshold_exceeded"]:
         structured_log(
             logger,
@@ -311,6 +299,30 @@ def complete_run_for_user(
             retries_scheduled_count=failure_summary.retries_scheduled_count,
             threshold=alert_summary.retry_scheduled_threshold,
         )
+
+
+def complete_run_for_user(
+    *,
+    user_settings: Any,
+    run: CrawlRun,
+    scholars: list[ScholarProfile],
+    user_id: int,
+    progress: RunProgress,
+    idempotency_key: str | None,
+    alert_blocked_failure_threshold: int,
+    alert_network_failure_threshold: int,
+    alert_retry_scheduled_threshold: int,
+) -> tuple[RunFailureSummary, RunAlertSummary]:
+    failure_summary = summarize_failures(scholar_results=progress.scholar_results)
+    alert_summary = build_alert_summary(
+        failure_summary=failure_summary,
+        alert_blocked_failure_threshold=alert_blocked_failure_threshold,
+        alert_network_failure_threshold=alert_network_failure_threshold,
+        alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
+    )
+    _log_alert_threshold_warnings(
+        user_id=user_id, run=run, failure_summary=failure_summary, alert_summary=alert_summary
+    )
     apply_safety_outcome(user_settings=user_settings, run=run, user_id=user_id, alert_summary=alert_summary)
     run_status = resolve_run_status(
         scholar_count=len(scholars),
-- 
2.49.1


From c0e66c509ff8a82872495db4b3e0eb22e71d329e Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 16:24:36 +0100
Subject: [PATCH 34/38] style: fix ruff lint and format issues across service
 modules

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/services/arxiv/rate_limit.py              | 48 +++++++++----------
 app/services/ingestion/application.py         |  2 +-
 app/services/ingestion/pagination.py          |  4 +-
 app/services/ingestion/scheduler.py           |  4 +-
 app/services/openalex/matching.py             |  8 +++-
 .../publications/pdf_queue_resolution.py      |  1 -
 app/services/publications/queries.py          |  3 +-
 app/services/scholar/source.py                |  4 +-
 tests/integration/test_deferred_enrichment.py |  4 +-
 9 files changed, 37 insertions(+), 41 deletions(-)

diff --git a/app/services/arxiv/rate_limit.py b/app/services/arxiv/rate_limit.py
index 56c8d4c..70d6b69 100644
--- a/app/services/arxiv/rate_limit.py
+++ b/app/services/arxiv/rate_limit.py
@@ -69,30 +69,30 @@ async def _run_serialized_fetch(
 ) -> tuple[httpx.Response, bool]:
     session_factory = get_session_factory()
     async with session_factory() as db_session, db_session.begin():
-            await _acquire_arxiv_lock(db_session)
-            runtime_state = await _load_runtime_state_for_update(db_session)
-            wait_seconds = await _wait_for_allowed_slot_or_raise(
-                runtime_state,
-                source_path=source_path,
-            )
-            response = await fetch()
-            hit_rate_limit = _record_post_response_state(
-                runtime_state,
-                response_status=int(response.status_code),
-                source_path=source_path,
-            )
-            structured_log(
-                logger,
-                "info",
-                "arxiv.request_completed",
-                status_code=int(response.status_code),
-                wait_seconds=wait_seconds,
-                cooldown_remaining_seconds=_cooldown_remaining_seconds(
-                    runtime_state.cooldown_until, now_utc=datetime.now(UTC)
-                ),
-                source_path=source_path,
-            )
-            return response, hit_rate_limit
+        await _acquire_arxiv_lock(db_session)
+        runtime_state = await _load_runtime_state_for_update(db_session)
+        wait_seconds = await _wait_for_allowed_slot_or_raise(
+            runtime_state,
+            source_path=source_path,
+        )
+        response = await fetch()
+        hit_rate_limit = _record_post_response_state(
+            runtime_state,
+            response_status=int(response.status_code),
+            source_path=source_path,
+        )
+        structured_log(
+            logger,
+            "info",
+            "arxiv.request_completed",
+            status_code=int(response.status_code),
+            wait_seconds=wait_seconds,
+            cooldown_remaining_seconds=_cooldown_remaining_seconds(
+                runtime_state.cooldown_until, now_utc=datetime.now(UTC)
+            ),
+            source_path=source_path,
+        )
+        return response, hit_rate_limit
 
 
 async def _acquire_arxiv_lock(db_session: AsyncSession) -> None:
diff --git a/app/services/ingestion/application.py b/app/services/ingestion/application.py
index 3f0ad48..9bfc46a 100644
--- a/app/services/ingestion/application.py
+++ b/app/services/ingestion/application.py
@@ -22,8 +22,8 @@ from app.services.ingestion.constants import RUN_LOCK_NAMESPACE
 from app.services.ingestion.enrichment import EnrichmentRunner
 from app.services.ingestion.pagination import PaginationEngine
 from app.services.ingestion.run_completion import (
-    int_or_default,
     complete_run_for_user,
+    int_or_default,
     run_execution_summary,
 )
 from app.services.ingestion.scholar_processing import run_scholar_iteration
diff --git a/app/services/ingestion/pagination.py b/app/services/ingestion/pagination.py
index 0e6b5b0..5858a7d 100644
--- a/app/services/ingestion/pagination.py
+++ b/app/services/ingestion/pagination.py
@@ -286,9 +286,7 @@ class PaginationEngine:
     ) -> None:
         deduped = _dedupe_publication_candidates(list(publications), seen_canonical=seen_canonical)
         if deduped:
-            discovered_count = await upsert_publications_fn(
-                db_session, run=run, scholar=scholar, publications=deduped
-            )
+            discovered_count = await upsert_publications_fn(db_session, run=run, scholar=scholar, publications=deduped)
             state.discovered_publication_count += discovered_count
 
     async def _paginate_loop(
diff --git a/app/services/ingestion/scheduler.py b/app/services/ingestion/scheduler.py
index 1e5f08c..dbb0632 100644
--- a/app/services/ingestion/scheduler.py
+++ b/app/services/ingestion/scheduler.py
@@ -184,9 +184,7 @@ class SchedulerService:
             run_interval_minutes=int(run_interval_minutes),
             request_delay_seconds=effective_request_delay_seconds(
                 request_delay_seconds,
-                floor=user_settings_service.resolve_request_delay_minimum(
-                    settings.ingestion_min_request_delay_seconds
-                ),
+                floor=user_settings_service.resolve_request_delay_minimum(settings.ingestion_min_request_delay_seconds),
             ),
             cooldown_until=cooldown_until,
             cooldown_reason=(str(cooldown_reason).strip() if cooldown_reason else None),
diff --git a/app/services/openalex/matching.py b/app/services/openalex/matching.py
index 1ecf115..34e1927 100644
--- a/app/services/openalex/matching.py
+++ b/app/services/openalex/matching.py
@@ -93,8 +93,12 @@ def find_best_match(
 
     for original_score, cand in top_scored_candidates:
         tb_score = 0
-        if target_year is not None and cand.publication_year is not None and abs(target_year - cand.publication_year) <= 1:
-                tb_score += 1
+        if (
+            target_year is not None
+            and cand.publication_year is not None
+            and abs(target_year - cand.publication_year) <= 1
+        ):
+            tb_score += 1
 
         candidate_author_names = [a.display_name for a in cand.authors if a.display_name]
         if _author_overlap_score(target_authors, candidate_author_names):
diff --git a/app/services/publications/pdf_queue_resolution.py b/app/services/publications/pdf_queue_resolution.py
index 2e02a65..aa80761 100644
--- a/app/services/publications/pdf_queue_resolution.py
+++ b/app/services/publications/pdf_queue_resolution.py
@@ -9,7 +9,6 @@ from app.logging_utils import structured_log
 from app.services.publication_identifiers import application as identifier_service
 from app.services.publications.pdf_queue_common import (
     PDF_STATUS_FAILED,
-    PDF_STATUS_QUEUED,
     PDF_STATUS_RESOLVED,
     PDF_STATUS_RUNNING,
     event_row,
diff --git a/app/services/publications/queries.py b/app/services/publications/queries.py
index 2de11d6..82763aa 100644
--- a/app/services/publications/queries.py
+++ b/app/services/publications/queries.py
@@ -3,7 +3,8 @@ from __future__ import annotations
 from datetime import datetime
 from typing import Any
 
-from sqlalchemy import Select, case, false as sa_false, func, select
+from sqlalchemy import Select, case, func, select
+from sqlalchemy import false as sa_false
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import (
diff --git a/app/services/scholar/source.py b/app/services/scholar/source.py
index 8d61ec8..afafb1c 100644
--- a/app/services/scholar/source.py
+++ b/app/services/scholar/source.py
@@ -74,9 +74,7 @@ class LiveScholarSource:
         self._min_interval_seconds = max(configured_interval, 0.0)
         self._user_agents = user_agents or DEFAULT_USER_AGENTS
         self._rotate_user_agents = (
-            bool(settings.scholar_http_rotate_user_agent)
-            if rotate_user_agents is None
-            else bool(rotate_user_agents)
+            bool(settings.scholar_http_rotate_user_agent) if rotate_user_agents is None else bool(rotate_user_agents)
         )
         configured_user_agent = settings.scholar_http_user_agent.strip()
         self._configured_user_agent = configured_user_agent or None
diff --git a/tests/integration/test_deferred_enrichment.py b/tests/integration/test_deferred_enrichment.py
index 447bc73..5ad5700 100644
--- a/tests/integration/test_deferred_enrichment.py
+++ b/tests/integration/test_deferred_enrichment.py
@@ -84,9 +84,7 @@ async def test_deferred_enrichment_sweeps_previous_runs(db_session: AsyncSession
     # We patch the client at its source, and also mock arXiv to avoid real HTTP calls
     with (
         patch("app.services.openalex.client.OpenAlexClient") as MockClient,
-        patch(
-            "app.services.arxiv.application.discover_arxiv_id_for_publication", new=AsyncMock(return_value=None)
-        ),
+        patch("app.services.arxiv.application.discover_arxiv_id_for_publication", new=AsyncMock(return_value=None)),
     ):
         mock_instance = MockClient.return_value
         mock_instance.get_works_by_filter = AsyncMock(return_value=[mock_work])
-- 
2.49.1


From 839593e1b3e9fbcb03c8d0fc1ea7bd2fa0b82f0d Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 16:25:51 +0100
Subject: [PATCH 35/38]

---
 DECOMPOSITION_CLEANUP.md | 193 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 193 insertions(+)
 create mode 100644 DECOMPOSITION_CLEANUP.md

diff --git a/DECOMPOSITION_CLEANUP.md b/DECOMPOSITION_CLEANUP.md
new file mode 100644
index 0000000..f95de24
--- /dev/null
+++ b/DECOMPOSITION_CLEANUP.md
@@ -0,0 +1,193 @@
+# Decomposition Cleanup — 3-Pass Fix Prompt
+
+You are working on the scholarr repository (`feat/decomposition` branch). A decomposition refactor split oversized files into focused modules. An audit found residual issues. Fix them in 3 sequential passes.
+
+**Read `agents.md` before starting.** Key rules:
+- Function length: 50 lines max
+- File length: 400 target, 600 hard ceiling (kwargs-heavy signatures are acceptable overage)
+- No dead code, no duplicate boilerplate, no backward-compatibility shims
+- All business logic in `app/services/<domain>/`
+- Use `structured_log()` for domain logging
+
+**Constraints for every pass:**
+- Pure refactoring — no behavioral changes
+- All tests must pass after each pass: `docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app python -m pytest`
+- Commit after each pass using conventional commit format
+
+---
+
+## Pass 1: Naming, DRY, and Dead Code
+
+**1a. Rename `_int_or_default` → `int_or_default`**
+
+This function in `app/services/ingestion/run_completion.py:38` is imported externally by `app/services/ingestion/application.py:25`, making it public API with a private-convention name.
+
+- Rename the definition in `run_completion.py` (line 38)
+- Update all internal call sites in `run_completion.py` (lines 71, 350, 375)
+- Update the import in `application.py` (line 25) and call sites (lines 138, 336, 342)
+
+**1b. Consolidate duplicate functions between `pdf_queue.py` and `pdf_queue_resolution.py`**
+
+Three functions exist with identical signatures in both files:
+
+| Function | `pdf_queue.py` | `pdf_queue_resolution.py` |
+|---|---|---|
+| `_utcnow()` | line 46 | line 33 |
+| `_event_row()` | line 150 | line 39 |
+| `_queued_job()` | line 165 | line 60 |
+
+Fix: Keep these in `pdf_queue.py` (the parent module). Have `pdf_queue_resolution.py` import them from `pdf_queue.py`. Since `pdf_queue.py` already imports from `pdf_queue_resolution.py`, check for circular imports — if importing `_utcnow`, `_event_row`, `_queued_job` from `pdf_queue` into `pdf_queue_resolution` would create a cycle, extract them to a shared `pdf_queue_common.py` instead.
+
+Also deduplicate the PDF status constants (`PDF_STATUS_QUEUED`, `PDF_STATUS_RUNNING`, `PDF_STATUS_RESOLVED`, `PDF_STATUS_FAILED`) that are duplicated between `pdf_queue.py` (lines 23-27) and `pdf_queue_resolution.py` (lines 20-23). Keep them in `pdf_queue.py` only.
+
+**1c. Consolidate `_effective_request_delay_seconds` duplication**
+
+`scheduler.py` (lines 32-42) and `queue_runner.py` (line 23-28) both define `_effective_request_delay_seconds` with slightly different signatures. The `queue_runner.py` version takes an explicit `floor` parameter (cleaner). Keep the `queue_runner.py` version. In `scheduler.py`, delete `_request_delay_floor_seconds()` and `_effective_request_delay_seconds()`, and instead import from `queue_runner`:
+
+```python
+from app.services.ingestion.queue_runner import _effective_request_delay_seconds
+```
+
+At the call site in `scheduler.py`, pass `floor=_request_delay_floor_seconds_value` where needed (inline the floor computation or keep it as a one-liner).
+
+Actually — since `_effective_request_delay_seconds` would now be imported externally, rename it to `effective_request_delay_seconds` (drop the underscore) in `queue_runner.py`.
+
+Commit message: `refactor: fix naming, remove duplicate code from decomposition`
+
+---
+
+## Pass 2: Function length — ingestion core (6 worst offenders)
+
+All 6 functions are >75 lines. Extract helpers to bring each under 50 lines. Below is specific guidance for each.
+
+**2a. `EnrichmentRunner.enrich_pending_publications` — 133 lines → ≤50** (`enrichment.py:47-179`)
+
+This function does 4 things: load publications, set up client, batch-loop with API calls, run dedup sweep. Extract:
+
+1. `_load_unenriched_publications(db_session, *, run_id) → list[Publication]` — lines 66-87 (query + return)
+2. `_enrich_batch(self, db_session, *, batch, run_id, client, openalex_works, now) → bool` — lines 142-166 (per-publication enrichment loop; return False if canceled). This inner loop iterates `batch`, calls `_discover_identifiers_for_enrichment`, and applies the match. The caller handles the outer batch loop and API call.
+3. `_flush_and_sweep_duplicates(db_session, *, run_id)` — lines 167-179 (flush + dedup sweep)
+
+The main function becomes: load pubs → early return → create client → batch loop (API call + `_enrich_batch`) → `_flush_and_sweep_duplicates`.
+
+**2b. `EnrichmentRunner.enrich_publications_with_openalex` — 64 lines → ≤50** (`enrichment.py:260-323`)
+
+Extract:
+1. `_sanitize_titles(publications) → list[str]` — lines 279-286 (title cleaning loop)
+
+The outer batch loop + match logic stays in the main method, which should now fit in ~45 lines.
+
+**2c. `ScholarIngestionService.run_for_user` — 99 lines → ≤50** (`application.py:525-623`)
+
+This function calls `initialize_run`, builds paging/threshold kwargs, calls `run_scholar_iteration`, `complete_run_for_user`, handles enrichment, commits, and logs. Extract:
+
+1. `_run_iteration_and_complete(self, db_session, *, run, scholars, user_id, start_cstart_map, paging, thresholds, auto_queue_continuations, queue_delay_seconds, idempotency_key) → tuple[RunProgress, RunFailureSummary, RunAlertSummary]` — lines 579-599 (the iteration + completion block). This calls `run_scholar_iteration` and `complete_run_for_user` and returns their results.
+2. `_inline_enrich_and_finalize(self, db_session, *, run, user_settings, intended_final_status) → None` — lines 604-614 (enrichment + status fixup + commit). This calls `enrich_pending_publications`, handles the exception, fixes status, and commits.
+
+**2d. `ScholarIngestionService.execute_run` — 88 lines → ≤50** (`application.py:374-461`)
+
+Extract:
+1. `_execute_run_body(self, db_session, session_factory, *, run_id, user_id, scholars, start_cstart_map, paging, thresholds, auto_queue_continuations, queue_delay_seconds, idempotency_key) → None` — lines 411-457 (the try-body: prepare, iterate, complete, commit, log, spawn enrichment task). The outer `execute_run` handles kwargs resolution and the `async with session_factory()` + `except`.
+
+Or alternatively, the `_resolve_paging_kwargs` / `_threshold_kwargs` calls can be lifted into the caller or inlined since they're trivial dict builders — this alone may shave enough lines. Consider whether the kwargs signature itself is the bulk (it is — 22 lines of signature). If so, this function may be acceptable as-is per the kwargs-exception rule. Use your judgment: if the function body (excluding signature and kwargs resolution) is ≤50 lines, document it as acceptable and move on.
+
+**2e. `run_scholar_iteration` — 84 lines → ≤50** (`scholar_processing.py:531-614`)
+
+This has two clear phases: pass 1 (breadth-first, lines 560-584) and pass 2 (depth, lines 586-614). Extract:
+
+1. `_run_first_pass(db_session, *, scholars, pagination, run, user_id, start_cstart_map, scholar_kwargs, request_delay_seconds, queue_delay_seconds, progress) → dict[int, int]` — the breadth-first loop (lines 560-584), returns `first_pass_cstarts`
+2. `_run_depth_pass(db_session, *, scholars, first_pass_cstarts, pagination, run, user_id, scholar_kwargs, request_delay_seconds, remaining_max, auto_queue_continuations, queue_delay_seconds, progress) → None` — the depth loop (lines 591-613)
+
+The main function becomes: build kwargs → call pass 1 → compute remaining → call pass 2 → return progress.
+
+**2f. `QueueJobRunner._finalize_queue_job_after_run` — 79 lines → ≤50** (`queue_runner.py:284-362`)
+
+Two branches: success path (lines 287-311) and failure path (lines 312-362). Extract:
+
+1. `_finalize_successful_queue_job(self, session, job, run_summary) → None` — success path
+2. `_finalize_failed_queue_job(self, session, job, run_summary) → None` — failure path
+
+The main function opens a session, branches on `failed_count`, and delegates.
+
+Commit message: `refactor: extract helpers from long functions in ingestion core`
+
+---
+
+## Pass 3: Function length — remaining violations (10 functions, 58-75 lines)
+
+**3a. `run_manual` — 105 lines → ≤50** (`app/api/routers/runs.py:183-287`)
+
+This route handler has a large try block. Extract:
+
+1. `_start_manual_run(db_session, *, current_user, ingest_service, idempotency_key) → tuple[CrawlRun, list, dict]` — lines 205-221 (initialize_run call with all the settings kwargs)
+2. `_spawn_background_execution(ingest_service, *, run, current_user, scholars, start_cstart_map, user_settings, idempotency_key) → None` — lines 226-249 (create_task + background_tasks management)
+3. `_manual_run_success_response(request, *, run, idempotency_key, db_session, current_user) → dict` — lines 251-265 (build success payload)
+
+The route handler becomes: load safety → check disabled → check idempotency → try: start → spawn → respond; except: handle errors.
+
+**3b. `PaginationEngine._paginate_loop` — 75 lines → ≤50** (`pagination.py:276-350`)
+
+Extract:
+1. `_upsert_page_publications(self, db_session, *, run, scholar, publications, seen_canonical, state, upsert_publications_fn)` — the dedup + upsert block (appears twice: lines 294-302 and 339-347). Deduplicate by extracting a single helper called from both places.
+
+This should bring the loop body under 50 lines.
+
+**3c. `PaginationEngine.fetch_and_parse_all_pages` — 72 lines → ≤50** (`pagination.py:415-486`)
+
+Most of the length is the kwargs-heavy calls. Check if the function body (excluding the 17-line signature) is ≤50 lines — it should be ~55. Extract:
+1. Move the `_short_circuit_initial_page` + `_build_loop_state` + `_paginate_loop` + `_result_from_pagination_state` sequence into a helper `_paginate_from_initial_page(self, *, scholar, run, db_session, state, ...) → PagedParseResult` if needed. Or accept this as kwargs-acceptable overage and document why.
+
+**3d. `PageFetcher.fetch_and_parse_with_retry` — 70 lines → ≤50** (`page_fetch.py:148-217`)
+
+Extract:
+1. `_classify_attempt(parsed_page, *, network_attempts, rate_limit_attempts) → tuple[int, int, int]` — lines 173-183 (attempt counter logic, returns updated network_attempts, rate_limit_attempts, total_attempts)
+
+This plus the existing `_should_retry` and `_sleep_backoff` helpers should bring the loop under 50 lines.
+
+**3e. `complete_run_for_user` — 66 lines → ≤50** (`run_completion.py:265-330`)
+
+Extract:
+1. `_log_alert_threshold_warnings(*, user_id, run, failure_summary, alert_summary) → None` — lines 284-313 (the 3 if-blocks that log threshold warnings)
+
+The main function becomes: summarize → build alerts → log warnings → apply safety → resolve status → finalize → return. ~35 lines.
+
+**3f. `process_scholar` — 61 lines → ≤50** (`scholar_processing.py:343-403`)
+
+The function body is mostly kwargs pass-through. Check if the actual body (excluding the 18-line signature) is ≤50 lines — it's ~43 lines of body. If so, this is acceptable under the kwargs exception. Document and move on.
+
+**3g. `_fetch_and_prepare_scholar_result` — 59 lines → ≤50** (`scholar_processing.py:406-464`)
+
+Same analysis: 16-line signature, 43-line body. If the body alone is ≤50, this is kwargs-acceptable. Document and move on.
+
+**3h. `_perform_live_author_search` — 60 lines → ≤50** (`author_search.py:459-518`)
+
+18-line signature, 42-line body. Kwargs-acceptable. Document and move on.
+
+**3i. `search_author_candidates` — 60 lines → ≤50** (`author_search.py:521-580`)
+
+19-line signature, 41-line body. Kwargs-acceptable. Document and move on.
+
+**3j. `ScholarIngestionService.initialize_run` — 58 lines → ≤50** (`application.py:315-372`)
+
+20-line signature, 38-line body. Kwargs-acceptable. Document and move on.
+
+Commit message: `refactor: extract helpers from remaining long functions`
+
+---
+
+## Verification (after all 3 passes)
+
+```bash
+# No function exceeds 50 lines (body, excluding kwargs signatures that exceed the limit)
+# Run the AST checker from the audit to verify
+
+# All tests pass
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app python -m pytest
+
+# Linting
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app ruff check .
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app ruff format --check .
+
+# Type checking
+docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app mypy app/
+```
-- 
2.49.1


From e8e20637e6d7e6f7c32ca42dc454b386ab9f3fcc Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Fri, 27 Feb 2026 16:44:54 +0100
Subject: [PATCH 36/38] Better crawling safety with preflight checks and
 cooldowns

---
 app/services/ingestion/application.py        | 50 ++++++++++++++
 app/services/ingestion/preflight.py          | 70 ++++++++++++++++++++
 app/services/ingestion/scholar_processing.py | 39 ++++++++++-
 app/services/scholar/state_detection.py      |  5 ++
 frontend/src/pages/DashboardPage.vue         |  5 ++
 frontend/src/pages/RunsPage.vue              |  5 ++
 6 files changed, 172 insertions(+), 2 deletions(-)
 create mode 100644 app/services/ingestion/preflight.py

diff --git a/app/services/ingestion/application.py b/app/services/ingestion/application.py
index 9bfc46a..6087925 100644
--- a/app/services/ingestion/application.py
+++ b/app/services/ingestion/application.py
@@ -21,6 +21,7 @@ from app.services.ingestion import safety as run_safety_service
 from app.services.ingestion.constants import RUN_LOCK_NAMESPACE
 from app.services.ingestion.enrichment import EnrichmentRunner
 from app.services.ingestion.pagination import PaginationEngine
+from app.services.ingestion.preflight import check_scholar_reachable
 from app.services.ingestion.run_completion import (
     complete_run_for_user,
     int_or_default,
@@ -231,6 +232,49 @@ class ScholarIngestionService:
                 await queue_service.clear_job_for_scholar(db_session, user_id=user_id, scholar_profile_id=sid)
         return scholars
 
+    async def _run_preflight_guard(
+        self,
+        db_session: AsyncSession,
+        *,
+        user_settings: Any,
+        user_id: int,
+        scholars: list[ScholarProfile],
+    ) -> None:
+        if not scholars:
+            return
+        result = await check_scholar_reachable(
+            self._source,
+            scholar_id=scholars[0].scholar_id,
+        )
+        if result.passed:
+            return
+        now_utc = datetime.now(UTC)
+        safety_state, _ = run_safety_service.apply_run_safety_outcome(
+            user_settings,
+            run_id=0,
+            blocked_failure_count=1,
+            network_failure_count=0,
+            blocked_failure_threshold=1,
+            network_failure_threshold=1,
+            blocked_cooldown_seconds=settings.ingestion_safety_cooldown_blocked_seconds,
+            network_cooldown_seconds=settings.ingestion_safety_cooldown_network_seconds,
+            now_utc=now_utc,
+        )
+        await db_session.commit()
+        structured_log(
+            logger,
+            "warning",
+            "ingestion.cooldown_entered_preflight",
+            user_id=user_id,
+            block_reason=result.block_reason,
+            cooldown_until=safety_state.get("cooldown_until"),
+        )
+        raise RunBlockedBySafetyPolicyError(
+            code="scrape_cooldown_active",
+            message=f"Preflight detected Scholar block ({result.block_reason}). Cooldown activated.",
+            safety_state=safety_state,
+        )
+
     async def _initialize_run_for_user(
         self,
         db_session: AsyncSession,
@@ -257,6 +301,12 @@ class ScholarIngestionService:
             user_id=user_id,
             filtered_scholar_ids=filtered_scholar_ids,
         )
+        await self._run_preflight_guard(
+            db_session,
+            user_settings=user_settings,
+            user_id=user_id,
+            scholars=scholars,
+        )
         run = await self._start_run_record(
             db_session,
             user_id=user_id,
diff --git a/app/services/ingestion/preflight.py b/app/services/ingestion/preflight.py
new file mode 100644
index 0000000..44441e3
--- /dev/null
+++ b/app/services/ingestion/preflight.py
@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from app.logging_utils import structured_log
+from app.services.scholar.source import FetchResult, ScholarSource
+from app.services.scholar.state_detection import (
+    classify_block_or_captcha_reason,
+    is_hard_challenge_reason,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class PreflightResult:
+    passed: bool
+    block_reason: str | None
+    status_code: int | None
+
+
+def _evaluate_fetch_result(fetch_result: FetchResult) -> PreflightResult:
+    if fetch_result.status_code is None:
+        return PreflightResult(passed=True, block_reason=None, status_code=None)
+    block_reason = classify_block_or_captcha_reason(
+        status_code=fetch_result.status_code,
+        final_url=(fetch_result.final_url or "").lower(),
+        body_lowered=fetch_result.body.lower(),
+    )
+    if block_reason is not None and is_hard_challenge_reason(block_reason):
+        return PreflightResult(
+            passed=False,
+            block_reason=block_reason,
+            status_code=fetch_result.status_code,
+        )
+    return PreflightResult(
+        passed=True,
+        block_reason=None,
+        status_code=fetch_result.status_code,
+    )
+
+
+async def check_scholar_reachable(
+    source: ScholarSource,
+    *,
+    scholar_id: str,
+) -> PreflightResult:
+    """Single-request probe to detect active Scholar blocks before a full run."""
+    structured_log(logger, "info", "ingestion.preflight_started", scholar_id=scholar_id)
+    fetch_result = await source.fetch_profile_html(scholar_id)
+    result = _evaluate_fetch_result(fetch_result)
+    if result.passed:
+        structured_log(
+            logger,
+            "info",
+            "ingestion.preflight_passed",
+            scholar_id=scholar_id,
+            status_code=result.status_code,
+        )
+    else:
+        structured_log(
+            logger,
+            "warning",
+            "ingestion.preflight_failed",
+            scholar_id=scholar_id,
+            block_reason=result.block_reason,
+            status_code=result.status_code,
+        )
+    return result
diff --git a/app/services/ingestion/scholar_processing.py b/app/services/ingestion/scholar_processing.py
index 2bbddfd..37b47d3 100644
--- a/app/services/ingestion/scholar_processing.py
+++ b/app/services/ingestion/scholar_processing.py
@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import random
 from datetime import UTC, datetime
 from typing import Any
 
@@ -27,6 +28,7 @@ from app.services.ingestion.types import (
     ScholarProcessingOutcome,
 )
 from app.services.scholar.parser import ParseState
+from app.services.scholar.state_detection import is_hard_challenge_reason
 
 logger = logging.getLogger(__name__)
 
@@ -528,6 +530,13 @@ def unexpected_scholar_exception_outcome(
     )
 
 
+def _is_hard_challenge_outcome(outcome: ScholarProcessingOutcome) -> bool:
+    entry = outcome.result_entry
+    return str(entry.get("state", "")) == ParseState.BLOCKED_OR_CAPTCHA.value and is_hard_challenge_reason(
+        str(entry.get("state_reason", ""))
+    )
+
+
 async def _run_first_pass(
     db_session: AsyncSession,
     *,
@@ -548,7 +557,8 @@ async def _run_first_pass(
             structured_log(logger, "info", "ingestion.run_canceled", run_id=run.id, user_id=user_id)
             return first_pass_cstarts
         if index > 0 and request_delay_seconds > 0:
-            await asyncio.sleep(float(request_delay_seconds))
+            jitter = random.uniform(0.0, min(float(request_delay_seconds), 2.0))
+            await asyncio.sleep(float(request_delay_seconds) + jitter)
         start_cstart = int(start_cstart_map.get(int(scholar.id), 0))
         outcome = await process_scholar(
             db_session,
@@ -563,6 +573,18 @@ async def _run_first_pass(
             **scholar_kwargs,
         )
         apply_outcome_to_progress(progress=progress, outcome=outcome)
+        if _is_hard_challenge_outcome(outcome):
+            structured_log(
+                logger,
+                "warning",
+                "ingestion.run_aborted_hard_challenge",
+                run_id=run.id,
+                user_id=user_id,
+                scholar_id=scholar.scholar_id,
+                state_reason=outcome.result_entry.get("state_reason"),
+                scholars_remaining=len(scholars) - index - 1,
+            )
+            return first_pass_cstarts
         resume_cstart = outcome.result_entry.get("continuation_cstart")
         if resume_cstart is not None and int(resume_cstart) > start_cstart:
             first_pass_cstarts[int(scholar.id)] = int(resume_cstart)
@@ -593,7 +615,8 @@ async def _run_depth_pass(
             structured_log(logger, "info", "ingestion.run_canceled", run_id=run.id, user_id=user_id)
             break
         if index > 0 and request_delay_seconds > 0:
-            await asyncio.sleep(float(request_delay_seconds))
+            jitter = random.uniform(0.0, min(float(request_delay_seconds), 2.0))
+            await asyncio.sleep(float(request_delay_seconds) + jitter)
         outcome = await process_scholar(
             db_session,
             pagination=pagination,
@@ -607,6 +630,18 @@ async def _run_depth_pass(
             **scholar_kwargs,
         )
         apply_outcome_to_progress(progress=progress, outcome=outcome)
+        if _is_hard_challenge_outcome(outcome):
+            structured_log(
+                logger,
+                "warning",
+                "ingestion.run_aborted_hard_challenge",
+                run_id=run.id,
+                user_id=user_id,
+                scholar_id=scholar.scholar_id,
+                state_reason=outcome.result_entry.get("state_reason"),
+                scholars_remaining=len(scholars) - index - 1,
+            )
+            break
 
 
 async def run_scholar_iteration(
diff --git a/app/services/scholar/state_detection.py b/app/services/scholar/state_detection.py
index 7532afa..28a413d 100644
--- a/app/services/scholar/state_detection.py
+++ b/app/services/scholar/state_detection.py
@@ -30,6 +30,11 @@ def classify_network_error_reason(fetch_error: str | None) -> str:
     return "network_error_missing_status_code"
 
 
+def is_hard_challenge_reason(state_reason: str) -> bool:
+    """True if the block reason indicates an active Scholar challenge (not retryable in short loops)."""
+    return state_reason.startswith("blocked_") and state_reason != "blocked_http_429_rate_limited"
+
+
 def classify_block_or_captcha_reason(
     *,
     status_code: int,
diff --git a/frontend/src/pages/DashboardPage.vue b/frontend/src/pages/DashboardPage.vue
index fce9e02..fbd0b4c 100644
--- a/frontend/src/pages/DashboardPage.vue
+++ b/frontend/src/pages/DashboardPage.vue
@@ -2,6 +2,7 @@
 import { computed, onMounted, onUnmounted, ref, watch } from "vue";
 
 import { fetchDashboardSnapshot, type DashboardSnapshot } from "@/features/dashboard";
+import { formatCooldownCountdown } from "@/features/safety";
 import { ApiRequestError } from "@/lib/api/errors";
 import AppPage from "@/components/layout/AppPage.vue";
 import AsyncStateGate from "@/components/patterns/AsyncStateGate.vue";
@@ -53,6 +54,10 @@ const startCheckLabel = computed(() => {
     return "Manual checks disabled";
   }
   if (runStatus.safetyState.cooldown_active) {
+    const remaining = runStatus.safetyState.cooldown_remaining_seconds;
+    if (remaining > 0) {
+      return `Cooldown (${formatCooldownCountdown(remaining)})`;
+    }
     return "Safety cooldown";
   }
   if (runStatus.isLikelyRunning) {
diff --git a/frontend/src/pages/RunsPage.vue b/frontend/src/pages/RunsPage.vue
index d28a3dc..49894b7 100644
--- a/frontend/src/pages/RunsPage.vue
+++ b/frontend/src/pages/RunsPage.vue
@@ -22,6 +22,7 @@ import {
   type QueueItem,
   type RunListItem,
 } from "@/features/runs";
+import { formatCooldownCountdown } from "@/features/safety";
 import { ApiRequestError } from "@/lib/api/errors";
 import { useAuthStore } from "@/stores/auth";
 import { useRunStatusStore } from "@/stores/run_status";
@@ -89,6 +90,10 @@ const runButtonLabel = computed(() => {
     return "Manual checks disabled";
   }
   if (runStatus.safetyState.cooldown_active) {
+    const remaining = runStatus.safetyState.cooldown_remaining_seconds;
+    if (remaining > 0) {
+      return `Cooldown (${formatCooldownCountdown(remaining)})`;
+    }
     return "Safety cooldown";
   }
   if (runStatus.isLikelyRunning) {
-- 
2.49.1


From a5165dc3bae228fb8c41bd1816bbf236df2aa33d Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Sun, 1 Mar 2026 18:14:22 +0100
Subject: [PATCH 37/38] after audit

---
 .claude/settings.json                         |   17 +
 .github/workflows/release.yml                 |    5 +-
 DECOMPOSITION_CLEANUP.md                      |  193 --
 DECOMPOSITION_SLICES.md                       |  242 --
 MODERNIZATION_PLAN.md                         |  628 ----
 agents.md                                     |    2 +-
 app/api/routers/run_manual.py                 |   18 +-
 app/api/routers/runs.py                       |   41 +-
 app/api/schemas/admin.py                      |    6 +-
 app/api/schemas/auth.py                       |   12 +-
 app/db/session.py                             |    2 +-
 app/http/middleware.py                        |   12 +-
 app/main.py                                   |    9 +-
 app/security/csrf.py                          |   26 +-
 app/services/arxiv/rate_limit.py              |   35 +-
 app/services/crossref/application.py          |    3 +-
 app/services/dbops/near_duplicate_repair.py   |   10 +-
 app/services/ingestion/application.py         |  277 +-
 app/services/ingestion/enrichment.py          |   26 +-
 app/services/ingestion/page_fetch.py          |   12 +-
 app/services/ingestion/pagination.py          |    6 +-
 app/services/ingestion/publication_upsert.py  |    7 +-
 app/services/ingestion/queue_runner.py        |    8 +-
 app/services/ingestion/run_completion.py      |   28 +
 app/services/ingestion/run_enrichment.py      |  110 +
 app/services/ingestion/run_guards.py          |  135 +
 app/services/ingestion/scheduler.py           |   18 +-
 app/services/ingestion/scholar_outcomes.py    |  308 ++
 app/services/ingestion/scholar_processing.py  |  299 +-
 app/services/openalex/client.py               |   27 +-
 app/services/publications/pdf_queue_common.py |    1 +
 .../publications/pdf_queue_queries.py         |   11 +-
 .../publications/pdf_queue_resolution.py      |    2 +-
 app/services/publications/queries.py          |   14 +-
 app/services/runs/events.py                   |   24 +-
 app/services/scholar/profile_rows.py          |    5 +-
 app/services/unpaywall/application.py         |    2 +-
 frontend/package-lock.json                    |  700 +++++
 frontend/package.json                         |    2 +
 .../src/composables/useRequestState.test.ts   |   51 +
 frontend/src/composables/useRequestState.ts   |   40 +
 .../components/PublicationTableRow.test.ts    |  139 +
 .../components/PublicationTableRow.vue        |  178 ++
 .../components/PublicationToolbar.test.ts     |   89 +
 .../components/PublicationToolbar.vue         |  148 +
 .../composables/usePublicationData.test.ts    |  118 +
 .../composables/usePublicationData.ts         |  338 ++
 .../components/ScholarBatchAdd.test.ts        |   76 +
 .../scholars/components/ScholarBatchAdd.vue   |   89 +
 .../components/ScholarNameSearch.test.ts      |   43 +
 .../scholars/components/ScholarNameSearch.vue |  167 +
 .../components/ScholarSettingsModal.test.ts   |   92 +
 .../components/ScholarSettingsModal.vue       |  113 +
 .../features/settings/SettingsAdminPanel.vue  | 1097 +------
 .../components/AdminIntegritySection.test.ts  |   72 +
 .../components/AdminIntegritySection.vue      |   88 +
 .../components/AdminPdfQueueSection.test.ts   |  104 +
 .../components/AdminPdfQueueSection.vue       |  203 ++
 .../components/AdminRepairsSection.test.ts    |   91 +
 .../components/AdminRepairsSection.vue        |  372 +++
 .../components/AdminUsersSection.test.ts      |   84 +
 .../settings/components/AdminUsersSection.vue |  211 ++
 frontend/src/pages/PublicationsPage.vue       | 1165 ++-----
 frontend/src/pages/ScholarsPage.vue           | 1179 ++-----
 tests/integration/helpers.py                  |  114 +
 tests/integration/test_api_admin.py           |  576 ++++
 tests/integration/test_api_auth.py            |  182 ++
 tests/integration/test_api_publications.py    |  573 ++++
 .../test_api_publications_advanced.py         |  337 ++
 tests/integration/test_api_runs.py            |  499 +++
 tests/integration/test_api_scholars.py        |  370 +++
 tests/integration/test_api_settings.py        |  183 ++
 tests/integration/test_api_v1.py              | 2721 -----------------
 tests/integration/test_fixture_probe_runs.py  |    2 +-
 .../test_run_lifecycle_consistency.py         |   29 +-
 tests/unit/test_logging_policy.py             |   40 +
 tests/unit/test_portability_import.py         |  121 +
 tests/unit/test_portability_normalize.py      |  193 ++
 tests/unit/test_scholar_validators.py         |  142 +
 tests/unit/test_user_validation.py            |   79 +
 80 files changed, 8489 insertions(+), 7302 deletions(-)
 create mode 100644 .claude/settings.json
 delete mode 100644 DECOMPOSITION_CLEANUP.md
 delete mode 100644 DECOMPOSITION_SLICES.md
 delete mode 100644 MODERNIZATION_PLAN.md
 create mode 100644 app/services/ingestion/run_enrichment.py
 create mode 100644 app/services/ingestion/run_guards.py
 create mode 100644 app/services/ingestion/scholar_outcomes.py
 create mode 100644 frontend/src/composables/useRequestState.test.ts
 create mode 100644 frontend/src/composables/useRequestState.ts
 create mode 100644 frontend/src/features/publications/components/PublicationTableRow.test.ts
 create mode 100644 frontend/src/features/publications/components/PublicationTableRow.vue
 create mode 100644 frontend/src/features/publications/components/PublicationToolbar.test.ts
 create mode 100644 frontend/src/features/publications/components/PublicationToolbar.vue
 create mode 100644 frontend/src/features/publications/composables/usePublicationData.test.ts
 create mode 100644 frontend/src/features/publications/composables/usePublicationData.ts
 create mode 100644 frontend/src/features/scholars/components/ScholarBatchAdd.test.ts
 create mode 100644 frontend/src/features/scholars/components/ScholarBatchAdd.vue
 create mode 100644 frontend/src/features/scholars/components/ScholarNameSearch.test.ts
 create mode 100644 frontend/src/features/scholars/components/ScholarNameSearch.vue
 create mode 100644 frontend/src/features/scholars/components/ScholarSettingsModal.test.ts
 create mode 100644 frontend/src/features/scholars/components/ScholarSettingsModal.vue
 create mode 100644 frontend/src/features/settings/components/AdminIntegritySection.test.ts
 create mode 100644 frontend/src/features/settings/components/AdminIntegritySection.vue
 create mode 100644 frontend/src/features/settings/components/AdminPdfQueueSection.test.ts
 create mode 100644 frontend/src/features/settings/components/AdminPdfQueueSection.vue
 create mode 100644 frontend/src/features/settings/components/AdminRepairsSection.test.ts
 create mode 100644 frontend/src/features/settings/components/AdminRepairsSection.vue
 create mode 100644 frontend/src/features/settings/components/AdminUsersSection.test.ts
 create mode 100644 frontend/src/features/settings/components/AdminUsersSection.vue
 create mode 100644 tests/integration/test_api_admin.py
 create mode 100644 tests/integration/test_api_auth.py
 create mode 100644 tests/integration/test_api_publications.py
 create mode 100644 tests/integration/test_api_publications_advanced.py
 create mode 100644 tests/integration/test_api_runs.py
 create mode 100644 tests/integration/test_api_scholars.py
 create mode 100644 tests/integration/test_api_settings.py
 delete mode 100644 tests/integration/test_api_v1.py
 create mode 100644 tests/unit/test_logging_policy.py
 create mode 100644 tests/unit/test_portability_import.py
 create mode 100644 tests/unit/test_portability_normalize.py
 create mode 100644 tests/unit/test_scholar_validators.py
 create mode 100644 tests/unit/test_user_validation.py

diff --git a/.claude/settings.json b/.claude/settings.json
new file mode 100644
index 0000000..9fa7fd3
--- /dev/null
+++ b/.claude/settings.json
@@ -0,0 +1,17 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(wc -l /home/jv/src/personal/playground/scholar_scraper/scholar-scraper/frontend/src/features/settings/SettingsAdminPanel.vue /home/jv/src/personal/playground/scholar_scraper/scholar-scraper/frontend/src/features/settings/components/Admin*.vue)",
+      "Read(//home/jv/src/personal/playground/scholar_scraper/scholar-scraper/**)",
+      "Bash(while read line rest)",
+      "Bash(do echo \"$line $rest\")",
+      "Bash(done)",
+      "Bash(grep -c 'def test_' tests/unit/*.py tests/unit/**/*.py tests/integration/*.py)",
+      "Bash(sort -t: -k2 -rn)",
+      "Bash(wc -l frontend/src/pages/*.vue)"
+    ],
+    "additionalDirectories": [
+      "/home/jv/src/personal/playground/scholar_scraper/scholar-scraper/frontend/src"
+    ]
+  }
+}
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 0e0166c..9f39e29 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -19,9 +19,10 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: "3.12"
-      - run: pip install python-semantic-release
+      - uses: astral-sh/setup-uv@v4
+      - run: uv sync --extra dev
       - name: Semantic Release
         id: release
-        run: semantic-release publish
+        run: uv run semantic-release publish
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/DECOMPOSITION_CLEANUP.md b/DECOMPOSITION_CLEANUP.md
deleted file mode 100644
index f95de24..0000000
--- a/DECOMPOSITION_CLEANUP.md
+++ /dev/null
@@ -1,193 +0,0 @@
-# Decomposition Cleanup — 3-Pass Fix Prompt
-
-You are working on the scholarr repository (`feat/decomposition` branch). A decomposition refactor split oversized files into focused modules. An audit found residual issues. Fix them in 3 sequential passes.
-
-**Read `agents.md` before starting.** Key rules:
-- Function length: 50 lines max
-- File length: 400 target, 600 hard ceiling (kwargs-heavy signatures are acceptable overage)
-- No dead code, no duplicate boilerplate, no backward-compatibility shims
-- All business logic in `app/services/<domain>/`
-- Use `structured_log()` for domain logging
-
-**Constraints for every pass:**
-- Pure refactoring — no behavioral changes
-- All tests must pass after each pass: `docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app python -m pytest`
-- Commit after each pass using conventional commit format
-
----
-
-## Pass 1: Naming, DRY, and Dead Code
-
-**1a. Rename `_int_or_default` → `int_or_default`**
-
-This function in `app/services/ingestion/run_completion.py:38` is imported externally by `app/services/ingestion/application.py:25`, making it public API with a private-convention name.
-
-- Rename the definition in `run_completion.py` (line 38)
-- Update all internal call sites in `run_completion.py` (lines 71, 350, 375)
-- Update the import in `application.py` (line 25) and call sites (lines 138, 336, 342)
-
-**1b. Consolidate duplicate functions between `pdf_queue.py` and `pdf_queue_resolution.py`**
-
-Three functions exist with identical signatures in both files:
-
-| Function | `pdf_queue.py` | `pdf_queue_resolution.py` |
-|---|---|---|
-| `_utcnow()` | line 46 | line 33 |
-| `_event_row()` | line 150 | line 39 |
-| `_queued_job()` | line 165 | line 60 |
-
-Fix: Keep these in `pdf_queue.py` (the parent module). Have `pdf_queue_resolution.py` import them from `pdf_queue.py`. Since `pdf_queue.py` already imports from `pdf_queue_resolution.py`, check for circular imports — if importing `_utcnow`, `_event_row`, `_queued_job` from `pdf_queue` into `pdf_queue_resolution` would create a cycle, extract them to a shared `pdf_queue_common.py` instead.
-
-Also deduplicate the PDF status constants (`PDF_STATUS_QUEUED`, `PDF_STATUS_RUNNING`, `PDF_STATUS_RESOLVED`, `PDF_STATUS_FAILED`) that are duplicated between `pdf_queue.py` (lines 23-27) and `pdf_queue_resolution.py` (lines 20-23). Keep them in `pdf_queue.py` only.
-
-**1c. Consolidate `_effective_request_delay_seconds` duplication**
-
-`scheduler.py` (lines 32-42) and `queue_runner.py` (line 23-28) both define `_effective_request_delay_seconds` with slightly different signatures. The `queue_runner.py` version takes an explicit `floor` parameter (cleaner). Keep the `queue_runner.py` version. In `scheduler.py`, delete `_request_delay_floor_seconds()` and `_effective_request_delay_seconds()`, and instead import from `queue_runner`:
-
-```python
-from app.services.ingestion.queue_runner import _effective_request_delay_seconds
-```
-
-At the call site in `scheduler.py`, pass `floor=_request_delay_floor_seconds_value` where needed (inline the floor computation or keep it as a one-liner).
-
-Actually — since `_effective_request_delay_seconds` would now be imported externally, rename it to `effective_request_delay_seconds` (drop the underscore) in `queue_runner.py`.
-
-Commit message: `refactor: fix naming, remove duplicate code from decomposition`
-
----
-
-## Pass 2: Function length — ingestion core (6 worst offenders)
-
-All 6 functions are >75 lines. Extract helpers to bring each under 50 lines. Below is specific guidance for each.
-
-**2a. `EnrichmentRunner.enrich_pending_publications` — 133 lines → ≤50** (`enrichment.py:47-179`)
-
-This function does 4 things: load publications, set up client, batch-loop with API calls, run dedup sweep. Extract:
-
-1. `_load_unenriched_publications(db_session, *, run_id) → list[Publication]` — lines 66-87 (query + return)
-2. `_enrich_batch(self, db_session, *, batch, run_id, client, openalex_works, now) → bool` — lines 142-166 (per-publication enrichment loop; return False if canceled). This inner loop iterates `batch`, calls `_discover_identifiers_for_enrichment`, and applies the match. The caller handles the outer batch loop and API call.
-3. `_flush_and_sweep_duplicates(db_session, *, run_id)` — lines 167-179 (flush + dedup sweep)
-
-The main function becomes: load pubs → early return → create client → batch loop (API call + `_enrich_batch`) → `_flush_and_sweep_duplicates`.
-
-**2b. `EnrichmentRunner.enrich_publications_with_openalex` — 64 lines → ≤50** (`enrichment.py:260-323`)
-
-Extract:
-1. `_sanitize_titles(publications) → list[str]` — lines 279-286 (title cleaning loop)
-
-The outer batch loop + match logic stays in the main method, which should now fit in ~45 lines.
-
-**2c. `ScholarIngestionService.run_for_user` — 99 lines → ≤50** (`application.py:525-623`)
-
-This function calls `initialize_run`, builds paging/threshold kwargs, calls `run_scholar_iteration`, `complete_run_for_user`, handles enrichment, commits, and logs. Extract:
-
-1. `_run_iteration_and_complete(self, db_session, *, run, scholars, user_id, start_cstart_map, paging, thresholds, auto_queue_continuations, queue_delay_seconds, idempotency_key) → tuple[RunProgress, RunFailureSummary, RunAlertSummary]` — lines 579-599 (the iteration + completion block). This calls `run_scholar_iteration` and `complete_run_for_user` and returns their results.
-2. `_inline_enrich_and_finalize(self, db_session, *, run, user_settings, intended_final_status) → None` — lines 604-614 (enrichment + status fixup + commit). This calls `enrich_pending_publications`, handles the exception, fixes status, and commits.
-
-**2d. `ScholarIngestionService.execute_run` — 88 lines → ≤50** (`application.py:374-461`)
-
-Extract:
-1. `_execute_run_body(self, db_session, session_factory, *, run_id, user_id, scholars, start_cstart_map, paging, thresholds, auto_queue_continuations, queue_delay_seconds, idempotency_key) → None` — lines 411-457 (the try-body: prepare, iterate, complete, commit, log, spawn enrichment task). The outer `execute_run` handles kwargs resolution and the `async with session_factory()` + `except`.
-
-Or alternatively, the `_resolve_paging_kwargs` / `_threshold_kwargs` calls can be lifted into the caller or inlined since they're trivial dict builders — this alone may shave enough lines. Consider whether the kwargs signature itself is the bulk (it is — 22 lines of signature). If so, this function may be acceptable as-is per the kwargs-exception rule. Use your judgment: if the function body (excluding signature and kwargs resolution) is ≤50 lines, document it as acceptable and move on.
-
-**2e. `run_scholar_iteration` — 84 lines → ≤50** (`scholar_processing.py:531-614`)
-
-This has two clear phases: pass 1 (breadth-first, lines 560-584) and pass 2 (depth, lines 586-614). Extract:
-
-1. `_run_first_pass(db_session, *, scholars, pagination, run, user_id, start_cstart_map, scholar_kwargs, request_delay_seconds, queue_delay_seconds, progress) → dict[int, int]` — the breadth-first loop (lines 560-584), returns `first_pass_cstarts`
-2. `_run_depth_pass(db_session, *, scholars, first_pass_cstarts, pagination, run, user_id, scholar_kwargs, request_delay_seconds, remaining_max, auto_queue_continuations, queue_delay_seconds, progress) → None` — the depth loop (lines 591-613)
-
-The main function becomes: build kwargs → call pass 1 → compute remaining → call pass 2 → return progress.
-
-**2f. `QueueJobRunner._finalize_queue_job_after_run` — 79 lines → ≤50** (`queue_runner.py:284-362`)
-
-Two branches: success path (lines 287-311) and failure path (lines 312-362). Extract:
-
-1. `_finalize_successful_queue_job(self, session, job, run_summary) → None` — success path
-2. `_finalize_failed_queue_job(self, session, job, run_summary) → None` — failure path
-
-The main function opens a session, branches on `failed_count`, and delegates.
-
-Commit message: `refactor: extract helpers from long functions in ingestion core`
-
----
-
-## Pass 3: Function length — remaining violations (10 functions, 58-75 lines)
-
-**3a. `run_manual` — 105 lines → ≤50** (`app/api/routers/runs.py:183-287`)
-
-This route handler has a large try block. Extract:
-
-1. `_start_manual_run(db_session, *, current_user, ingest_service, idempotency_key) → tuple[CrawlRun, list, dict]` — lines 205-221 (initialize_run call with all the settings kwargs)
-2. `_spawn_background_execution(ingest_service, *, run, current_user, scholars, start_cstart_map, user_settings, idempotency_key) → None` — lines 226-249 (create_task + background_tasks management)
-3. `_manual_run_success_response(request, *, run, idempotency_key, db_session, current_user) → dict` — lines 251-265 (build success payload)
-
-The route handler becomes: load safety → check disabled → check idempotency → try: start → spawn → respond; except: handle errors.
-
-**3b. `PaginationEngine._paginate_loop` — 75 lines → ≤50** (`pagination.py:276-350`)
-
-Extract:
-1. `_upsert_page_publications(self, db_session, *, run, scholar, publications, seen_canonical, state, upsert_publications_fn)` — the dedup + upsert block (appears twice: lines 294-302 and 339-347). Deduplicate by extracting a single helper called from both places.
-
-This should bring the loop body under 50 lines.
-
-**3c. `PaginationEngine.fetch_and_parse_all_pages` — 72 lines → ≤50** (`pagination.py:415-486`)
-
-Most of the length is the kwargs-heavy calls. Check if the function body (excluding the 17-line signature) is ≤50 lines — it should be ~55. Extract:
-1. Move the `_short_circuit_initial_page` + `_build_loop_state` + `_paginate_loop` + `_result_from_pagination_state` sequence into a helper `_paginate_from_initial_page(self, *, scholar, run, db_session, state, ...) → PagedParseResult` if needed. Or accept this as kwargs-acceptable overage and document why.
-
-**3d. `PageFetcher.fetch_and_parse_with_retry` — 70 lines → ≤50** (`page_fetch.py:148-217`)
-
-Extract:
-1. `_classify_attempt(parsed_page, *, network_attempts, rate_limit_attempts) → tuple[int, int, int]` — lines 173-183 (attempt counter logic, returns updated network_attempts, rate_limit_attempts, total_attempts)
-
-This plus the existing `_should_retry` and `_sleep_backoff` helpers should bring the loop under 50 lines.
-
-**3e. `complete_run_for_user` — 66 lines → ≤50** (`run_completion.py:265-330`)
-
-Extract:
-1. `_log_alert_threshold_warnings(*, user_id, run, failure_summary, alert_summary) → None` — lines 284-313 (the 3 if-blocks that log threshold warnings)
-
-The main function becomes: summarize → build alerts → log warnings → apply safety → resolve status → finalize → return. ~35 lines.
-
-**3f. `process_scholar` — 61 lines → ≤50** (`scholar_processing.py:343-403`)
-
-The function body is mostly kwargs pass-through. Check if the actual body (excluding the 18-line signature) is ≤50 lines — it's ~43 lines of body. If so, this is acceptable under the kwargs exception. Document and move on.
-
-**3g. `_fetch_and_prepare_scholar_result` — 59 lines → ≤50** (`scholar_processing.py:406-464`)
-
-Same analysis: 16-line signature, 43-line body. If the body alone is ≤50, this is kwargs-acceptable. Document and move on.
-
-**3h. `_perform_live_author_search` — 60 lines → ≤50** (`author_search.py:459-518`)
-
-18-line signature, 42-line body. Kwargs-acceptable. Document and move on.
-
-**3i. `search_author_candidates` — 60 lines → ≤50** (`author_search.py:521-580`)
-
-19-line signature, 41-line body. Kwargs-acceptable. Document and move on.
-
-**3j. `ScholarIngestionService.initialize_run` — 58 lines → ≤50** (`application.py:315-372`)
-
-20-line signature, 38-line body. Kwargs-acceptable. Document and move on.
-
-Commit message: `refactor: extract helpers from remaining long functions`
-
----
-
-## Verification (after all 3 passes)
-
-```bash
-# No function exceeds 50 lines (body, excluding kwargs signatures that exceed the limit)
-# Run the AST checker from the audit to verify
-
-# All tests pass
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app python -m pytest
-
-# Linting
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app ruff check .
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app ruff format --check .
-
-# Type checking
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app mypy app/
-```
diff --git a/DECOMPOSITION_SLICES.md b/DECOMPOSITION_SLICES.md
deleted file mode 100644
index 4442463..0000000
--- a/DECOMPOSITION_SLICES.md
+++ /dev/null
@@ -1,242 +0,0 @@
-# Scholarr Decomposition Slices
-
-## How to use this file
-
-This file contains self-contained decomposition prompts ("slices") to bring the codebase into compliance with `agents.md` file size rules. Each slice is an independent task for an LLM executor.
-
-**Rules from `agents.md`:**
-- File length: 400 lines target, 600 lines hard ceiling
-- Slightly exceeding the 600-line ceiling is acceptable when the excess is driven by verbose keyword-argument signatures (named parameters), not by business logic density
-- Function length: 50 lines max
-- All business logic in `app/services/<domain>/`
-- Read `agents.md` fully before starting any slice
-
-**Execution protocol:**
-1. Pick the next incomplete slice in order (slices depend on prior ones)
-2. Read the prompt section — it contains everything you need
-3. Read all source files mentioned before making changes
-4. Make the changes described — no business logic changes, only file reorganization
-5. Verify: all imports resolve, all tests pass
-6. Commit with the specified message
-
----
-
-## Progress
-
-| # | Slice | Status |
-|---|-------|--------|
-| 1 | Schema split | **DONE** |
-| 2 | Ingestion: pagination + publication upsert | **DONE** |
-| 3 | Ingestion: enrichment + scholar processing + run completion | **DONE** |
-| 4 | Scholars service + PDF queue | **DONE** |
-| 5 | Routers + scheduler | **DONE** |
-
----
-
-## Slice 1: Split `app/api/schemas.py` into domain packages — DONE
-
-Completed. The 945-line `app/api/schemas.py` was split into `app/api/schemas/` package:
-
-| File | Lines | Contents |
-|---|---|---|
-| `common.py` | 39 | `ApiMeta`, `ApiErrorData`, `ApiErrorEnvelope`, `MessageData`, `MessageEnvelope` |
-| `auth.py` | 73 | `SessionUserData`, `AuthMe*`, `CsrfBootstrap*`, `Login*`, `ChangePasswordRequest` |
-| `scholars.py` | 153 | `ScholarItem*`, `ScholarSearch*`, `ScholarExport*`, `DataExport*`, `DataImport*` |
-| `publications.py` | 151 | `DisplayIdentifierData`, `PublicationItem*`, `MarkAll*`, `MarkSelected*`, `RetryPublication*`, `TogglePublication*` |
-| `runs.py` | 226 | `RunListItem*`, `RunSummary*`, `RunDebug*`, `RunScholarResult*`, `RunDetail*`, `ManualRun*`, `Queue*`, `ScrapeSafety*` |
-| `admin.py` | 289 | All `Admin*` models including PDF queue, repair, near-duplicate schemas |
-| `settings.py` | 54 | `SettingsPolicy*`, `Settings*`, `SettingsUpdateRequest` |
-| `__init__.py` | 7 | Wildcard re-exports — all `from app.api.schemas import X` imports unchanged |
-
----
-
-## Slice 2: Decompose `app/services/ingestion/application.py` — pagination + publication upsert — DONE
-
-Completed. Extracted three modules from `application.py` (2,955 → 2,084 lines):
-
-| File | Lines | Contents |
-|---|---|---|
-| `app/services/ingestion/page_fetch.py` | 219 | `PageFetcher` class — single-page fetch, parse-or-layout-error, retry with backoff |
-| `app/services/ingestion/pagination.py` | 486 | `PaginationEngine` class — multi-page orchestration, loop state, short-circuit, fingerprint checks |
-| `app/services/ingestion/publication_upsert.py` | 239 | Module-level functions — `resolve_publication`, `upsert_profile_publications`, find/create/update helpers |
-
-Also fixed two external import paths (`portability/normalize.py`, `portability/publication_import.py`) that imported `normalize_title`/`build_publication_url` from `application.py` — now correctly sourced from `fingerprints.py`. Updated one integration test to monkeypatch the new module-level function instead of the old instance method.
-
----
-
-## Slice 3: Decompose `app/services/ingestion/application.py` — enrichment, scholar processing, run completion — DONE
-
-Completed. Extracted four logical chunks from `application.py` (2,085 → 635 lines):
-
-| File | Lines | Contents |
-|---|---|---|
-| `app/services/ingestion/enrichment.py` | 323 | `EnrichmentRunner` class — OpenAlex enrichment, identifier discovery, dedup sweep |
-| `app/services/ingestion/scholar_processing.py` | 614 | `process_scholar`, `run_scholar_iteration`, continuation queue, outcome resolution |
-| `app/services/ingestion/run_completion.py` | 417 | `complete_run_for_user`, failure summary, alert summary, safety outcome, progress tracking |
-
-Also updated two tests (`test_ingestion_arxiv_rate_limit.py`, `test_ingestion_progress_reporting.py`) and one integration test (`test_deferred_enrichment.py`) to import from new modules.
-
-**Why:** Three remaining logical chunks. Extracting all three brings `application.py` down to ~500 lines (the orchestration spine).
-
-**Files to create:** `app/services/ingestion/enrichment.py`, `app/services/ingestion/scholar_processing.py`, `app/services/ingestion/run_completion.py`
-
-**Files to modify:** `app/services/ingestion/application.py`
-
-**Prompt:**
-
-You are working on the scholarr repository. Read `agents.md` for project conventions. Continue decomposing `app/services/ingestion/application.py` (slice 2 is complete — `page_fetch.py`, `pagination.py`, and `publication_upsert.py` already extracted). Extract three remaining chunks.
-
-**A. `app/services/ingestion/enrichment.py` (~300 lines)**
-
-Move these methods (post-run OpenAlex enrichment):
-
-- `_run_is_canceled`, `_enrich_pending_publications`, `_discover_identifiers_for_enrichment`
-- `_publish_identifier_update_event`, `_enrich_publications_with_openalex`
-
-Create an `EnrichmentRunner` class that receives service dependencies (OpenAlex client, identifier service, dedup service, DB session factory) in its constructor.
-
-**B. `app/services/ingestion/scholar_processing.py` (~400 lines)**
-
-Move these methods (per-scholar outcome resolution):
-
-- `_assert_valid_paged_parse_result`, `_apply_first_page_profile_metadata`, `_build_result_entry`
-- `_skipped_no_change_outcome`, `_upsert_publications_outcome`, `_upsert_success_or_exception`
-- `_upsert_success`, `_upsert_exception_outcome`, `_parse_failure_outcome`
-- `_sync_continuation_queue`, `_process_scholar`, `_process_scholar_inner`
-- `_fetch_and_prepare_scholar_result`, `_resolve_scholar_outcome`, `_unexpected_scholar_exception_outcome`
-
-These become methods on a `ScholarProcessor` class or module-level functions.
-
-**C. `app/services/ingestion/run_completion.py` (~300 lines)**
-
-Move these methods (run finalization + alerting):
-
-- `_classify_failure_bucket` (standalone function)
-- `_summarize_failures`, `_build_alert_summary`, `_apply_safety_outcome`, `_finalize_run_record`
-- `_resolve_run_status`, `_resolve_continuation_queue_target`, `_build_failure_debug_context`
-- `_complete_run_for_user`
-
-These become module-level functions accepting explicit parameters.
-
-**After all extractions, `application.py` should contain only:**
-
-- `ScholarIngestionService.__init__` and config helpers
-- Run lifecycle: `initialize_run`, `execute_run`, `run_for_user`
-- Scholar iteration orchestration: `_run_scholar_iteration`
-- Progress tracking: `_result_counters`, `_adjust_progress_counts`
-- Safety gate integration, background task management
-
-Target: `application.py` ≤ 500 lines. No new file exceeds 400 lines. All tests must pass unchanged.
-
-Commit message: `refactor: extract enrichment, scholar processing, and run completion from ingestion service`
-
----
-
-## Slice 4: Decompose `app/services/scholars/application.py` (996 lines) and `app/services/publications/pdf_queue.py` (969 lines) — DONE
-
-Completed. Extracted four modules from two oversized service files:
-
-| File | Lines | Contents |
-|---|---|---|
-| `app/services/scholars/author_search_cache.py` | 239 | Serialize/deserialize cache entries, cache get/set/prune |
-| `app/services/scholars/author_search.py` | 580 | Cooldown, throttle, retry, circuit breaker, `search_author_candidates` |
-| `app/services/scholars/application.py` | 221 | Scholar CRUD only (list, create, get, toggle, delete, image ops) |
-| `app/services/publications/pdf_queue_queries.py` | 395 | SQL builders, row hydration, listing/counting/pagination, retry item builders |
-| `app/services/publications/pdf_queue_resolution.py` | 311 | Task execution, outcome persistence, scheduling (`schedule_rows`) |
-| `app/services/publications/pdf_queue.py` | 364 | Dataclasses, constants, enqueueing logic, public API |
-
-Also updated one test file (`test_publication_pdf_queue_policy.py`) to monkeypatch `pdf_queue_resolution` instead of `pdf_queue` for the 4 resolution-related tests, and updated `publications/application.py` and `publication_identifiers/application.py` imports.
-
-**Prompt:**
-
-You are working on the scholarr repository. Read `agents.md` for project conventions. Two service files exceed the 600-line ceiling. Decompose both.
-
-**A. `app/services/scholars/application.py` (996 lines)**
-
-This file mixes scholar CRUD (~350 lines) with the entire author search pipeline (~650 lines). Split them:
-
-Create `app/services/scholars/author_search_cache.py` (~150 lines): Move all `_serialize_*` and `_deserialize_*` functions. Move `_cache_get_author_search_result`, `_cache_set_author_search_result`, `_prune_author_search_cache`. These are pure functions operating on the DB cache table.
-
-Create `app/services/scholars/author_search.py` (~500 lines): Move remaining author search functions — cooldown management, throttle logic, retry wrappers, circuit breaker, lock acquisition, and `search_author_candidates`. Import cache functions from `author_search_cache.py`. Accept DB session and settings as explicit parameters.
-
-Update `application.py`: Keep only scholar CRUD methods. Import and delegate to `search_author_candidates` from `author_search.py`. Target: ≤ 350 lines.
-
-**B. `app/services/publications/pdf_queue.py` (969 lines)**
-
-Three concerns in one file. Split by concern:
-
-Create `app/services/publications/pdf_queue_queries.py` (~330 lines): Move SQL query builders (`_tracked_queue_select_base`, `_tracked_queue_select`, etc.), result hydration (`_queue_item_from_row`, `_hydrated_queue_items`), listing/counting/pagination (`list_pdf_queue_items`, `count_pdf_queue_items`, `list_pdf_queue_page`), retry item builders and missing-PDF candidate queries.
-
-Create `app/services/publications/pdf_queue_resolution.py` (~300 lines): Move task execution (`_mark_attempt_started`, `_failed_outcome`, `_fetch_outcome_for_row`), outcome persistence (`_apply_publication_update`, `_apply_job_outcome`, `_persist_outcome`), scheduling (`_resolve_publication_row`, `_run_resolution_task`, `_register_task`, `_drop_finished_task`, `_schedule_rows`).
-
-Keep in `pdf_queue.py` (~340 lines): dataclasses, constants, enqueueing logic, public API.
-
-No file should exceed 500 lines. All tests must pass unchanged.
-
-Commit message: `refactor: decompose scholars service and pdf_queue into focused modules`
-
----
-
-## Slice 5: Decompose router files and scheduler — DONE
-
-Completed. Extracted helpers from three oversized files:
-
-| File | Lines | Contents |
-|---|---|---|
-| `app/api/routers/run_serializers.py` | 238 | `serialize_run`, `serialize_queue_item`, `normalize_scholar_result`, `manual_run_payload_from_run`, `manual_run_success_payload`, value coercion helpers, idempotency key validation |
-| `app/api/routers/run_manual.py` | 237 | `load_safety_state`, `raise_manual_runs_disabled`, `reused_manual_run_payload`, `run_ingestion_for_manual`, `recover_integrity_error`, `execute_manual_run`, safety/failure raise helpers |
-| `app/api/routers/runs.py` | 440 | Route handlers only + imports |
-| `app/api/routers/scholar_helpers.py` | 234 | `serialize_scholar`, `hydrate_scholar_metadata_if_needed`, `enqueue_initial_scrape_job_for_scholar`, `search_kwargs`, `search_response_data`, `require_user_profile`, `read_uploaded_image` |
-| `app/api/routers/scholars.py` | 406 | Route handlers only + imports |
-| `app/services/ingestion/queue_runner.py` | 379 | `QueueJobRunner` class — drain continuation queue, job lifecycle (drop/retry/reschedule), ingestion dispatch, finalization |
-| `app/services/ingestion/scheduler.py` | 312 | `SchedulerService` — auto-run scheduling, `_run_loop`, `_tick_once`, candidate loading, PDF queue drain |
-
-Also updated one test file (`test_scholars_create_hydration.py`) to monkeypatch `scholar_helpers` instead of the `scholars` router for the 4 helper-related tests.
-
-**Files to create:** `app/api/routers/run_serializers.py`, `app/api/routers/run_manual.py`, `app/api/routers/scholar_helpers.py`, `app/services/ingestion/queue_runner.py`
-
-**Files to modify:** `app/api/routers/runs.py` (875 → ~405), `app/api/routers/scholars.py` (616 → ~396), `app/services/ingestion/scheduler.py` (622 → ~280)
-
-**Prompt:**
-
-You are working on the scholarr repository. Read `agents.md` for project conventions. Three files are slightly over the 600-line ceiling. Extract helpers from each.
-
-**A. `app/api/routers/runs.py` (875 lines) → 3 files**
-
-Create `app/api/routers/run_serializers.py` (~250 lines): Move all `_serialize_*`, `_normalize_*`, `_int_value`, `_str_value`, `_bool_value` helper functions. Move `_manual_run_payload_from_run` and `_manual_run_success_payload`.
-
-Create `app/api/routers/run_manual.py` (~220 lines): Move `_load_safety_state`, `_raise_manual_runs_disabled`, `_reused_manual_run_payload`, `_run_ingestion_for_manual`, `_recover_integrity_error`, `_execute_manual_run`, `_raise_manual_blocked_safety`, `_raise_manual_failed`.
-
-Keep in `runs.py` (~405 lines): only route handler functions + imports.
-
-**B. `app/api/routers/scholars.py` (616 lines) → 2 files**
-
-Create `app/api/routers/scholar_helpers.py` (~220 lines): Move `_needs_metadata_hydration`, `_is_create_hydration_rate_limited`, `_auto_enqueue_new_scholar_enabled`, `_enqueue_initial_scrape_job_for_scholar`, `_uploaded_image_media_path`, `_serialize_scholar`, `_hydrate_scholar_metadata_if_needed`, `_search_kwargs`, `_search_response_data`, `_read_uploaded_image`, `_require_user_profile`.
-
-Keep in `scholars.py` (~396 lines): only route handlers.
-
-**C. `app/services/ingestion/scheduler.py` (622 lines) → 2 files**
-
-Create `app/services/ingestion/queue_runner.py` (~350 lines): Move all continuation-queue job processing — `_drain_continuation_queue`, `_drop_queue_job_if_max_attempts`, `_mark_queue_job_retrying`, `_queue_job_has_available_scholar`, all `_reschedule_*` methods, `_run_ingestion_for_queue_job`, `_finalize_queue_job_after_run`, `_run_queue_job`. Create a `QueueJobRunner` class receiving config params in constructor.
-
-Keep in `scheduler.py` (~280 lines): auto-run scheduling, `_run_loop`, `_tick_once`, candidate loading.
-
-All tests must pass unchanged after each extraction.
-
-Commit message: `refactor: extract helpers from oversized router and scheduler files`
-
----
-
-## Verification (after all slices)
-
-```bash
-# No Python file exceeds 600 lines
-find app/ -name "*.py" -exec wc -l {} + | awk '$1 > 600 && !/total/ {print "FAIL:", $0}'
-
-# All tests pass
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app python -m pytest
-
-# Linting
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app ruff check .
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app ruff format --check .
-```
diff --git a/MODERNIZATION_PLAN.md b/MODERNIZATION_PLAN.md
deleted file mode 100644
index d51aded..0000000
--- a/MODERNIZATION_PLAN.md
+++ /dev/null
@@ -1,628 +0,0 @@
-# Scholarr Modernization Plan — Slices 2-10
-
-> **Slice 1 is complete** (commit `7736cab`): removed 114 stale `build/` files, fixed `.gitignore`, committed pending deletions, replaced `npm install` with `npm ci` in CI.
->
-> Each slice below is a self-contained prompt designed for an LLM executor. Execute in order — each slice depends on the prior ones being complete.
-
----
-
-## Slice 2: Create `structured_log()` Utility
-
-**Why:** The codebase has 19 `_log_*` helper functions (422 lines) and 138 instances of duplicated `"event"` keys in logging calls. A single utility eliminates all of it.
-
-**Files to create:**
-- `app/logging_utils.py`
-
-**Files to modify:**
-- `tests/unit/test_logging.py`
-
-**Context files (read but don't modify):**
-- `app/logging_config.py` — line 88 has `"event": getattr(record, "event", record.getMessage())` which means when no `event` key is in `extra`, it falls back to `getMessage()`. This is the mechanism that makes `structured_log()` work without duplicating the event name.
-- `app/logging_context.py`
-
-**Prompt:**
-```
-You are working on the scholarr repository. The current logging pattern has a DRY problem:
-
-1. Every log call duplicates the event name as both the message and in extra["event"]:
-   `logger.info("event.name", extra={"event": "event.name", "key": value})`
-
-2. There are 19 `_log_*` helper functions (422 lines total) that just wrap logger calls with typed signatures to build extra dicts.
-
-3. Metrics data (metric_name/metric_value) is mixed into log extra dicts but has no consumer.
-
-Create `app/logging_utils.py`:
-
-```python
-"""Structured logging utility — eliminates boilerplate across domain services."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-
-def structured_log(
-    logger: logging.Logger,
-    level: str,
-    event: str,
-    /,
-    **fields: Any,
-) -> None:
-    """Emit a structured log entry.
-
-    The event name is passed as the log message. The JsonLogFormatter in
-    logging_config.py extracts it via record.getMessage() when no explicit
-    'event' key exists in extra — so we do NOT duplicate it.
-
-    Usage:
-        structured_log(logger, "info", "ingestion.run_started", user_id=1, scholar_count=5)
-    """
-    fields.pop("metric_name", None)
-    fields.pop("metric_value", None)
-
-    log_method = getattr(logger, level.lower())
-    log_method(event, extra=fields)
-```
-
-Verify that `app/logging_config.py` line 88 already handles this correctly — when no `event` key is in extra, it falls back to getMessage() which returns the event string passed as the first argument. No changes to logging_config.py should be needed.
-
-Add tests in `tests/unit/test_logging.py` (append to existing file):
-- Test that `structured_log()` produces a log record where the JsonLogFormatter outputs the event name correctly
-- Test that `structured_log()` works with ConsoleLogFormatter
-- Test that metric_name/metric_value fields are stripped from output
-- Test that extra fields (user_id, scholar_id, etc.) appear in the formatted output
-
-Commit message: "refactor: add structured_log utility to eliminate logging boilerplate"
-```
-
----
-
-## Slice 3: Migrate Ingestion Logging to `structured_log()`
-
-**Why:** `app/services/ingestion/application.py` is 3,089 lines. 8 `_log_*` helpers consume ~239 lines. 34 inline logger calls duplicate event names and include dead metric fields. This slice removes ~300 lines.
-
-**Files to modify:**
-- `app/services/ingestion/application.py`
-
-**Context files:**
-- `app/logging_utils.py` (created in Slice 2)
-
-**Prompt:**
-```
-You are working on the scholarr repository. The file `app/services/ingestion/application.py` (3,089 lines) has 8 `_log_*` helper functions consuming ~239 lines, plus 34 inline logger calls with duplicated `"event":` keys and mixed `metric_name`/`metric_value` fields.
-
-Migrate ALL logging in this file to use `structured_log()` from `app.logging_utils`.
-
-1. Add `from app.logging_utils import structured_log` at the top.
-
-2. Delete these 8 helper methods entirely:
-   - `_log_request_delay_coercion` (line ~123, 21 lines)
-   - `_log_run_started` (line ~310, 36 lines)
-   - `_log_scholar_parsed` (line ~383, 28 lines)
-   - `_log_alert_thresholds` (line ~1013, 47 lines)
-   - `_log_safety_transition` (line ~1093, 42 lines)
-   - `_log_run_completed` (line ~1178, 28 lines)
-   - `_attempt_log_entry` (line ~1837, 16 lines)
-   - `_page_log_entry` (line ~1999, 21 lines)
-
-3. Replace every call to these deleted helpers with an inline `structured_log()` call. Example:
-
-   Before:
-   ```python
-   self._log_run_started(
-       user_id=user_id,
-       trigger_type=trigger_type,
-       scholar_count=scholar_count,
-       ...
-   )
-   ```
-
-   After:
-   ```python
-   structured_log(
-       logger, "info", "ingestion.run_started",
-       user_id=user_id,
-       trigger_type=trigger_type.value,
-       scholar_count=scholar_count,
-       ...
-   )
-   ```
-
-4. For ALL remaining inline `logger.info/warning/debug/exception()` calls:
-   - Replace with `structured_log()` where the call uses `extra={"event": ..., ...}` pattern
-   - Do NOT convert `logger.exception()` calls — keep them but remove the duplicated `"event"` key from their extra dict
-   - Remove `metric_name` and `metric_value` from all calls
-
-5. Do NOT change any business logic. Only logging call sites.
-
-Expected outcome: ~300 lines removed. All existing tests must pass unchanged.
-
-Commit message: "refactor: migrate ingestion service logging to structured_log"
-```
-
----
-
-## Slice 4: Migrate All Remaining Services to `structured_log()`
-
-**Why:** 11 more `_log_*` helpers remain across 8 files (183 lines total), plus inline logger calls with the same duplication pattern in ~20 files.
-
-**Files to modify (all have `_log_*` helpers to delete):**
-- `app/services/ingestion/scheduler.py` — `_log_queue_item_resolved` (line ~518, 21 lines)
-- `app/services/arxiv/rate_limit.py` — `_log_request_scheduled` (199), `_log_request_completed` (216), `_log_cooldown_activated` (235)
-- `app/services/arxiv/client.py` — `_log_cache_event` (283), `_log_request_skipped_for_cooldown` (299)
-- `app/services/publications/pdf_resolution_pipeline.py` — `_log_arxiv_skip` (148)
-- `app/services/unpaywall/application.py` — `_log_resolution_summary` (194)
-- `app/api/routers/publications.py` — `_log_retry_pdf_result` (343)
-- `app/api/routers/settings.py` — `_log_settings_update` (103)
-- `app/main.py` — `_log_startup_build_marker` (53)
-
-**Files to modify (inline `extra={"event":...}` pattern only — no helpers to delete):**
-- `app/http/middleware.py`
-- `app/db/session.py`
-- `app/auth/runtime.py`
-- `app/security/csrf.py`
-- `app/api/routers/scholars.py`
-- `app/api/routers/runs.py`
-- `app/api/routers/admin_dbops.py`
-- `app/api/routers/admin.py`
-- `app/api/routers/auth.py`
-- `app/api/routers/publications.py`
-- `app/services/scholars/application.py`
-- `app/services/runs/events.py`
-- `app/services/openalex/client.py`
-- `app/services/openalex/matching.py`
-- `app/services/crossref/application.py`
-- `app/services/publications/dedup.py`
-- `app/services/publications/enrichment.py`
-- `app/services/publications/pdf_queue.py`
-- `app/services/scholar/source.py`
-- `app/services/arxiv/gateway.py`
-
-**Prompt:**
-```
-You are working on the scholarr repository. Slice 3 migrated `ingestion/application.py` to `structured_log()`. Now do the same for ALL remaining files.
-
-1. Delete these `_log_*` helper functions and replace their call sites with inline `structured_log()`:
-
-   - `app/services/ingestion/scheduler.py:~518` — `_log_queue_item_resolved` (21 lines)
-   - `app/services/arxiv/rate_limit.py:~199` — `_log_request_scheduled` (17 lines)
-   - `app/services/arxiv/rate_limit.py:~216` — `_log_request_completed` (19 lines)
-   - `app/services/arxiv/rate_limit.py:~235` — `_log_cooldown_activated` (13 lines)
-   - `app/services/arxiv/client.py:~283` — `_log_cache_event` (16 lines)
-   - `app/services/arxiv/client.py:~299` — `_log_request_skipped_for_cooldown` (13 lines)
-   - `app/services/publications/pdf_resolution_pipeline.py:~148` — `_log_arxiv_skip` (11 lines)
-   - `app/services/unpaywall/application.py:~194` — `_log_resolution_summary` (21 lines)
-   - `app/api/routers/publications.py:~343` — `_log_retry_pdf_result` (24 lines)
-   - `app/api/routers/settings.py:~103` — `_log_settings_update` (15 lines)
-   - `app/main.py:~53` — `_log_startup_build_marker` (13 lines)
-
-2. In ALL files under `app/` that have inline `logger.info/warning/debug("event.name", extra={"event": "event.name", ...})` calls:
-   - Replace with `structured_log(logger, "level", "event.name", key=value, ...)`
-   - Add `from app.logging_utils import structured_log` import
-   - Remove `metric_name`/`metric_value` from all calls
-   - Keep `logger.exception()` calls but remove the duplicated `"event"` key from their extra dicts
-
-3. In `app/services/openalex/client.py`, the lines that log `response.text` (lines ~87, ~137):
-   - Truncate: `response.text[:500]`
-
-4. Do NOT change any business logic. Only logging call sites.
-
-Verify: `grep -rn '"event":' app/ --include="*.py" | grep -v __pycache__` should return 0 matches.
-Verify: `grep -rn 'def _log_' app/ --include="*.py"` should return 0 matches.
-
-Commit message: "refactor: migrate all remaining logging to structured_log, remove boilerplate helpers"
-```
-
----
-
-## Slice 5: Logging Relevance Audit — Reduce Noise, Improve Readability
-
-**Why:** Self-hosted users need clear, actionable logs. Current logging has verbose debug noise (per-HTTP-request, per-publication), overly long event names, and no console display optimization.
-
-**Files to modify:**
-- `app/services/scholar/source.py`
-- `app/services/ingestion/application.py`
-- `app/logging_config.py`
-- Any files with event names longer than ~40 chars
-
-**Prompt:**
-```
-You are working on the scholarr repository. The logging has been migrated to `structured_log()` (slices 2-4). Now audit log RELEVANCE and READABILITY for self-hosted users running this in Docker.
-
-1. **Remove redundant debug logs:**
-   - `app/services/scholar/source.py`: Remove the 3 debug-level HTTP fetch events (fetch_started, search_fetch_started, publication_fetch_started). Keep only `fetch_succeeded` at DEBUG. The HTTP middleware already logs request.started/completed.
-   - `app/services/ingestion/application.py`: Remove per-publication `publication.discovered` and `publication.created` DEBUG logs. The run_completed summary already reports totals.
-
-2. **Shorten overly long event names** (search all structured_log calls in app/):
-   - `ingestion.request_delay_coerced_to_policy_floor` → `ingestion.delay_coerced`
-   - `ingestion.safety_cooldown_cleared` → `ingestion.cooldown_cleared`
-   - Any other names longer than ~40 chars — shorten while preserving meaning
-
-3. **Improve console readability** in `app/logging_config.py` `ConsoleLogFormatter.format()`:
-   - Add a short-name mapping for common context fields in console output ONLY (JSON keeps full names):
-     ```python
-     _CONSOLE_SHORT_KEYS = {
-         "user_id": "user",
-         "scholar_id": "scholar",
-         "crawl_run_id": "run",
-         "run_id": "run",
-     }
-     ```
-   - Apply in the `for key in sorted(payload.keys())` loop
-
-4. Do NOT remove any WARNING or ERROR level logs. Only remove/demote DEBUG/INFO that are redundant.
-5. Do NOT change business logic.
-
-Commit message: "refactor: reduce log noise, improve event naming and console readability"
-```
-
----
-
-## Slice 6: Add Ruff + Mypy to CI
-
-**Why:** No Python linting or type checking in CI. Code quality regressions go undetected.
-
-**Files to modify:**
-- `pyproject.toml`
-- `.github/workflows/ci.yml`
-
-**Prompt:**
-```
-You are working on the scholarr repository. Add Python linting and type checking to CI.
-
-1. In `pyproject.toml`, add ruff configuration:
-   ```toml
-   [tool.ruff]
-   target-version = "py312"
-   line-length = 120
-
-   [tool.ruff.lint]
-   select = ["E", "F", "W", "I", "UP", "B", "SIM", "RUF"]
-   ignore = ["E501"]
-
-   [tool.ruff.lint.isort]
-   known-first-party = ["app"]
-   ```
-
-2. In `pyproject.toml`, add mypy configuration:
-   ```toml
-   [tool.mypy]
-   python_version = "3.12"
-   ignore_missing_imports = true
-   check_untyped_defs = false
-   warn_unused_ignores = true
-   ```
-
-3. In `.github/workflows/ci.yml`, add a `lint` job after `repo-hygiene` and before `test`:
-   ```yaml
-   lint:
-     runs-on: ubuntu-latest
-     needs: [repo-hygiene]
-     steps:
-       - uses: actions/checkout@v4
-       - uses: actions/setup-python@v5
-         with:
-           python-version: "3.12"
-       - uses: astral-sh/setup-uv@v4
-       - run: uv sync --extra dev
-       - name: Ruff check
-         run: uv run ruff check .
-       - name: Ruff format check
-         run: uv run ruff format --check .
-       - name: Mypy
-         run: uv run mypy app/ --ignore-missing-imports
-   ```
-
-4. Update the `test` job's `needs` to include `lint`.
-
-5. Add `ruff` and `mypy` to dev dependencies in `pyproject.toml` under `[project.optional-dependencies]`.
-
-6. Run `ruff check .` locally and fix auto-fixable issues with `ruff check --fix .`. For unfixable issues, add targeted `noqa` comments only if fixing would change behavior.
-
-Commit message: "ci: add ruff linting and mypy type checking"
-```
-
----
-
-## Slice 7: Add CodeQL + Dependabot
-
-**Why:** No security scanning. Missed vulnerabilities, no automated dependency updates.
-
-**Files to create:**
-- `.github/workflows/codeql.yml`
-- `.github/dependabot.yml`
-
-**Prompt:**
-```
-You are working on the scholarr repository. Add security scanning.
-
-1. Create `.github/workflows/codeql.yml`:
-   ```yaml
-   name: CodeQL
-
-   on:
-     push:
-       branches: [main]
-     pull_request:
-       branches: [main]
-     schedule:
-       - cron: "30 5 * * 1"
-
-   jobs:
-     analyze:
-       runs-on: ubuntu-latest
-       permissions:
-         security-events: write
-         contents: read
-       strategy:
-         matrix:
-           language: [python, javascript]
-       steps:
-         - uses: actions/checkout@v4
-         - uses: github/codeql-action/init@v3
-           with:
-             languages: ${{ matrix.language }}
-         - uses: github/codeql-action/autobuild@v3
-         - uses: github/codeql-action/analyze@v3
-   ```
-
-2. Create `.github/dependabot.yml`:
-   ```yaml
-   version: 2
-   updates:
-     - package-ecosystem: pip
-       directory: /
-       schedule:
-         interval: weekly
-     - package-ecosystem: npm
-       directory: /frontend
-       schedule:
-         interval: weekly
-     - package-ecosystem: github-actions
-       directory: /
-       schedule:
-         interval: weekly
-   ```
-
-Commit message: "ci: add CodeQL security scanning and Dependabot"
-```
-
----
-
-## Slice 8: Fix Version Remnants + Adopt Semantic Release
-
-**Why:** Version `0.1.0` is hardcoded in 5 places (including `crossref/application.py:294`). `0.0.1` exists in `docs/website/package.json`. No CHANGELOG, no GitHub Releases.
-
-**Files to modify:**
-- `pyproject.toml`
-- `app/services/crossref/application.py`
-
-**Files to create:**
-- `.github/workflows/release.yml`
-
-**Prompt:**
-```
-You are working on the scholarr repository. Set up automated versioning with python-semantic-release.
-
-1. Fix hardcoded version in `app/services/crossref/application.py` (line ~294):
-   ```python
-   # Before:
-   etiquette = Etiquette(settings.app_name, "0.1.0", "https://scholarr.local", email)
-
-   # After:
-   from importlib.metadata import version as pkg_version
-   _APP_VERSION = pkg_version("scholarr")
-   # then in function:
-   etiquette = Etiquette(settings.app_name, _APP_VERSION, "https://scholarr.local", email)
-   ```
-
-2. In `pyproject.toml`, add semantic-release config:
-   ```toml
-   [tool.semantic_release]
-   version_toml = ["pyproject.toml:project.version"]
-   version_variables = ["frontend/package.json:version"]
-   branch = "main"
-   build_command = ""
-   commit_message = "chore(release): v{version}"
-   ```
-
-3. Create `.github/workflows/release.yml`:
-   ```yaml
-   name: Release
-
-   on:
-     push:
-       branches: [main]
-
-   jobs:
-     release:
-       runs-on: ubuntu-latest
-       if: github.repository == 'JustinZeus/scholarr'
-       permissions:
-         contents: write
-         id-token: write
-       steps:
-         - uses: actions/checkout@v4
-           with:
-             fetch-depth: 0
-             token: ${{ secrets.GITHUB_TOKEN }}
-         - uses: actions/setup-python@v5
-           with:
-             python-version: "3.12"
-         - run: pip install python-semantic-release
-         - name: Semantic Release
-           id: release
-           run: semantic-release publish
-           env:
-             GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-   ```
-
-4. Add `python-semantic-release` to dev dependencies in `pyproject.toml`.
-
-Note: `docs/website/package.json` version (`0.0.1`) is addressed in Slice 9 (docs rebuild). `frontend/package-lock.json` and `uv.lock` versions auto-update on next `npm install`/`uv sync`.
-
-Commit message: "ci: adopt python-semantic-release, fix hardcoded version strings"
-```
-
----
-
-## Slice 9: Docs — Delete and Rebuild from Scratch
-
-**Why:** Current docs have split authority (two api-contract.md files), orphaned pages, stale version (`0.0.1`), and missing critical docs (testing, deployment, configuration reference). Clean slate is faster than migration.
-
-**Files to delete:**
-- `docs/` (entire directory)
-
-**Files to create:**
-- Complete new `docs/` tree
-
-**Prompt:**
-```
-You are working on the scholarr repository. Delete the entire `docs/` directory and rebuild from scratch.
-
-Target IA:
-
-docs/
-├── index.md                          # Landing page: what is scholarr, quick links
-├── user/
-│   ├── overview.md                   # What scholarr does, key concepts
-│   ├── getting-started.md            # Install (docker compose), first run, add first scholar
-│   └── configuration.md              # ALL env vars from .env.example, organized by category
-├── developer/
-│   ├── overview.md                   # Dev quickstart
-│   ├── architecture.md               # FastAPI + SQLAlchemy + Vue 3, domain service boundaries
-│   ├── local-development.md          # docker-compose.dev.yml, hot reload, running tests
-│   ├── contributing.md               # PR process, conventional commits, code standards from agents.md
-│   ├── ingestion.md                  # Ingestion pipeline: parsing, rate limiting, safety gates
-│   ├── frontend-theme-inventory.md   # Theme tokens, Tailwind integration
-│   └── testing.md                    # Test tiers (unit/integration/smoke), markers, fixtures, how to run
-├── operations/
-│   ├── overview.md                   # Ops quickstart
-│   ├── deployment.md                 # Production Docker, scaling, health checks
-│   ├── database-runbook.md           # Backup, restore, integrity checks, migration procedures
-│   ├── scrape-safety-runbook.md      # Rate limiting, cooldowns, CAPTCHA handling
-│   └── arxiv-runbook.md              # ArXiv rate limits, cache, query patterns
-├── reference/
-│   ├── overview.md                   # Reference index
-│   ├── api.md                        # CANONICAL: envelope spec + endpoints + DTO contract
-│   ├── environment.md                # Env var quick-reference (links to user/configuration.md)
-│   └── changelog.md                  # Placeholder: "auto-generated by semantic-release"
-└── website/
-    ├── docusaurus.config.js
-    ├── sidebars.js                   # ALL pages listed, no orphans
-    ├── package.json                  # version: "0.1.0"
-    └── src/css/custom.css
-
-Content guidelines:
-- Self-contained, scannable docs (headers, bullets, tables)
-- Frontmatter: `title`, `sidebar_position`
-- `configuration.md`: read `.env.example`, organize every variable with description, type, default, example
-- `testing.md`: pytest markers from pyproject.toml (`integration`, `db`, `migrations`, `schema`, `smoke`), container-based runner from agents.md, fixture org under tests/fixtures/
-- `api.md`: merge old `developer/api-contract.md` (DTO structure) and `reference/api-contract.md` (envelope spec). Include exact envelope shapes:
-  - Success: `{"data": ..., "meta": {"request_id": "..."}}`
-  - Error: `{"error": {"code": "...", "message": "...", "details": ...}, "meta": {"request_id": "..."}}`
-  - Publication semantics (modes, pagination, identifiers)
-  - Scholar portability endpoints
-- `deployment.md`: practical Docker commands from docker-compose.yml
-- `database-runbook.md`: reference scripts/db/ (backup_full.sh, restore_dump.sh, check_integrity.py, repair_publication_links.py)
-
-Docusaurus config:
-- url: "https://justinzeus.github.io"
-- baseUrl: "/scholarr/"
-- organizationName: "JustinZeus"
-- projectName: "scholarr"
-- onBrokenLinks: "throw"
-- docs path: ".." (reads from docs/ parent)
-- Exclude: "website/**", "README.md"
-
-Commit message: "docs: rebuild documentation from scratch with clean IA"
-```
-
----
-
-## Slice 10: Begin `ingestion/application.py` Decomposition
-
-**Why:** After logging cleanup (slices 3+5), the file is ~2,700-2,800 lines. Still the largest source file by 3x. This begins decomposition with the safest extract: safety gate logic.
-
-**Files to modify:**
-- `app/services/ingestion/application.py`
-
-**Files to create:**
-- `app/services/ingestion/safety.py`
-
-**Prompt:**
-```
-You are working on the scholarr repository. `app/services/ingestion/application.py` is ~2,700-2,800 lines (after logging cleanup). It contains the entire ingestion orchestration in a single class.
-
-Extract the FIRST logical chunk: safety gate logic.
-
-1. Read `app/services/ingestion/application.py` fully.
-
-2. Identify safety/cooldown methods:
-   - `_enforce_safety_gate`
-   - `_raise_safety_blocked_start`
-   - Cooldown activation/clearing methods
-   - Alert threshold evaluation methods
-
-3. Create `app/services/ingestion/safety.py`:
-   - Move identified methods to standalone functions or a small class
-   - Accept explicit parameters (no implicit self.xxx state)
-   - Keep same function signatures where possible
-
-4. Update `application.py` to import from `safety.py`.
-
-5. Run full test suite: `docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app pytest tests/`
-   All tests must pass unchanged.
-
-Constraints from `agents.md`:
-- Max 50 lines per function
-- No flat files in `app/services/` root — all within `app/services/ingestion/`
-- Fail fast, early returns, guard clauses
-
-Commit message: "refactor: extract ingestion safety gate logic to dedicated module"
-```
-
----
-
-## Verification (after all slices)
-
-Run these checks to confirm everything is clean:
-
-```bash
-# 1. No tracked build artifacts
-git ls-files build/ | wc -l  # expect: 0
-
-# 2. No duplicated event keys in logging
-grep -rn '"event":' app/ --include="*.py" | grep -v __pycache__ | wc -l  # expect: 0
-
-# 3. No _log_ helper functions remain
-grep -rn 'def _log_' app/ --include="*.py" | wc -l  # expect: 0
-
-# 4. No stale version strings
-grep -rn '0\.0\.1' . --include="*.py" --include="*.json" --include="*.toml" \
-  | grep -v node_modules | grep -v .venv | grep -v uv.lock | wc -l  # expect: 0
-
-# 5. Docs build
-npm --prefix docs/website run build  # expect: success, no broken links
-
-# 6. All tests pass
-docker compose -f docker-compose.yml -f docker-compose.dev.yml run --rm app pytest tests/
-```
-
----
-
-## Slice Summary
-
-| # | Slice | Files Changed | Estimated Impact |
-|---|-------|---------------|------------------|
-| ~~1~~ | ~~Repo hygiene~~ | ~~120 files~~ | ~~-18,380 lines~~ **DONE** |
-| 2 | `structured_log()` utility | 2 files | +50 lines |
-| 3 | Migrate ingestion logging | 1 file | -300 lines |
-| 4 | Migrate remaining logging | ~20 files | -180 lines |
-| 5 | Logging noise/readability | ~5 files | -30 lines, better output |
-| 6 | Ruff + mypy in CI | 2 files | +50 lines config |
-| 7 | CodeQL + Dependabot | 2 files | +40 lines config |
-| 8 | Version fix + semantic-release | 3 files | +40 lines config |
-| 9 | Docs rebuild | full replacement | ~20 new files |
-| 10 | Ingestion decomposition | 2 files | net zero (move) |
diff --git a/agents.md b/agents.md
index 9f81a20..1767078 100644
--- a/agents.md
+++ b/agents.md
@@ -77,7 +77,7 @@ Types: `feat`, `fix`, `docs`, `ci`, `refactor`, `test`, `chore`, `perf`.
 
 ## 7. Testing & Quality Gates
 
-All commands run inside containers. Do not run bare `npm`, `pytest`, or `ruff` on the host.
+All **local development** commands run inside containers. Do not run bare `npm`, `pytest`, or `ruff` on the host. CI workflows (`.github/workflows/`) use bare runners with `uv` and `npm` directly — this is intentional since CI has no Docker-in-Docker dependency.
 
 ### Backend
 
diff --git a/app/api/routers/run_manual.py b/app/api/routers/run_manual.py
index 6360e34..0632e39 100644
--- a/app/api/routers/run_manual.py
+++ b/app/api/routers/run_manual.py
@@ -138,9 +138,11 @@ async def recover_integrity_error(
     original_exc: IntegrityError,
 ) -> dict[str, Any]:
     if idempotency_key is None:
-        logger.exception(
+        structured_log(
+            logger,
+            "exception",
             "api.runs.manual_integrity_error",
-            extra={"user_id": user_id},
+            user_id=user_id,
         )
         raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
     existing_run = await run_service.get_manual_run_by_idempotency_key(
@@ -149,9 +151,11 @@ async def recover_integrity_error(
         idempotency_key=idempotency_key,
     )
     if existing_run is None:
-        logger.exception(
+        structured_log(
+            logger,
+            "exception",
             "api.runs.manual_integrity_error",
-            extra={"user_id": user_id},
+            user_id=user_id,
         )
         raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from original_exc
     if existing_run.status in (RunStatus.RUNNING, RunStatus.RESOLVING):
@@ -230,8 +234,10 @@ def raise_manual_blocked_safety(*, exc, user_id: int) -> None:
 
 
 def raise_manual_failed(*, exc: Exception, user_id: int) -> None:
-    logger.exception(
+    structured_log(
+        logger,
+        "exception",
         "api.runs.manual_failed",
-        extra={"user_id": user_id},
+        user_id=user_id,
     )
     raise ApiException(status_code=500, code="manual_run_failed", message="Manual run failed.") from exc
diff --git a/app/api/routers/runs.py b/app/api/routers/runs.py
index 28779ef..15d86f3 100644
--- a/app/api/routers/runs.py
+++ b/app/api/routers/runs.py
@@ -37,7 +37,8 @@ from app.api.schemas import (
     RunsListEnvelope,
 )
 from app.db.models import RunStatus, RunTriggerType, User
-from app.db.session import get_db_session
+from app.db.session import get_db_session, get_session_factory
+from app.logging_utils import structured_log
 from app.services.ingestion import application as ingestion_service
 from app.services.runs import application as run_service
 from app.services.runs.events import event_generator
@@ -47,6 +48,14 @@ from app.settings import settings
 logger = logging.getLogger(__name__)
 _background_tasks: set[asyncio.Task[Any]] = set()
 
+
+def _drop_finished_task(task: asyncio.Task[Any]) -> None:
+    _background_tasks.discard(task)
+    try:
+        task.result()
+    except Exception:
+        structured_log(logger, "exception", "runs.background_task_failed")
+
 router = APIRouter(prefix="/runs", tags=["api-runs"])
 ACTIVE_RUN_STATUSES = {RunStatus.RUNNING, RunStatus.RESOLVING}
 
@@ -234,7 +243,7 @@ def _spawn_background_execution(
         )
     )
     _background_tasks.add(task)
-    task.add_done_callback(_background_tasks.discard)
+    task.add_done_callback(_drop_finished_task)
 
 
 @router.post(
@@ -247,15 +256,16 @@ async def run_manual(
     current_user: User = Depends(get_api_current_user),
     ingest_service: ingestion_service.ScholarIngestionService = Depends(get_ingestion_service),
 ):
-    safety_state = await load_safety_state(db_session, user_id=current_user.id)
+    user_id = int(current_user.id)
+    safety_state = await load_safety_state(db_session, user_id=user_id)
     if not settings.ingestion_manual_run_allowed:
-        raise_manual_runs_disabled(user_id=current_user.id, safety_state=safety_state)
+        raise_manual_runs_disabled(user_id=user_id, safety_state=safety_state)
 
     idempotency_key = normalize_idempotency_key(request.headers.get(IDEMPOTENCY_HEADER))
     reused_payload = await reused_manual_run_payload(
         db_session,
         request=request,
-        user_id=current_user.id,
+        user_id=user_id,
         idempotency_key=idempotency_key,
         safety_state=safety_state,
     )
@@ -291,12 +301,12 @@ async def run_manual(
                 "new_publication_count": 0,
                 "reused_existing_run": False,
                 "idempotency_key": idempotency_key,
-                "safety_state": await load_safety_state(db_session, user_id=current_user.id),
+                "safety_state": await load_safety_state(db_session, user_id=user_id),
             },
         )
     except ingestion_service.RunBlockedBySafetyPolicyError as exc:
         await db_session.rollback()
-        raise_manual_blocked_safety(exc=exc, user_id=current_user.id)
+        raise_manual_blocked_safety(exc=exc, user_id=user_id)
     except ingestion_service.RunAlreadyInProgressError as exc:
         await db_session.rollback()
         raise ApiException(
@@ -309,13 +319,13 @@ async def run_manual(
         return await recover_integrity_error(
             db_session,
             request=request,
-            user_id=current_user.id,
+            user_id=user_id,
             idempotency_key=idempotency_key,
             original_exc=exc,
         )
     except Exception as exc:
         await db_session.rollback()
-        raise_manual_failed(exc=exc, user_id=current_user.id)
+        raise_manual_failed(exc=exc, user_id=user_id)
 
 
 @router.get(
@@ -454,14 +464,15 @@ async def clear_queue_item(
 @router.get("/{run_id}/stream")
 async def stream_run_events(
     run_id: int,
-    db_session: AsyncSession = Depends(get_db_session),
     current_user: User = Depends(get_api_current_user),
 ):
-    run = await run_service.get_run_for_user(
-        db_session,
-        user_id=current_user.id,
-        run_id=run_id,
-    )
+    session_factory = get_session_factory()
+    async with session_factory() as db_session:
+        run = await run_service.get_run_for_user(
+            db_session,
+            user_id=current_user.id,
+            run_id=run_id,
+        )
     if run is None:
         raise ApiException(
             status_code=404,
diff --git a/app/api/schemas/admin.py b/app/api/schemas/admin.py
index d9f2eb7..f5f73b5 100644
--- a/app/api/schemas/admin.py
+++ b/app/api/schemas/admin.py
@@ -34,8 +34,8 @@ class AdminUsersListEnvelope(BaseModel):
 
 
 class AdminUserCreateRequest(BaseModel):
-    email: str
-    password: str
+    email: str = Field(max_length=254)
+    password: str = Field(max_length=128)
     is_admin: bool = False
 
     model_config = ConfigDict(extra="forbid")
@@ -55,7 +55,7 @@ class AdminUserEnvelope(BaseModel):
 
 
 class AdminResetPasswordRequest(BaseModel):
-    new_password: str
+    new_password: str = Field(max_length=128)
 
     model_config = ConfigDict(extra="forbid")
 
diff --git a/app/api/schemas/auth.py b/app/api/schemas/auth.py
index 174d0b7..f160b24 100644
--- a/app/api/schemas/auth.py
+++ b/app/api/schemas/auth.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 from app.api.schemas.common import ApiMeta
 
@@ -44,8 +44,8 @@ class CsrfBootstrapEnvelope(BaseModel):
 
 
 class LoginRequest(BaseModel):
-    email: str
-    password: str
+    email: str = Field(max_length=254)
+    password: str = Field(max_length=128)
 
     model_config = ConfigDict(extra="forbid")
 
@@ -66,8 +66,8 @@ class LoginEnvelope(BaseModel):
 
 
 class ChangePasswordRequest(BaseModel):
-    current_password: str
-    new_password: str
-    confirm_password: str
+    current_password: str = Field(max_length=128)
+    new_password: str = Field(max_length=128)
+    confirm_password: str = Field(max_length=128)
 
     model_config = ConfigDict(extra="forbid")
diff --git a/app/db/session.py b/app/db/session.py
index 6d286ca..59a1745 100644
--- a/app/db/session.py
+++ b/app/db/session.py
@@ -85,7 +85,7 @@ async def check_database() -> bool:
             result = await conn.execute(text("SELECT 1"))
             return result.scalar_one() == 1
     except Exception:
-        logger.exception("db.healthcheck_failed")
+        structured_log(logger, "exception", "db.healthcheck_failed")
         return False
 
 
diff --git a/app/http/middleware.py b/app/http/middleware.py
index 00223e0..65607ed 100644
--- a/app/http/middleware.py
+++ b/app/http/middleware.py
@@ -74,13 +74,13 @@ class RequestLoggingMiddleware(BaseHTTPMiddleware):
             response = await call_next(request)
         except Exception:
             duration_ms = int((time.perf_counter() - start) * 1000)
-            logger.exception(
+            structured_log(
+                logger,
+                "exception",
                 "request.failed",
-                extra={
-                    "method": request.method,
-                    "path": request.url.path,
-                    "duration_ms": duration_ms,
-                },
+                method=request.method,
+                path=request.url.path,
+                duration_ms=duration_ms,
             )
             raise
         else:
diff --git a/app/main.py b/app/main.py
index cf03376..feda0c8 100644
--- a/app/main.py
+++ b/app/main.py
@@ -73,8 +73,13 @@ async def lifespan(_: FastAPI):
             )
             await session.commit()
             structured_log(logger, "info", "app.startup_orphaned_runs_cleaned")
-    except Exception as e:
-        logger.error(f"Failed to clean orphaned runs at startup: {e}")
+    except Exception as exc:
+        structured_log(
+            logger,
+            "error",
+            "app.startup_orphaned_runs_cleanup_failed",
+            error=str(exc),
+        )
 
     await scheduler_service.start()
     yield
diff --git a/app/security/csrf.py b/app/security/csrf.py
index 5c181c9..822be3b 100644
--- a/app/security/csrf.py
+++ b/app/security/csrf.py
@@ -6,9 +6,10 @@ from urllib.parse import parse_qs
 
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.requests import Request
-from starlette.responses import JSONResponse, PlainTextResponse, Response
+from starlette.responses import PlainTextResponse, Response
 from starlette.types import Message
 
+from app.api.responses import error_response
 from app.logging_utils import structured_log
 
 CSRF_SESSION_KEY = "csrf_token"
@@ -88,7 +89,10 @@ class CSRFMiddleware(BaseHTTPMiddleware):
         content_type = request.headers.get("content-type", "")
         if not content_type.startswith("application/x-www-form-urlencoded"):
             return None
-        parsed = parse_qs(body.decode("utf-8"), keep_blank_values=True)
+        try:
+            parsed = parse_qs(body.decode("utf-8"), keep_blank_values=True)
+        except (UnicodeDecodeError, ValueError):
+            return None
         values = parsed.get(CSRF_FORM_FIELD)
         if not values:
             return None
@@ -114,19 +118,11 @@ class CSRFMiddleware(BaseHTTPMiddleware):
         message: str,
     ) -> Response:
         if request.url.path.startswith("/api/"):
-            request_state = getattr(request, "state", None)
-            request_id = getattr(request_state, "request_id", None) if request_state else None
-            return JSONResponse(
-                {
-                    "error": {
-                        "code": code,
-                        "message": message,
-                        "details": None,
-                    },
-                    "meta": {
-                        "request_id": request_id,
-                    },
-                },
+            return error_response(
+                request,
                 status_code=403,
+                code=code,
+                message=message,
+                details=None,
             )
         return PlainTextResponse(message, status_code=403)
diff --git a/app/services/arxiv/rate_limit.py b/app/services/arxiv/rate_limit.py
index 70d6b69..1f3ab3f 100644
--- a/app/services/arxiv/rate_limit.py
+++ b/app/services/arxiv/rate_limit.py
@@ -75,24 +75,31 @@ async def _run_serialized_fetch(
             runtime_state,
             source_path=source_path,
         )
-        response = await fetch()
+        runtime_state.next_allowed_at = datetime.now(UTC) + timedelta(seconds=_min_interval_seconds())
+
+    if wait_seconds > 0:
+        await asyncio.sleep(wait_seconds)
+    response = await fetch()
+
+    async with session_factory() as db_session, db_session.begin():
+        runtime_state = await _load_runtime_state_for_update(db_session)
         hit_rate_limit = _record_post_response_state(
             runtime_state,
             response_status=int(response.status_code),
             source_path=source_path,
         )
-        structured_log(
-            logger,
-            "info",
-            "arxiv.request_completed",
-            status_code=int(response.status_code),
-            wait_seconds=wait_seconds,
-            cooldown_remaining_seconds=_cooldown_remaining_seconds(
-                runtime_state.cooldown_until, now_utc=datetime.now(UTC)
-            ),
-            source_path=source_path,
-        )
-        return response, hit_rate_limit
+    structured_log(
+        logger,
+        "info",
+        "arxiv.request_completed",
+        status_code=int(response.status_code),
+        wait_seconds=wait_seconds,
+        cooldown_remaining_seconds=_cooldown_remaining_seconds(
+            runtime_state.cooldown_until, now_utc=datetime.now(UTC)
+        ),
+        source_path=source_path,
+    )
+    return response, hit_rate_limit
 
 
 async def _acquire_arxiv_lock(db_session: AsyncSession) -> None:
@@ -144,8 +151,6 @@ async def _wait_for_allowed_slot_or_raise(
         source_path=source_path,
         cooldown_remaining_seconds=0.0,
     )
-    if wait_seconds > 0:
-        await asyncio.sleep(wait_seconds)
     return wait_seconds
 
 
diff --git a/app/services/crossref/application.py b/app/services/crossref/application.py
index a9e46d5..7a2908b 100644
--- a/app/services/crossref/application.py
+++ b/app/services/crossref/application.py
@@ -350,7 +350,8 @@ async def _fetch_items(
             ),
             timeout=timeout,
         )
-    except Exception:
+    except Exception as exc:
+        structured_log(logger, "warning", "crossref.fetch_failed", error=str(exc))
         return []
 
 
diff --git a/app/services/dbops/near_duplicate_repair.py b/app/services/dbops/near_duplicate_repair.py
index 76a295f..8d50570 100644
--- a/app/services/dbops/near_duplicate_repair.py
+++ b/app/services/dbops/near_duplicate_repair.py
@@ -6,12 +6,14 @@ from typing import Any
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import DataRepairJob
+from app.services.dbops.application import (
+    REPAIR_STATUS_COMPLETED,
+    REPAIR_STATUS_FAILED,
+    REPAIR_STATUS_PLANNED,
+    REPAIR_STATUS_RUNNING,
+)
 from app.services.publications import dedup as dedup_service
 
-REPAIR_STATUS_PLANNED = "planned"
-REPAIR_STATUS_RUNNING = "running"
-REPAIR_STATUS_COMPLETED = "completed"
-REPAIR_STATUS_FAILED = "failed"
 NEAR_DUP_JOB_NAME = "repair_publication_near_duplicates"
 NEAR_DUP_DEFAULT_MAX_CLUSTERS = 25
 
diff --git a/app/services/ingestion/application.py b/app/services/ingestion/application.py
index 6087925..cd5e6ea 100644
--- a/app/services/ingestion/application.py
+++ b/app/services/ingestion/application.py
@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import logging
 from datetime import UTC, datetime
 from typing import Any
@@ -17,21 +16,28 @@ from app.db.models import (
 )
 from app.logging_utils import structured_log
 from app.services.ingestion import queue as queue_service
-from app.services.ingestion import safety as run_safety_service
 from app.services.ingestion.constants import RUN_LOCK_NAMESPACE
 from app.services.ingestion.enrichment import EnrichmentRunner
 from app.services.ingestion.pagination import PaginationEngine
-from app.services.ingestion.preflight import check_scholar_reachable
 from app.services.ingestion.run_completion import (
     complete_run_for_user,
     int_or_default,
+    log_run_completed,
     run_execution_summary,
 )
+from app.services.ingestion.run_enrichment import (
+    inline_enrich_and_finalize,
+    spawn_background_enrichment_task,
+)
+from app.services.ingestion.run_guards import (
+    load_user_settings_for_run,
+    run_preflight_guard,
+)
 from app.services.ingestion.scholar_processing import run_scholar_iteration
 from app.services.ingestion.types import (
     RunAlertSummary,
     RunAlreadyInProgressError,
-    RunBlockedBySafetyPolicyError,
+    RunBlockedBySafetyPolicyError,  # noqa: F401 (re-exported)
     RunFailureSummary,
     RunProgress,
 )
@@ -42,8 +48,6 @@ from app.settings import settings
 logger = logging.getLogger(__name__)
 ACTIVE_RUN_INDEX_NAME = "uq_crawl_runs_user_active"
 
-_background_tasks: set[asyncio.Task[Any]] = set()
-
 
 def _is_active_run_integrity_error(exc: IntegrityError) -> bool:
     original_error = getattr(exc, "orig", None)
@@ -97,34 +101,6 @@ def _threshold_kwargs(
     }
 
 
-def _log_run_completed(
-    *,
-    run: CrawlRun,
-    user_id: int,
-    scholars: list[ScholarProfile],
-    progress: RunProgress,
-    failure_summary: RunFailureSummary,
-    alert_summary: RunAlertSummary,
-) -> None:
-    structured_log(
-        logger,
-        "info",
-        "ingestion.run_completed",
-        user_id=user_id,
-        crawl_run_id=run.id,
-        status=run.status.value,
-        scholar_count=len(scholars),
-        succeeded_count=progress.succeeded_count,
-        failed_count=progress.failed_count,
-        partial_count=progress.partial_count,
-        new_publication_count=run.new_pub_count,
-        blocked_failure_count=alert_summary.blocked_failure_count,
-        network_failure_count=alert_summary.network_failure_count,
-        retries_scheduled_count=failure_summary.retries_scheduled_count,
-        alert_flags=alert_summary.alert_flags,
-    )
-
-
 class ScholarIngestionService:
     def __init__(self, *, source: ScholarSource) -> None:
         self._source = source
@@ -138,78 +114,6 @@ class ScholarIngestionService:
         )
         return max(policy_minimum, int_or_default(value, policy_minimum))
 
-    async def _load_user_settings_for_run(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_id: int,
-        trigger_type: RunTriggerType,
-    ):
-        user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=user_id)
-        await self._enforce_safety_gate(
-            db_session, user_settings=user_settings, user_id=user_id, trigger_type=trigger_type
-        )
-        return user_settings
-
-    async def _enforce_safety_gate(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_settings,
-        user_id: int,
-        trigger_type: RunTriggerType,
-    ) -> None:
-        now_utc = datetime.now(UTC)
-        previous = run_safety_service.get_safety_event_context(user_settings, now_utc=now_utc)
-        if run_safety_service.clear_expired_cooldown(user_settings, now_utc=now_utc):
-            await db_session.commit()
-            await db_session.refresh(user_settings)
-            structured_log(
-                logger,
-                "info",
-                "ingestion.cooldown_cleared",
-                user_id=user_id,
-                reason=previous.get("cooldown_reason"),
-                cooldown_until=previous.get("cooldown_until"),
-            )
-            now_utc = datetime.now(UTC)
-        if run_safety_service.is_cooldown_active(user_settings, now_utc=now_utc):
-            await self._raise_safety_blocked_start(
-                db_session,
-                user_settings=user_settings,
-                user_id=user_id,
-                trigger_type=trigger_type,
-                now_utc=now_utc,
-            )
-
-    async def _raise_safety_blocked_start(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_settings,
-        user_id: int,
-        trigger_type: RunTriggerType,
-        now_utc: datetime,
-    ) -> None:
-        safety_state = run_safety_service.register_cooldown_blocked_start(user_settings, now_utc=now_utc)
-        await db_session.commit()
-        structured_log(
-            logger,
-            "warning",
-            "ingestion.safety_policy_blocked_run_start",
-            user_id=user_id,
-            trigger_type=trigger_type.value,
-            reason=safety_state.get("cooldown_reason"),
-            cooldown_until=safety_state.get("cooldown_until"),
-            cooldown_remaining_seconds=safety_state.get("cooldown_remaining_seconds"),
-            blocked_start_count=((safety_state.get("counters") or {}).get("blocked_start_count")),
-        )
-        raise RunBlockedBySafetyPolicyError(
-            code="scrape_cooldown_active",
-            message="Scrape safety cooldown is active; run start is temporarily blocked.",
-            safety_state=safety_state,
-        )
-
     async def _load_target_scholars(
         self,
         db_session: AsyncSession,
@@ -232,49 +136,6 @@ class ScholarIngestionService:
                 await queue_service.clear_job_for_scholar(db_session, user_id=user_id, scholar_profile_id=sid)
         return scholars
 
-    async def _run_preflight_guard(
-        self,
-        db_session: AsyncSession,
-        *,
-        user_settings: Any,
-        user_id: int,
-        scholars: list[ScholarProfile],
-    ) -> None:
-        if not scholars:
-            return
-        result = await check_scholar_reachable(
-            self._source,
-            scholar_id=scholars[0].scholar_id,
-        )
-        if result.passed:
-            return
-        now_utc = datetime.now(UTC)
-        safety_state, _ = run_safety_service.apply_run_safety_outcome(
-            user_settings,
-            run_id=0,
-            blocked_failure_count=1,
-            network_failure_count=0,
-            blocked_failure_threshold=1,
-            network_failure_threshold=1,
-            blocked_cooldown_seconds=settings.ingestion_safety_cooldown_blocked_seconds,
-            network_cooldown_seconds=settings.ingestion_safety_cooldown_network_seconds,
-            now_utc=now_utc,
-        )
-        await db_session.commit()
-        structured_log(
-            logger,
-            "warning",
-            "ingestion.cooldown_entered_preflight",
-            user_id=user_id,
-            block_reason=result.block_reason,
-            cooldown_until=safety_state.get("cooldown_until"),
-        )
-        raise RunBlockedBySafetyPolicyError(
-            code="scrape_cooldown_active",
-            message=f"Preflight detected Scholar block ({result.block_reason}). Cooldown activated.",
-            safety_state=safety_state,
-        )
-
     async def _initialize_run_for_user(
         self,
         db_session: AsyncSession,
@@ -287,7 +148,7 @@ class ScholarIngestionService:
         threshold_kwargs: dict[str, Any],
         idempotency_key: str | None,
     ) -> tuple[Any, CrawlRun, list[ScholarProfile], dict[int, int]]:
-        user_settings = await self._load_user_settings_for_run(
+        user_settings = await load_user_settings_for_run(
             db_session,
             user_id=user_id,
             trigger_type=trigger_type,
@@ -301,8 +162,9 @@ class ScholarIngestionService:
             user_id=user_id,
             filtered_scholar_ids=filtered_scholar_ids,
         )
-        await self._run_preflight_guard(
+        await run_preflight_guard(
             db_session,
+            self._source,
             user_settings=user_settings,
             user_id=user_id,
             scholars=scholars,
@@ -486,7 +348,7 @@ class ScholarIngestionService:
                 if intended_final_status not in (RunStatus.CANCELED,):
                     run.status = RunStatus.RESOLVING
                 await db_session.commit()
-                _log_run_completed(
+                log_run_completed(
                     run=run,
                     user_id=user_id,
                     scholars=attached_scholars,
@@ -495,19 +357,22 @@ class ScholarIngestionService:
                     alert_summary=alert_summary,
                 )
                 if intended_final_status not in (RunStatus.CANCELED,):
-                    task = asyncio.create_task(
-                        self._background_enrich(
-                            session_factory,
-                            run_id=run.id,
-                            intended_final_status=intended_final_status,
-                            openalex_api_key=getattr(user_settings, "openalex_api_key", None),
-                        )
+                    spawn_background_enrichment_task(
+                        session_factory,
+                        self._enrichment,
+                        run_id=run.id,
+                        intended_final_status=intended_final_status,
+                        openalex_api_key=getattr(user_settings, "openalex_api_key", None),
                     )
-                    _background_tasks.add(task)
-                    task.add_done_callback(_background_tasks.discard)
             except Exception as exc:
                 await db_session.rollback()
-                logger.exception("ingestion.background_run_failed", extra={"run_id": run_id, "user_id": user_id})
+                structured_log(
+                    logger,
+                    "exception",
+                    "ingestion.background_run_failed",
+                    run_id=run_id,
+                    user_id=user_id,
+                )
                 await self._fail_run_in_background(session_factory, run_id, exc)
 
     async def _prepare_execute_run(
@@ -530,47 +395,21 @@ class ScholarIngestionService:
         return run, user_settings, list(scholars_result.scalars().all())
 
     async def _fail_run_in_background(self, session_factory: Any, run_id: int, exc: Exception) -> None:
-        async with session_factory() as cleanup_session:
-            run_to_fail = await cleanup_session.get(CrawlRun, run_id)
-            if run_to_fail:
-                run_to_fail.status = RunStatus.FAILED
-                run_to_fail.end_dt = datetime.now(UTC)
-                run_to_fail.error_log["terminal_exception"] = str(exc)
-                await cleanup_session.commit()
-
-    async def _background_enrich(
-        self,
-        session_factory: Any,
-        *,
-        run_id: int,
-        intended_final_status: RunStatus,
-        openalex_api_key: str | None = None,
-    ) -> None:
         try:
-            async with session_factory() as session:
-                await self._enrichment.enrich_pending_publications(
-                    session,
-                    run_id=run_id,
-                    openalex_api_key=openalex_api_key,
-                )
-                run = await session.get(CrawlRun, run_id)
-                if run is not None and run.status == RunStatus.RESOLVING:
-                    run.status = intended_final_status
-                await session.commit()
-                logger.info(
-                    "ingestion.background_enrichment_complete",
-                    extra={"run_id": run_id, "final_status": str(intended_final_status)},
-                )
+            async with session_factory() as cleanup_session:
+                run_to_fail = await cleanup_session.get(CrawlRun, run_id)
+                if run_to_fail:
+                    run_to_fail.status = RunStatus.FAILED
+                    run_to_fail.end_dt = datetime.now(UTC)
+                    run_to_fail.error_log["terminal_exception"] = str(exc)
+                    await cleanup_session.commit()
         except Exception:
-            logger.exception("ingestion.background_enrichment_failed", extra={"run_id": run_id})
-            try:
-                async with session_factory() as fallback_session:
-                    run = await fallback_session.get(CrawlRun, run_id)
-                    if run is not None and run.status == RunStatus.RESOLVING:
-                        run.status = intended_final_status
-                    await fallback_session.commit()
-            except Exception:
-                logger.exception("ingestion.background_enrichment_fallback_failed", extra={"run_id": run_id})
+            structured_log(
+                logger,
+                "exception",
+                "ingestion.fail_run_cleanup_failed",
+                run_id=run_id,
+            )
 
     async def run_for_user(
         self,
@@ -626,7 +465,7 @@ class ScholarIngestionService:
             alert_network_failure_threshold=alert_network_failure_threshold,
             alert_retry_scheduled_threshold=alert_retry_scheduled_threshold,
         )
-        progress, failure_summary, alert_summary = await self._run_iteration_and_complete(
+        progress, failure_summary, alert_summary, intended_final_status = await self._run_iteration_and_complete(
             db_session,
             run=run,
             scholars=scholars,
@@ -639,10 +478,14 @@ class ScholarIngestionService:
             idempotency_key=idempotency_key,
         )
         user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=user_id)
-        await self._inline_enrich_and_finalize(
-            db_session, run=run, user_settings=user_settings, intended_final_status=run.status
+        await inline_enrich_and_finalize(
+            db_session,
+            self._enrichment,
+            run=run,
+            user_settings=user_settings,
+            intended_final_status=intended_final_status,
         )
-        _log_run_completed(
+        log_run_completed(
             run=run,
             user_id=user_id,
             scholars=scholars,
@@ -665,7 +508,7 @@ class ScholarIngestionService:
         auto_queue_continuations: bool,
         queue_delay_seconds: int,
         idempotency_key: str | None,
-    ) -> tuple[RunProgress, RunFailureSummary, RunAlertSummary]:
+    ) -> tuple[RunProgress, RunFailureSummary, RunAlertSummary, RunStatus]:
         progress = await run_scholar_iteration(
             db_session,
             pagination=self._pagination,
@@ -691,27 +534,7 @@ class ScholarIngestionService:
         if intended_final_status not in (RunStatus.CANCELED,):
             run.status = RunStatus.RESOLVING
         await db_session.commit()
-        return progress, failure_summary, alert_summary
-
-    async def _inline_enrich_and_finalize(
-        self,
-        db_session: AsyncSession,
-        *,
-        run: CrawlRun,
-        user_settings: Any,
-        intended_final_status: RunStatus,
-    ) -> None:
-        try:
-            await self._enrichment.enrich_pending_publications(
-                db_session,
-                run_id=run.id,
-                openalex_api_key=getattr(user_settings, "openalex_api_key", None),
-            )
-        except Exception:
-            logger.exception("ingestion.enrichment_failed", extra={"run_id": run.id})
-        if run.status == RunStatus.RESOLVING:
-            run.status = intended_final_status
-        await db_session.commit()
+        return progress, failure_summary, alert_summary, intended_final_status
 
     async def _try_acquire_user_lock(
         self,
diff --git a/app/services/ingestion/enrichment.py b/app/services/ingestion/enrichment.py
index 9232efb..1b66f58 100644
--- a/app/services/ingestion/enrichment.py
+++ b/app/services/ingestion/enrichment.py
@@ -96,7 +96,7 @@ class EnrichmentRunner:
 
         for p in batch:
             if await self.run_is_canceled(db_session, run_id=run_id):
-                logger.info("ingestion.enrichment_aborted", extra={"run_id": run_id})
+                structured_log(logger, "info", "ingestion.enrichment_aborted", run_id=run_id)
                 return False, arxiv_lookup_allowed
             p.openalex_last_attempt_at = now
             arxiv_lookup_allowed = await self._discover_identifiers_for_enrichment(
@@ -112,9 +112,9 @@ class EnrichmentRunner:
                 candidates=openalex_works,
             )
             if match:
-                p.year = match.publication_year or p.year
-                p.citation_count = match.cited_by_count or p.citation_count
-                p.pdf_url = match.oa_url or p.pdf_url
+                p.year = match.publication_year if match.publication_year is not None else p.year
+                p.citation_count = match.cited_by_count if match.cited_by_count is not None else p.citation_count
+                p.pdf_url = match.oa_url if match.oa_url is not None else p.pdf_url
                 p.openalex_enriched = True
         return True, arxiv_lookup_allowed
 
@@ -162,7 +162,7 @@ class EnrichmentRunner:
 
         for i in range(0, len(publications), batch_size):
             if await self.run_is_canceled(db_session, run_id=run_id):
-                logger.info("ingestion.enrichment_aborted", extra={"run_id": run_id})
+                structured_log(logger, "info", "ingestion.enrichment_aborted", run_id=run_id)
                 return
             batch = publications[i : i + batch_size]
             titles = _sanitize_titles(batch)
@@ -181,6 +181,8 @@ class EnrichmentRunner:
                 continue
             except Exception as e:
                 structured_log(logger, "warning", "ingestion.openalex_enrichment_failed", error=str(e), run_id=run_id)
+                for p in batch:
+                    p.openalex_last_attempt_at = now
                 continue
             should_continue, arxiv_lookup_allowed = await self._enrich_batch(
                 db_session,
@@ -302,9 +304,13 @@ class EnrichmentRunner:
                     {"title.search": "|".join(titles)}, limit=batch_size * 3
                 )
             except Exception as e:
-                logger.warning(
+                structured_log(
+                    logger,
+                    "warning",
                     "ingestion.openalex_enrichment_failed",
-                    extra={"error": str(e), "batch_size": len(batch), "scholar_id": scholar.id},
+                    error=str(e),
+                    batch_size=len(batch),
+                    scholar_id=scholar.id,
                 )
                 openalex_works = []
 
@@ -320,11 +326,11 @@ class EnrichmentRunner:
                         title=p.title,
                         title_url=p.title_url,
                         cluster_id=p.cluster_id,
-                        year=match.publication_year or p.year,
-                        citation_count=match.cited_by_count,
+                        year=match.publication_year if match.publication_year is not None else p.year,
+                        citation_count=match.cited_by_count if match.cited_by_count is not None else p.citation_count,
                         authors_text=p.authors_text,
                         venue_text=p.venue_text,
-                        pdf_url=match.oa_url or p.pdf_url,
+                        pdf_url=match.oa_url if match.oa_url is not None else p.pdf_url,
                     )
                     enriched.append(new_p)
                 else:
diff --git a/app/services/ingestion/page_fetch.py b/app/services/ingestion/page_fetch.py
index 19aff3f..3a57206 100644
--- a/app/services/ingestion/page_fetch.py
+++ b/app/services/ingestion/page_fetch.py
@@ -49,13 +49,13 @@ class PageFetcher:
                 error="source_does_not_support_pagination",
             )
         except Exception as exc:
-            logger.exception(
+            structured_log(
+                logger,
+                "exception",
                 "ingestion.fetch_unexpected_error",
-                extra={
-                    "scholar_id": scholar_id,
-                    "cstart": cstart,
-                    "page_size": page_size,
-                },
+                scholar_id=scholar_id,
+                cstart=cstart,
+                page_size=page_size,
             )
             return FetchResult(
                 requested_url=(
diff --git a/app/services/ingestion/pagination.py b/app/services/ingestion/pagination.py
index 5858a7d..91bc984 100644
--- a/app/services/ingestion/pagination.py
+++ b/app/services/ingestion/pagination.py
@@ -353,6 +353,9 @@ class PaginationEngine:
                 page_attempt_log=next_attempt_log,
             )
 
+            if self._handle_page_state_transition(state=state):
+                return
+
             if next_parsed_page.publications:
                 await self._upsert_page_publications(
                     db_session,
@@ -364,9 +367,6 @@ class PaginationEngine:
                     upsert_publications_fn=upsert_publications_fn,
                 )
 
-            if self._handle_page_state_transition(state=state):
-                return
-
     @staticmethod
     def _result_from_pagination_state(
         *,
diff --git a/app/services/ingestion/publication_upsert.py b/app/services/ingestion/publication_upsert.py
index 9d1a6b7..d2ba42b 100644
--- a/app/services/ingestion/publication_upsert.py
+++ b/app/services/ingestion/publication_upsert.py
@@ -8,7 +8,6 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import CrawlRun, Publication, ScholarProfile, ScholarPublication
-from app.services.doi.normalize import first_doi_from_texts
 from app.services.ingestion.fingerprints import (
     build_publication_fingerprint,
     build_publication_url,
@@ -106,8 +105,9 @@ def update_existing_publication(
 ) -> None:
     if candidate.cluster_id and publication.cluster_id is None:
         publication.cluster_id = candidate.cluster_id
-    publication.title_raw = candidate.title
-    publication.title_normalized = normalize_title(candidate.title)
+    if not publication.title_raw:
+        publication.title_raw = candidate.title
+        publication.title_normalized = normalize_title(candidate.title)
     if candidate.year is not None:
         publication.year = candidate.year
     if candidate.citation_count is not None:
@@ -118,7 +118,6 @@ def update_existing_publication(
         publication.venue_text = candidate.venue_text
     if candidate.title_url:
         publication.pub_url = build_publication_url(candidate.title_url)
-    first_doi_from_texts(candidate.title_url, candidate.venue_text, candidate.title)
 
 
 async def resolve_publication(
diff --git a/app/services/ingestion/queue_runner.py b/app/services/ingestion/queue_runner.py
index 45d9dd7..2220f58 100644
--- a/app/services/ingestion/queue_runner.py
+++ b/app/services/ingestion/queue_runner.py
@@ -229,7 +229,13 @@ class QueueJobRunner:
                 error=str(exc),
             )
             await recovery_session.commit()
-        logger.exception("scheduler.queue_item_run_failed", extra={"queue_item_id": job.id, "user_id": job.user_id})
+        structured_log(
+            logger,
+            "exception",
+            "scheduler.queue_item_run_failed",
+            queue_item_id=job.id,
+            user_id=job.user_id,
+        )
 
     async def _load_request_delay_for_user(self, user_id: int, *, floor: int) -> int:
         session_factory = get_session_factory()
diff --git a/app/services/ingestion/run_completion.py b/app/services/ingestion/run_completion.py
index 8f53f6a..d22b8fc 100644
--- a/app/services/ingestion/run_completion.py
+++ b/app/services/ingestion/run_completion.py
@@ -427,3 +427,31 @@ def run_execution_summary(
         partial_count=progress.partial_count,
         new_publication_count=run.new_pub_count,
     )
+
+
+def log_run_completed(
+    *,
+    run: CrawlRun,
+    user_id: int,
+    scholars: list[ScholarProfile],
+    progress: RunProgress,
+    failure_summary: RunFailureSummary,
+    alert_summary: RunAlertSummary,
+) -> None:
+    structured_log(
+        logger,
+        "info",
+        "ingestion.run_completed",
+        user_id=user_id,
+        crawl_run_id=run.id,
+        status=run.status.value,
+        scholar_count=len(scholars),
+        succeeded_count=progress.succeeded_count,
+        failed_count=progress.failed_count,
+        partial_count=progress.partial_count,
+        new_publication_count=run.new_pub_count,
+        blocked_failure_count=alert_summary.blocked_failure_count,
+        network_failure_count=alert_summary.network_failure_count,
+        retries_scheduled_count=failure_summary.retries_scheduled_count,
+        alert_flags=alert_summary.alert_flags,
+    )
diff --git a/app/services/ingestion/run_enrichment.py b/app/services/ingestion/run_enrichment.py
new file mode 100644
index 0000000..94ed0f4
--- /dev/null
+++ b/app/services/ingestion/run_enrichment.py
@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import CrawlRun, RunStatus
+from app.logging_utils import structured_log
+from app.services.ingestion.enrichment import EnrichmentRunner
+
+logger = logging.getLogger(__name__)
+
+_background_tasks: set[asyncio.Task[Any]] = set()
+
+
+async def background_enrich(
+    session_factory: Any,
+    enrichment_runner: EnrichmentRunner,
+    *,
+    run_id: int,
+    intended_final_status: RunStatus,
+    openalex_api_key: str | None = None,
+) -> None:
+    try:
+        async with session_factory() as session:
+            await enrichment_runner.enrich_pending_publications(
+                session,
+                run_id=run_id,
+                openalex_api_key=openalex_api_key,
+            )
+            run = await session.get(CrawlRun, run_id)
+            if run is not None and run.status == RunStatus.RESOLVING:
+                run.status = intended_final_status
+            await session.commit()
+            structured_log(
+                logger,
+                "info",
+                "ingestion.background_enrichment_complete",
+                run_id=run_id,
+                final_status=str(intended_final_status),
+            )
+    except Exception:
+        structured_log(
+            logger,
+            "exception",
+            "ingestion.background_enrichment_failed",
+            run_id=run_id,
+        )
+        try:
+            async with session_factory() as fallback_session:
+                run = await fallback_session.get(CrawlRun, run_id)
+                if run is not None and run.status == RunStatus.RESOLVING:
+                    run.status = intended_final_status
+                await fallback_session.commit()
+        except Exception:
+            structured_log(
+                logger,
+                "exception",
+                "ingestion.background_enrichment_fallback_failed",
+                run_id=run_id,
+            )
+
+
+async def inline_enrich_and_finalize(
+    db_session: AsyncSession,
+    enrichment_runner: EnrichmentRunner,
+    *,
+    run: CrawlRun,
+    user_settings: Any,
+    intended_final_status: RunStatus,
+) -> None:
+    try:
+        await enrichment_runner.enrich_pending_publications(
+            db_session,
+            run_id=run.id,
+            openalex_api_key=getattr(user_settings, "openalex_api_key", None),
+        )
+    except Exception:
+        structured_log(
+            logger,
+            "exception",
+            "ingestion.enrichment_failed",
+            run_id=run.id,
+        )
+    if run.status == RunStatus.RESOLVING:
+        run.status = intended_final_status
+    await db_session.commit()
+
+
+def spawn_background_enrichment_task(
+    session_factory: Any,
+    enrichment_runner: EnrichmentRunner,
+    *,
+    run_id: int,
+    intended_final_status: RunStatus,
+    openalex_api_key: str | None,
+) -> None:
+    task = asyncio.create_task(
+        background_enrich(
+            session_factory,
+            enrichment_runner,
+            run_id=run_id,
+            intended_final_status=intended_final_status,
+            openalex_api_key=openalex_api_key,
+        )
+    )
+    _background_tasks.add(task)
+    task.add_done_callback(_background_tasks.discard)
diff --git a/app/services/ingestion/run_guards.py b/app/services/ingestion/run_guards.py
new file mode 100644
index 0000000..fafc405
--- /dev/null
+++ b/app/services/ingestion/run_guards.py
@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import logging
+from datetime import UTC, datetime
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import (
+    RunTriggerType,
+    ScholarProfile,
+)
+from app.logging_utils import structured_log
+from app.services.ingestion import safety as run_safety_service
+from app.services.ingestion.preflight import check_scholar_reachable
+from app.services.ingestion.types import RunBlockedBySafetyPolicyError
+from app.services.scholar.source import ScholarSource
+from app.services.settings import application as user_settings_service
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+async def load_user_settings_for_run(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    trigger_type: RunTriggerType,
+):
+    user_settings = await user_settings_service.get_or_create_settings(db_session, user_id=user_id)
+    await enforce_safety_gate(db_session, user_settings=user_settings, user_id=user_id, trigger_type=trigger_type)
+    return user_settings
+
+
+async def enforce_safety_gate(
+    db_session: AsyncSession,
+    *,
+    user_settings,
+    user_id: int,
+    trigger_type: RunTriggerType,
+) -> None:
+    now_utc = datetime.now(UTC)
+    previous = run_safety_service.get_safety_event_context(user_settings, now_utc=now_utc)
+    if run_safety_service.clear_expired_cooldown(user_settings, now_utc=now_utc):
+        await db_session.commit()
+        await db_session.refresh(user_settings)
+        structured_log(
+            logger,
+            "info",
+            "ingestion.cooldown_cleared",
+            user_id=user_id,
+            reason=previous.get("cooldown_reason"),
+            cooldown_until=previous.get("cooldown_until"),
+        )
+        now_utc = datetime.now(UTC)
+    if run_safety_service.is_cooldown_active(user_settings, now_utc=now_utc):
+        await raise_safety_blocked_start(
+            db_session,
+            user_settings=user_settings,
+            user_id=user_id,
+            trigger_type=trigger_type,
+            now_utc=now_utc,
+        )
+
+
+async def raise_safety_blocked_start(
+    db_session: AsyncSession,
+    *,
+    user_settings,
+    user_id: int,
+    trigger_type: RunTriggerType,
+    now_utc: datetime,
+) -> None:
+    safety_state = run_safety_service.register_cooldown_blocked_start(user_settings, now_utc=now_utc)
+    await db_session.commit()
+    structured_log(
+        logger,
+        "warning",
+        "ingestion.safety_policy_blocked_run_start",
+        user_id=user_id,
+        trigger_type=trigger_type.value,
+        reason=safety_state.get("cooldown_reason"),
+        cooldown_until=safety_state.get("cooldown_until"),
+        cooldown_remaining_seconds=safety_state.get("cooldown_remaining_seconds"),
+        blocked_start_count=((safety_state.get("counters") or {}).get("blocked_start_count")),
+    )
+    raise RunBlockedBySafetyPolicyError(
+        code="scrape_cooldown_active",
+        message="Scrape safety cooldown is active; run start is temporarily blocked.",
+        safety_state=safety_state,
+    )
+
+
+async def run_preflight_guard(
+    db_session: AsyncSession,
+    source: ScholarSource,
+    *,
+    user_settings: Any,
+    user_id: int,
+    scholars: list[ScholarProfile],
+) -> None:
+    if not scholars:
+        return
+    result = await check_scholar_reachable(
+        source,
+        scholar_id=scholars[0].scholar_id,
+    )
+    if result.passed:
+        return
+    now_utc = datetime.now(UTC)
+    safety_state, _ = run_safety_service.apply_run_safety_outcome(
+        user_settings,
+        run_id=0,
+        blocked_failure_count=1,
+        network_failure_count=0,
+        blocked_failure_threshold=1,
+        network_failure_threshold=1,
+        blocked_cooldown_seconds=settings.ingestion_safety_cooldown_blocked_seconds,
+        network_cooldown_seconds=settings.ingestion_safety_cooldown_network_seconds,
+        now_utc=now_utc,
+    )
+    await db_session.commit()
+    structured_log(
+        logger,
+        "warning",
+        "ingestion.cooldown_entered_preflight",
+        user_id=user_id,
+        block_reason=result.block_reason,
+        cooldown_until=safety_state.get("cooldown_until"),
+    )
+    raise RunBlockedBySafetyPolicyError(
+        code="scrape_cooldown_active",
+        message=f"Preflight detected Scholar block ({result.block_reason}). Cooldown activated.",
+        safety_state=safety_state,
+    )
diff --git a/app/services/ingestion/scheduler.py b/app/services/ingestion/scheduler.py
index dbb0632..bf4e9e7 100644
--- a/app/services/ingestion/scheduler.py
+++ b/app/services/ingestion/scheduler.py
@@ -125,9 +125,10 @@ class SchedulerService:
             except asyncio.CancelledError:
                 raise
             except Exception:
-                logger.exception(
+                structured_log(
+                    logger,
+                    "exception",
                     "scheduler.tick_failed",
-                    extra={},
                 )
             await asyncio.sleep(float(self._tick_seconds))
 
@@ -263,7 +264,12 @@ class SchedulerService:
                 return None
             except Exception:
                 await session.rollback()
-                logger.exception("scheduler.run_failed", extra={"user_id": candidate.user_id})
+                structured_log(
+                    logger,
+                    "exception",
+                    "scheduler.run_failed",
+                    user_id=candidate.user_id,
+                )
                 return None
 
     async def _run_candidate(self, candidate: _AutoRunCandidate) -> None:
@@ -300,4 +306,8 @@ class SchedulerService:
                         processed_count=processed,
                     )
             except Exception:
-                logger.exception("scheduler.pdf_queue_drain_failed", extra={})
+                structured_log(
+                    logger,
+                    "exception",
+                    "scheduler.pdf_queue_drain_failed",
+                )
diff --git a/app/services/ingestion/scholar_outcomes.py b/app/services/ingestion/scholar_outcomes.py
new file mode 100644
index 0000000..0871273
--- /dev/null
+++ b/app/services/ingestion/scholar_outcomes.py
@@ -0,0 +1,308 @@
+from __future__ import annotations
+
+import logging
+from datetime import UTC, datetime
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import (
+    CrawlRun,
+    RunStatus,
+    ScholarProfile,
+)
+from app.logging_utils import structured_log
+from app.services.ingestion.run_completion import build_failure_debug_context
+from app.services.ingestion.types import (
+    PagedParseResult,
+    ScholarProcessingOutcome,
+)
+from app.services.scholar.parser import ParseState
+
+logger = logging.getLogger(__name__)
+
+
+def assert_valid_paged_parse_result(
+    *,
+    scholar_id: str,
+    paged_parse_result: PagedParseResult,
+) -> None:
+    parsed_page = paged_parse_result.parsed_page
+    if parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS} and any(
+        code.startswith("layout_") for code in parsed_page.warnings
+    ):
+        raise RuntimeError(f"Layout warning marked as terminal for scholar_id={scholar_id}.")
+    for publication in paged_parse_result.publications:
+        if not publication.title.strip():
+            raise RuntimeError(f"Malformed publication title for scholar_id={scholar_id}.")
+        if publication.citation_count is not None and int(publication.citation_count) < 0:
+            raise RuntimeError(f"Negative citation count for scholar_id={scholar_id}.")
+
+
+def apply_first_page_profile_metadata(
+    *,
+    scholar: ScholarProfile,
+    paged_parse_result: PagedParseResult,
+    run_dt: datetime,
+) -> None:
+    first_page = paged_parse_result.first_page_parsed_page
+    if first_page.profile_name and not (scholar.display_name or "").strip():
+        scholar.display_name = first_page.profile_name
+    if first_page.profile_image_url:
+        scholar.profile_image_url = first_page.profile_image_url
+    scholar.last_initial_page_checked_at = run_dt
+
+
+def build_result_entry(
+    *,
+    scholar: ScholarProfile,
+    start_cstart: int,
+    paged_parse_result: PagedParseResult,
+) -> dict[str, Any]:
+    parsed_page = paged_parse_result.parsed_page
+    return {
+        "scholar_profile_id": scholar.id,
+        "scholar_id": scholar.scholar_id,
+        "state": parsed_page.state.value,
+        "state_reason": parsed_page.state_reason,
+        "outcome": "failed",
+        "attempt_count": len(paged_parse_result.attempt_log),
+        "publication_count": len(paged_parse_result.publications),
+        "start_cstart": start_cstart,
+        "articles_range": parsed_page.articles_range,
+        "warnings": parsed_page.warnings,
+        "has_show_more_button": parsed_page.has_show_more_button,
+        "pages_fetched": paged_parse_result.pages_fetched,
+        "pages_attempted": paged_parse_result.pages_attempted,
+        "has_more_remaining": paged_parse_result.has_more_remaining,
+        "pagination_truncated_reason": paged_parse_result.pagination_truncated_reason,
+        "continuation_cstart": paged_parse_result.continuation_cstart,
+        "skipped_no_change": paged_parse_result.skipped_no_change,
+        "initial_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
+    }
+
+
+def skipped_no_change_outcome(
+    *,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+) -> ScholarProcessingOutcome:
+    first_page = paged_parse_result.first_page_parsed_page
+    scholar.last_run_status = RunStatus.SUCCESS
+    scholar.last_run_dt = run_dt
+    result_entry["state"] = first_page.state.value
+    result_entry["state_reason"] = "no_change_initial_page_signature"
+    result_entry["outcome"] = "success"
+    result_entry["publication_count"] = 0
+    result_entry["warnings"] = first_page.warnings
+    result_entry["debug"] = {
+        "state_reason": "no_change_initial_page_signature",
+        "first_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
+        "attempt_log": paged_parse_result.attempt_log,
+        "page_logs": paged_parse_result.page_logs,
+    }
+    return ScholarProcessingOutcome(
+        result_entry=result_entry,
+        succeeded_count_delta=1,
+        failed_count_delta=0,
+        partial_count_delta=0,
+        discovered_publication_count=0,
+    )
+
+
+async def upsert_publications_outcome(
+    db_session: AsyncSession,
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+) -> ScholarProcessingOutcome:
+    parsed_page = paged_parse_result.parsed_page
+    publications = paged_parse_result.publications
+    had_page_failure = parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}
+    has_partial_set = len(publications) > 0 and had_page_failure
+    if (not had_page_failure) or has_partial_set:
+        return await _upsert_success_or_exception(
+            db_session,
+            run=run,
+            scholar=scholar,
+            run_dt=run_dt,
+            paged_parse_result=paged_parse_result,
+            result_entry=result_entry,
+            has_partial_publication_set=has_partial_set,
+        )
+    return _parse_failure_outcome(
+        scholar=scholar,
+        run_dt=run_dt,
+        paged_parse_result=paged_parse_result,
+        result_entry=result_entry,
+    )
+
+
+async def _upsert_success_or_exception(
+    db_session: AsyncSession,
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+    has_partial_publication_set: bool,
+) -> ScholarProcessingOutcome:
+    try:
+        return _upsert_success(
+            run=run,
+            scholar=scholar,
+            run_dt=run_dt,
+            paged_parse_result=paged_parse_result,
+            result_entry=result_entry,
+            has_partial_publication_set=has_partial_publication_set,
+        )
+    except Exception as exc:
+        return _upsert_exception_outcome(
+            run=run,
+            scholar=scholar,
+            run_dt=run_dt,
+            paged_parse_result=paged_parse_result,
+            result_entry=result_entry,
+            exc=exc,
+        )
+
+
+def _upsert_success(
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+    has_partial_publication_set: bool,
+) -> ScholarProcessingOutcome:
+    discovered_count = paged_parse_result.discovered_publication_count
+    is_partial = (
+        paged_parse_result.has_more_remaining
+        or paged_parse_result.pagination_truncated_reason is not None
+        or has_partial_publication_set
+    )
+    scholar.last_run_status = RunStatus.PARTIAL_FAILURE if is_partial else RunStatus.SUCCESS
+    scholar.last_run_dt = run_dt
+    if not is_partial and paged_parse_result.first_page_fingerprint_sha256:
+        scholar.last_initial_page_fingerprint_sha256 = paged_parse_result.first_page_fingerprint_sha256
+    result_entry["outcome"] = "partial" if is_partial else "success"
+    if is_partial:
+        result_entry["debug"] = build_failure_debug_context(
+            fetch_result=paged_parse_result.fetch_result,
+            parsed_page=paged_parse_result.parsed_page,
+            attempt_log=paged_parse_result.attempt_log,
+            page_logs=paged_parse_result.page_logs,
+        )
+    return ScholarProcessingOutcome(
+        result_entry=result_entry,
+        succeeded_count_delta=1,
+        failed_count_delta=0,
+        partial_count_delta=1 if is_partial else 0,
+        discovered_publication_count=discovered_count,
+    )
+
+
+def _upsert_exception_outcome(
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+    exc: Exception,
+) -> ScholarProcessingOutcome:
+    scholar.last_run_status = RunStatus.FAILED
+    scholar.last_run_dt = run_dt
+    result_entry["state"] = "ingestion_error"
+    result_entry["state_reason"] = "publication_upsert_exception"
+    result_entry["outcome"] = "failed"
+    result_entry["error"] = str(exc)
+    result_entry["debug"] = build_failure_debug_context(
+        fetch_result=paged_parse_result.fetch_result,
+        parsed_page=paged_parse_result.parsed_page,
+        attempt_log=paged_parse_result.attempt_log,
+        page_logs=paged_parse_result.page_logs,
+        exception=exc,
+    )
+    structured_log(
+        logger,
+        "exception",
+        "ingestion.scholar_failed",
+        crawl_run_id=run.id,
+        scholar_profile_id=scholar.id,
+        scholar_id=scholar.scholar_id,
+    )
+    return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
+
+
+def _parse_failure_outcome(
+    *,
+    scholar: ScholarProfile,
+    run_dt: datetime,
+    paged_parse_result: PagedParseResult,
+    result_entry: dict[str, Any],
+) -> ScholarProcessingOutcome:
+    scholar.last_run_status = RunStatus.FAILED
+    scholar.last_run_dt = run_dt
+    result_entry["debug"] = build_failure_debug_context(
+        fetch_result=paged_parse_result.fetch_result,
+        parsed_page=paged_parse_result.parsed_page,
+        attempt_log=paged_parse_result.attempt_log,
+        page_logs=paged_parse_result.page_logs,
+    )
+    structured_log(
+        logger,
+        "warning",
+        "ingestion.scholar_parse_failed",
+        scholar_profile_id=scholar.id,
+        scholar_id=scholar.scholar_id,
+        state=paged_parse_result.parsed_page.state.value,
+        state_reason=paged_parse_result.parsed_page.state_reason,
+        status_code=paged_parse_result.fetch_result.status_code,
+    )
+    return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
+
+
+def unexpected_scholar_exception_outcome(
+    *,
+    run: CrawlRun,
+    scholar: ScholarProfile,
+    start_cstart: int,
+    exc: Exception,
+) -> ScholarProcessingOutcome:
+    scholar.last_run_status = RunStatus.FAILED
+    scholar.last_run_dt = datetime.now(UTC)
+    structured_log(
+        logger,
+        "exception",
+        "ingestion.scholar_unexpected_failure",
+        crawl_run_id=run.id,
+        scholar_profile_id=scholar.id,
+        scholar_id=scholar.scholar_id,
+    )
+    return ScholarProcessingOutcome(
+        result_entry={
+            "scholar_profile_id": scholar.id,
+            "scholar_id": scholar.scholar_id,
+            "state": "ingestion_error",
+            "state_reason": "scholar_processing_exception",
+            "outcome": "failed",
+            "attempt_count": 0,
+            "publication_count": 0,
+            "start_cstart": start_cstart,
+            "warnings": [],
+            "error": str(exc),
+            "debug": {"exception_type": type(exc).__name__, "exception_message": str(exc)},
+        },
+        succeeded_count_delta=0,
+        failed_count_delta=1,
+        partial_count_delta=0,
+        discovered_publication_count=0,
+    )
diff --git a/app/services/ingestion/scholar_processing.py b/app/services/ingestion/scholar_processing.py
index 37b47d3..f41d904 100644
--- a/app/services/ingestion/scholar_processing.py
+++ b/app/services/ingestion/scholar_processing.py
@@ -6,6 +6,7 @@ import random
 from datetime import UTC, datetime
 from typing import Any
 
+from sqlalchemy.exc import InterfaceError, OperationalError
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import (
@@ -21,7 +22,15 @@ from app.services.ingestion.constants import (
 )
 from app.services.ingestion.pagination import PaginationEngine
 from app.services.ingestion.publication_upsert import upsert_profile_publications
-from app.services.ingestion.run_completion import apply_outcome_to_progress, build_failure_debug_context
+from app.services.ingestion.run_completion import apply_outcome_to_progress
+from app.services.ingestion.scholar_outcomes import (
+    apply_first_page_profile_metadata,
+    assert_valid_paged_parse_result,
+    build_result_entry,
+    skipped_no_change_outcome,
+    unexpected_scholar_exception_outcome,
+    upsert_publications_outcome,
+)
 from app.services.ingestion.types import (
     PagedParseResult,
     RunProgress,
@@ -33,254 +42,6 @@ from app.services.scholar.state_detection import is_hard_challenge_reason
 logger = logging.getLogger(__name__)
 
 
-def assert_valid_paged_parse_result(
-    *,
-    scholar_id: str,
-    paged_parse_result: PagedParseResult,
-) -> None:
-    parsed_page = paged_parse_result.parsed_page
-    if parsed_page.state in {ParseState.OK, ParseState.NO_RESULTS} and any(
-        code.startswith("layout_") for code in parsed_page.warnings
-    ):
-        raise RuntimeError(f"Layout warning marked as terminal for scholar_id={scholar_id}.")
-    for publication in paged_parse_result.publications:
-        if not publication.title.strip():
-            raise RuntimeError(f"Malformed publication title for scholar_id={scholar_id}.")
-        if publication.citation_count is not None and int(publication.citation_count) < 0:
-            raise RuntimeError(f"Negative citation count for scholar_id={scholar_id}.")
-
-
-def apply_first_page_profile_metadata(
-    *,
-    scholar: ScholarProfile,
-    paged_parse_result: PagedParseResult,
-    run_dt: datetime,
-) -> None:
-    first_page = paged_parse_result.first_page_parsed_page
-    if first_page.profile_name and not (scholar.display_name or "").strip():
-        scholar.display_name = first_page.profile_name
-    if first_page.profile_image_url:
-        scholar.profile_image_url = first_page.profile_image_url
-    scholar.last_initial_page_checked_at = run_dt
-
-
-def build_result_entry(
-    *,
-    scholar: ScholarProfile,
-    start_cstart: int,
-    paged_parse_result: PagedParseResult,
-) -> dict[str, Any]:
-    parsed_page = paged_parse_result.parsed_page
-    return {
-        "scholar_profile_id": scholar.id,
-        "scholar_id": scholar.scholar_id,
-        "state": parsed_page.state.value,
-        "state_reason": parsed_page.state_reason,
-        "outcome": "failed",
-        "attempt_count": len(paged_parse_result.attempt_log),
-        "publication_count": len(paged_parse_result.publications),
-        "start_cstart": start_cstart,
-        "articles_range": parsed_page.articles_range,
-        "warnings": parsed_page.warnings,
-        "has_show_more_button": parsed_page.has_show_more_button,
-        "pages_fetched": paged_parse_result.pages_fetched,
-        "pages_attempted": paged_parse_result.pages_attempted,
-        "has_more_remaining": paged_parse_result.has_more_remaining,
-        "pagination_truncated_reason": paged_parse_result.pagination_truncated_reason,
-        "continuation_cstart": paged_parse_result.continuation_cstart,
-        "skipped_no_change": paged_parse_result.skipped_no_change,
-        "initial_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
-    }
-
-
-def skipped_no_change_outcome(
-    *,
-    scholar: ScholarProfile,
-    run_dt: datetime,
-    paged_parse_result: PagedParseResult,
-    result_entry: dict[str, Any],
-) -> ScholarProcessingOutcome:
-    first_page = paged_parse_result.first_page_parsed_page
-    scholar.last_run_status = RunStatus.SUCCESS
-    scholar.last_run_dt = run_dt
-    result_entry["state"] = first_page.state.value
-    result_entry["state_reason"] = "no_change_initial_page_signature"
-    result_entry["outcome"] = "success"
-    result_entry["publication_count"] = 0
-    result_entry["warnings"] = first_page.warnings
-    result_entry["debug"] = {
-        "state_reason": "no_change_initial_page_signature",
-        "first_page_fingerprint_sha256": paged_parse_result.first_page_fingerprint_sha256,
-        "attempt_log": paged_parse_result.attempt_log,
-        "page_logs": paged_parse_result.page_logs,
-    }
-    return ScholarProcessingOutcome(
-        result_entry=result_entry,
-        succeeded_count_delta=1,
-        failed_count_delta=0,
-        partial_count_delta=0,
-        discovered_publication_count=0,
-    )
-
-
-async def upsert_publications_outcome(
-    db_session: AsyncSession,
-    *,
-    run: CrawlRun,
-    scholar: ScholarProfile,
-    run_dt: datetime,
-    paged_parse_result: PagedParseResult,
-    result_entry: dict[str, Any],
-) -> ScholarProcessingOutcome:
-    parsed_page = paged_parse_result.parsed_page
-    publications = paged_parse_result.publications
-    had_page_failure = parsed_page.state not in {ParseState.OK, ParseState.NO_RESULTS}
-    has_partial_set = len(publications) > 0 and had_page_failure
-    if (not had_page_failure) or has_partial_set:
-        return await _upsert_success_or_exception(
-            db_session,
-            run=run,
-            scholar=scholar,
-            run_dt=run_dt,
-            paged_parse_result=paged_parse_result,
-            result_entry=result_entry,
-            has_partial_publication_set=has_partial_set,
-        )
-    return _parse_failure_outcome(
-        scholar=scholar,
-        run_dt=run_dt,
-        paged_parse_result=paged_parse_result,
-        result_entry=result_entry,
-    )
-
-
-async def _upsert_success_or_exception(
-    db_session: AsyncSession,
-    *,
-    run: CrawlRun,
-    scholar: ScholarProfile,
-    run_dt: datetime,
-    paged_parse_result: PagedParseResult,
-    result_entry: dict[str, Any],
-    has_partial_publication_set: bool,
-) -> ScholarProcessingOutcome:
-    try:
-        return _upsert_success(
-            run=run,
-            scholar=scholar,
-            run_dt=run_dt,
-            paged_parse_result=paged_parse_result,
-            result_entry=result_entry,
-            has_partial_publication_set=has_partial_publication_set,
-        )
-    except Exception as exc:
-        return _upsert_exception_outcome(
-            run=run,
-            scholar=scholar,
-            run_dt=run_dt,
-            paged_parse_result=paged_parse_result,
-            result_entry=result_entry,
-            exc=exc,
-        )
-
-
-def _upsert_success(
-    *,
-    run: CrawlRun,
-    scholar: ScholarProfile,
-    run_dt: datetime,
-    paged_parse_result: PagedParseResult,
-    result_entry: dict[str, Any],
-    has_partial_publication_set: bool,
-) -> ScholarProcessingOutcome:
-    discovered_count = paged_parse_result.discovered_publication_count
-    is_partial = (
-        paged_parse_result.has_more_remaining
-        or paged_parse_result.pagination_truncated_reason is not None
-        or has_partial_publication_set
-    )
-    scholar.last_run_status = RunStatus.PARTIAL_FAILURE if is_partial else RunStatus.SUCCESS
-    scholar.last_run_dt = run_dt
-    if not is_partial and paged_parse_result.first_page_fingerprint_sha256:
-        scholar.last_initial_page_fingerprint_sha256 = paged_parse_result.first_page_fingerprint_sha256
-    result_entry["outcome"] = "partial" if is_partial else "success"
-    if is_partial:
-        result_entry["debug"] = build_failure_debug_context(
-            fetch_result=paged_parse_result.fetch_result,
-            parsed_page=paged_parse_result.parsed_page,
-            attempt_log=paged_parse_result.attempt_log,
-            page_logs=paged_parse_result.page_logs,
-        )
-    return ScholarProcessingOutcome(
-        result_entry=result_entry,
-        succeeded_count_delta=1,
-        failed_count_delta=0,
-        partial_count_delta=1 if is_partial else 0,
-        discovered_publication_count=discovered_count,
-    )
-
-
-def _upsert_exception_outcome(
-    *,
-    run: CrawlRun,
-    scholar: ScholarProfile,
-    run_dt: datetime,
-    paged_parse_result: PagedParseResult,
-    result_entry: dict[str, Any],
-    exc: Exception,
-) -> ScholarProcessingOutcome:
-    scholar.last_run_status = RunStatus.FAILED
-    scholar.last_run_dt = run_dt
-    result_entry["state"] = "ingestion_error"
-    result_entry["state_reason"] = "publication_upsert_exception"
-    result_entry["outcome"] = "failed"
-    result_entry["error"] = str(exc)
-    result_entry["debug"] = build_failure_debug_context(
-        fetch_result=paged_parse_result.fetch_result,
-        parsed_page=paged_parse_result.parsed_page,
-        attempt_log=paged_parse_result.attempt_log,
-        page_logs=paged_parse_result.page_logs,
-        exception=exc,
-    )
-    logger.exception(
-        "ingestion.scholar_failed",
-        extra={
-            "crawl_run_id": run.id,
-            "scholar_profile_id": scholar.id,
-            "scholar_id": scholar.scholar_id,
-        },
-    )
-    return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
-
-
-def _parse_failure_outcome(
-    *,
-    scholar: ScholarProfile,
-    run_dt: datetime,
-    paged_parse_result: PagedParseResult,
-    result_entry: dict[str, Any],
-) -> ScholarProcessingOutcome:
-    scholar.last_run_status = RunStatus.FAILED
-    scholar.last_run_dt = run_dt
-    result_entry["debug"] = build_failure_debug_context(
-        fetch_result=paged_parse_result.fetch_result,
-        parsed_page=paged_parse_result.parsed_page,
-        attempt_log=paged_parse_result.attempt_log,
-        page_logs=paged_parse_result.page_logs,
-    )
-    structured_log(
-        logger,
-        "warning",
-        "ingestion.scholar_parse_failed",
-        scholar_profile_id=scholar.id,
-        scholar_id=scholar.scholar_id,
-        state=paged_parse_result.parsed_page.state.value,
-        state_reason=paged_parse_result.parsed_page.state_reason,
-        status_code=paged_parse_result.fetch_result.status_code,
-    )
-    return ScholarProcessingOutcome(result_entry, 0, 1, 0, 0)
-
-
 async def sync_continuation_queue(
     db_session: AsyncSession,
     *,
@@ -396,6 +157,8 @@ async def process_scholar(
             queue_delay_seconds=queue_delay_seconds,
         )
         return outcome
+    except (OperationalError, InterfaceError):
+        raise
     except Exception as exc:
         return unexpected_scholar_exception_outcome(
             run=run,
@@ -492,44 +255,6 @@ async def _resolve_scholar_outcome(
     )
 
 
-def unexpected_scholar_exception_outcome(
-    *,
-    run: CrawlRun,
-    scholar: ScholarProfile,
-    start_cstart: int,
-    exc: Exception,
-) -> ScholarProcessingOutcome:
-    scholar.last_run_status = RunStatus.FAILED
-    scholar.last_run_dt = datetime.now(UTC)
-    logger.exception(
-        "ingestion.scholar_unexpected_failure",
-        extra={
-            "crawl_run_id": run.id,
-            "scholar_profile_id": scholar.id,
-            "scholar_id": scholar.scholar_id,
-        },
-    )
-    return ScholarProcessingOutcome(
-        result_entry={
-            "scholar_profile_id": scholar.id,
-            "scholar_id": scholar.scholar_id,
-            "state": "ingestion_error",
-            "state_reason": "scholar_processing_exception",
-            "outcome": "failed",
-            "attempt_count": 0,
-            "publication_count": 0,
-            "start_cstart": start_cstart,
-            "warnings": [],
-            "error": str(exc),
-            "debug": {"exception_type": type(exc).__name__, "exception_message": str(exc)},
-        },
-        succeeded_count_delta=0,
-        failed_count_delta=1,
-        partial_count_delta=0,
-        discovered_publication_count=0,
-    )
-
-
 def _is_hard_challenge_outcome(outcome: ScholarProcessingOutcome) -> bool:
     entry = outcome.result_entry
     return str(entry.get("state", "")) == ParseState.BLOCKED_OR_CAPTCHA.value and is_hard_challenge_reason(
diff --git a/app/services/openalex/client.py b/app/services/openalex/client.py
index f418c1e..13db8ab 100644
--- a/app/services/openalex/client.py
+++ b/app/services/openalex/client.py
@@ -8,6 +8,7 @@ from tenacity import (
     wait_exponential,
 )
 
+from app.logging_utils import structured_log
 from app.services.openalex.types import OpenAlexWork
 
 logger = logging.getLogger(__name__)
@@ -82,7 +83,13 @@ class OpenAlexClient:
                 raise OpenAlexBudgetExhaustedError("Daily API budget exhausted; retrying won't help until midnight UTC")
             raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex work by DOI")
         if response.status_code >= 400:
-            logger.warning("OpenAlex API error: %s %s", response.status_code, response.text[:500])
+            structured_log(
+                logger,
+                "warning",
+                "openalex.api_error",
+                status_code=response.status_code,
+                response_preview=response.text[:500],
+            )
             raise OpenAlexClientError(f"API Error {response.status_code}")
 
         data = response.json()
@@ -130,7 +137,14 @@ class OpenAlexClient:
                 raise OpenAlexBudgetExhaustedError("Daily API budget exhausted; retrying won't help until midnight UTC")
             raise OpenAlexRateLimitError("Rate limit exceeded fetching OpenAlex works list")
         if response.status_code >= 400:
-            logger.warning("OpenAlex API error (filters=%s): %s %s", filters, response.status_code, response.text[:500])
+            structured_log(
+                logger,
+                "warning",
+                "openalex.api_error_with_filters",
+                filters=filters,
+                status_code=response.status_code,
+                response_preview=response.text[:500],
+            )
             raise OpenAlexClientError(f"API Error {response.status_code}")
 
         data = response.json()
@@ -140,8 +154,13 @@ class OpenAlexClient:
         for raw_work in results:
             try:
                 parsed_works.append(OpenAlexWork.from_api_dict(raw_work))
-            except Exception as e:
-                logger.warning("Failed to parse OpenAlex raw dict: %s", e)
+            except Exception as exc:
+                structured_log(
+                    logger,
+                    "warning",
+                    "openalex.parse_failed",
+                    error=str(exc),
+                )
                 continue
 
         return parsed_works
diff --git a/app/services/publications/pdf_queue_common.py b/app/services/publications/pdf_queue_common.py
index 46c2143..9eb95ed 100644
--- a/app/services/publications/pdf_queue_common.py
+++ b/app/services/publications/pdf_queue_common.py
@@ -4,6 +4,7 @@ from datetime import UTC, datetime
 
 from app.db.models import PublicationPdfJob, PublicationPdfJobEvent
 
+PDF_STATUS_UNTRACKED = "untracked"
 PDF_STATUS_QUEUED = "queued"
 PDF_STATUS_RUNNING = "running"
 PDF_STATUS_RESOLVED = "resolved"
diff --git a/app/services/publications/pdf_queue_queries.py b/app/services/publications/pdf_queue_queries.py
index a0ee0b2..31260ea 100644
--- a/app/services/publications/pdf_queue_queries.py
+++ b/app/services/publications/pdf_queue_queries.py
@@ -16,14 +16,13 @@ from app.db.models import (
 )
 from app.services.publication_identifiers import application as identifier_service
 from app.services.publication_identifiers.types import DisplayIdentifier
+from app.services.publications.pdf_queue_common import (
+    PDF_STATUS_QUEUED,
+    PDF_STATUS_RUNNING,
+    PDF_STATUS_UNTRACKED,
+)
 from app.services.publications.types import PublicationListItem
 
-PDF_STATUS_UNTRACKED = "untracked"
-PDF_STATUS_QUEUED = "queued"
-PDF_STATUS_RUNNING = "running"
-PDF_STATUS_RESOLVED = "resolved"
-PDF_STATUS_FAILED = "failed"
-
 
 def _bounded_limit(limit: int, *, max_value: int = 500) -> int:
     return max(1, min(int(limit), max_value))
diff --git a/app/services/publications/pdf_queue_resolution.py b/app/services/publications/pdf_queue_resolution.py
index aa80761..aec3f74 100644
--- a/app/services/publications/pdf_queue_resolution.py
+++ b/app/services/publications/pdf_queue_resolution.py
@@ -251,7 +251,7 @@ def _drop_finished_task(task: asyncio.Task[None]) -> None:
     try:
         task.result()
     except Exception:
-        logger.exception("publications.pdf_queue.task_failed")
+        structured_log(logger, "exception", "publications.pdf_queue.task_failed")
 
 
 def schedule_rows(
diff --git a/app/services/publications/queries.py b/app/services/publications/queries.py
index 82763aa..f113080 100644
--- a/app/services/publications/queries.py
+++ b/app/services/publications/queries.py
@@ -16,6 +16,12 @@ from app.db.models import (
     ScholarPublication,
 )
 from app.services.publications.modes import MODE_LATEST, MODE_UNREAD
+from app.services.publications.pdf_queue_common import (
+    PDF_STATUS_FAILED,
+    PDF_STATUS_QUEUED,
+    PDF_STATUS_RESOLVED,
+    PDF_STATUS_RUNNING,
+)
 from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 
@@ -29,10 +35,10 @@ def _normalized_citation_count(value: object) -> int:
 def _pdf_status_sort_rank():
     return case(
         (Publication.pdf_url.is_not(None), 4),
-        (PublicationPdfJob.status == "resolved", 4),
-        (PublicationPdfJob.status == "running", 3),
-        (PublicationPdfJob.status == "queued", 2),
-        (PublicationPdfJob.status == "failed", 0),
+        (PublicationPdfJob.status == PDF_STATUS_RESOLVED, 4),
+        (PublicationPdfJob.status == PDF_STATUS_RUNNING, 3),
+        (PublicationPdfJob.status == PDF_STATUS_QUEUED, 2),
+        (PublicationPdfJob.status == PDF_STATUS_FAILED, 0),
         else_=1,
     )
 
diff --git a/app/services/runs/events.py b/app/services/runs/events.py
index 7f4a71e..17baa62 100644
--- a/app/services/runs/events.py
+++ b/app/services/runs/events.py
@@ -4,6 +4,8 @@ import logging
 from collections.abc import AsyncGenerator
 from typing import Any
 
+from app.logging_utils import structured_log
+
 logger = logging.getLogger(__name__)
 
 
@@ -17,7 +19,13 @@ class RunEventPublisher:
             self._subscribers[run_id] = set()
         queue: asyncio.Queue[Any] = asyncio.Queue()
         self._subscribers[run_id].add(queue)
-        logger.debug(f"New subscriber for run {run_id}. Total: {len(self._subscribers[run_id])}")
+        structured_log(
+            logger,
+            "debug",
+            "runs.event_subscriber_added",
+            run_id=run_id,
+            subscriber_count=len(self._subscribers[run_id]),
+        )
         return queue
 
     def unsubscribe(self, run_id: int, queue: asyncio.Queue) -> None:
@@ -37,7 +45,12 @@ class RunEventPublisher:
             try:
                 queue.put_nowait(message)
             except asyncio.QueueFull:
-                logger.warning(f"Subscriber queue full for run {run_id}, dropping message")
+                structured_log(
+                    logger,
+                    "warning",
+                    "runs.event_subscriber_queue_full",
+                    run_id=run_id,
+                )
 
 
 run_events = RunEventPublisher()
@@ -54,7 +67,12 @@ async def event_generator(run_id: int) -> AsyncGenerator[str, None]:
             data_str = json.dumps(message["data"])
             yield f"event: {event_type}\ndata: {data_str}\n\n"
     except asyncio.CancelledError:
-        logger.debug(f"Client disconnected from SSE stream for run {run_id}")
+        structured_log(
+            logger,
+            "debug",
+            "runs.event_stream_disconnected",
+            run_id=run_id,
+        )
         raise
     finally:
         run_events.unsubscribe(run_id, queue)
diff --git a/app/services/scholar/profile_rows.py b/app/services/scholar/profile_rows.py
index bb0d83d..d291dbf 100644
--- a/app/services/scholar/profile_rows.py
+++ b/app/services/scholar/profile_rows.py
@@ -131,7 +131,10 @@ def parse_citation_count(parts: list[str]) -> int | None:
     text = normalize_space(" ".join(parts))
     if not text:
         return 0
-    digits = re.sub(r"\D+", "", text)
+    match = re.search(r"[\d,]+", text)
+    if not match:
+        return None
+    digits = match.group(0).replace(",", "")
     if not digits:
         return None
     return int(digits)
diff --git a/app/services/unpaywall/application.py b/app/services/unpaywall/application.py
index fa9b83b..f7d23f8 100644
--- a/app/services/unpaywall/application.py
+++ b/app/services/unpaywall/application.py
@@ -393,7 +393,7 @@ async def resolve_publication_oa_outcomes(
         return {}
     email = _email_for_request(request_email)
     if email is None:
-        logger.debug("unpaywall.resolve_skipped_missing_email")
+        structured_log(logger, "debug", "unpaywall.resolve_skipped_missing_email")
         return {}
     import httpx
 
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 81441d5..4e5d821 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -15,7 +15,9 @@
       "devDependencies": {
         "@types/node": "^22.10.2",
         "@vitejs/plugin-vue": "^5.2.1",
+        "@vue/test-utils": "^2.4.6",
         "autoprefixer": "^10.4.21",
+        "happy-dom": "^20.7.0",
         "postcss": "^8.5.3",
         "tailwindcss": "^3.4.17",
         "typescript": "^5.7.2",
@@ -474,6 +476,24 @@
         "node": ">=12"
       }
     },
+    "node_modules/@isaacs/cliui": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
+      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^5.1.2",
+        "string-width-cjs": "npm:string-width@^4.2.0",
+        "strip-ansi": "^7.0.1",
+        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
+        "wrap-ansi": "^8.1.0",
+        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/@jridgewell/gen-mapping": {
       "version": "0.3.13",
       "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
@@ -550,6 +570,24 @@
         "node": ">= 8"
       }
     },
+    "node_modules/@one-ini/wasm": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/@one-ini/wasm/-/wasm-0.1.1.tgz",
+      "integrity": "sha512-XuySG1E38YScSJoMlqovLru4KTUNSjgVTIjyh7qMX6aNN5HY5Ct5LhRJdxO79JtTzKfzV/bnWpz+zquYrISsvw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@pkgjs/parseargs": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
+      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=14"
+      }
+    },
     "node_modules/@rollup/rollup-android-arm-eabi": {
       "version": "4.57.1",
       "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.57.1.tgz",
@@ -917,6 +955,23 @@
         "undici-types": "~6.21.0"
       }
     },
+    "node_modules/@types/whatwg-mimetype": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@types/whatwg-mimetype/-/whatwg-mimetype-3.0.2.tgz",
+      "integrity": "sha512-c2AKvDT8ToxLIOUlN51gTiHXflsfIFisS4pO7pDPoKouJCESkhZnEy623gwP9laCy5lnLDAw1vAzu2vM2YLOrA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@vitejs/plugin-vue": {
       "version": "5.2.4",
       "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.4.tgz",
@@ -1227,6 +1282,27 @@
       "integrity": "sha512-cfWa1fCGBxrvaHRhvV3Is0MgmrbSCxYTXCSCau2I0a1Xw1N1pHAvkWCiXPRAqjvToILvguNyEwjevUqAuBQWvQ==",
       "license": "MIT"
     },
+    "node_modules/@vue/test-utils": {
+      "version": "2.4.6",
+      "resolved": "https://registry.npmjs.org/@vue/test-utils/-/test-utils-2.4.6.tgz",
+      "integrity": "sha512-FMxEjOpYNYiFe0GkaHsnJPXFHxQ6m4t8vI/ElPGpMWxZKpmRvQ33OIrvRXemy6yha03RxhOlQuy+gZMC3CQSow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "js-beautify": "^1.14.9",
+        "vue-component-type-helpers": "^2.0.0"
+      }
+    },
+    "node_modules/abbrev": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-2.0.0.tgz",
+      "integrity": "sha512-6/mh1E2u2YgEsCHdY0Yx5oW+61gZU+1vXaoiHHrpKeuRNNgFvS+/jrwHiQhB5apAf5oB7UB7E19ol2R2LKH8hQ==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
     "node_modules/alien-signals": {
       "version": "1.0.13",
       "resolved": "https://registry.npmjs.org/alien-signals/-/alien-signals-1.0.13.tgz",
@@ -1234,6 +1310,32 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/ansi-regex": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
     "node_modules/any-promise": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
@@ -1502,6 +1604,26 @@
         "node": ">= 6"
       }
     },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/commander": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
@@ -1512,6 +1634,32 @@
         "node": ">= 6"
       }
     },
+    "node_modules/config-chain": {
+      "version": "1.1.13",
+      "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz",
+      "integrity": "sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ini": "^1.3.4",
+        "proto-list": "~1.2.1"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/cssesc": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
@@ -1580,6 +1728,42 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/eastasianwidth": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
+      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/editorconfig": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/editorconfig/-/editorconfig-1.0.7.tgz",
+      "integrity": "sha512-e0GOtq/aTQhVdNyDU9e02+wz9oDDM+SIOQxWME2QRjzRX5yyLAuHDE+0aE8vHb9XRC8XD37eO2u57+F09JqFhw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@one-ini/wasm": "0.1.1",
+        "commander": "^10.0.0",
+        "minimatch": "^9.0.1",
+        "semver": "^7.5.3"
+      },
+      "bin": {
+        "editorconfig": "bin/editorconfig"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/editorconfig/node_modules/commander": {
+      "version": "10.0.1",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz",
+      "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      }
+    },
     "node_modules/electron-to-chromium": {
       "version": "1.5.286",
       "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.286.tgz",
@@ -1587,6 +1771,13 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/emoji-regex": {
+      "version": "9.2.2",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/entities": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
@@ -1728,6 +1919,23 @@
         "node": ">=8"
       }
     },
+    "node_modules/foreground-child": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
+      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "cross-spawn": "^7.0.6",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/fraction.js": {
       "version": "5.3.4",
       "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz",
@@ -1767,6 +1975,28 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/glob": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz",
+      "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/glob-parent": {
       "version": "6.0.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
@@ -1780,6 +2010,24 @@
         "node": ">=10.13.0"
       }
     },
+    "node_modules/happy-dom": {
+      "version": "20.7.0",
+      "resolved": "https://registry.npmjs.org/happy-dom/-/happy-dom-20.7.0.tgz",
+      "integrity": "sha512-hR/uLYQdngTyEfxnOoa+e6KTcfBFyc1hgFj/Cc144A5JJUuHFYqIEBDcD4FeGqUeKLRZqJ9eN9u7/GDjYEgS1g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": ">=20.0.0",
+        "@types/whatwg-mimetype": "^3.0.2",
+        "@types/ws": "^8.18.1",
+        "entities": "^7.0.1",
+        "whatwg-mimetype": "^3.0.0",
+        "ws": "^8.18.3"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
     "node_modules/hasown": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
@@ -1803,6 +2051,13 @@
         "he": "bin/he"
       }
     },
+    "node_modules/ini": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/is-binary-path": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
@@ -1842,6 +2097,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/is-glob": {
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
@@ -1865,6 +2130,29 @@
         "node": ">=0.12.0"
       }
     },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/jackspeak": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
+      "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/cliui": "^8.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      },
+      "optionalDependencies": {
+        "@pkgjs/parseargs": "^0.11.0"
+      }
+    },
     "node_modules/jiti": {
       "version": "1.21.7",
       "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
@@ -1875,6 +2163,38 @@
         "jiti": "bin/jiti.js"
       }
     },
+    "node_modules/js-beautify": {
+      "version": "1.15.4",
+      "resolved": "https://registry.npmjs.org/js-beautify/-/js-beautify-1.15.4.tgz",
+      "integrity": "sha512-9/KXeZUKKJwqCXUdBxFJ3vPh467OCckSBmYDwSK/EtV090K+iMJ7zx2S3HLVDIWFQdqMIsZWbnaGiba18aWhaA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "config-chain": "^1.1.13",
+        "editorconfig": "^1.0.4",
+        "glob": "^10.4.2",
+        "js-cookie": "^3.0.5",
+        "nopt": "^7.2.1"
+      },
+      "bin": {
+        "css-beautify": "js/bin/css-beautify.js",
+        "html-beautify": "js/bin/html-beautify.js",
+        "js-beautify": "js/bin/js-beautify.js"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/js-cookie": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/js-cookie/-/js-cookie-3.0.5.tgz",
+      "integrity": "sha512-cEiJEAEoIbWfCZYKWhVwFuvPX1gETRYPw6LlaTKoxD3s2AkXzkCjnp6h0V77ozyqj0jakteJ4YqDJT830+lVGw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      }
+    },
     "node_modules/lilconfig": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
@@ -1902,6 +2222,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/lru-cache": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/magic-string": {
       "version": "0.30.21",
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
@@ -1951,6 +2278,16 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/minipass": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -2002,6 +2339,22 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/nopt": {
+      "version": "7.2.1",
+      "resolved": "https://registry.npmjs.org/nopt/-/nopt-7.2.1.tgz",
+      "integrity": "sha512-taM24ViiimT/XntxbPyJQzCG+p4EKOpgD3mxFwW38mGjVUrfERQOeY4EDHjdnptttfHuHQXFx+lTP08Q+mLa/w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "abbrev": "^2.0.0"
+      },
+      "bin": {
+        "nopt": "bin/nopt.js"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
     "node_modules/normalize-path": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
@@ -2032,6 +2385,13 @@
         "node": ">= 6"
       }
     },
+    "node_modules/package-json-from-dist": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0"
+    },
     "node_modules/path-browserify": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
@@ -2039,6 +2399,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/path-parse": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
@@ -2046,6 +2416,23 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/path-scurry": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
+      "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "lru-cache": "^10.2.0",
+        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/pathe": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
@@ -2286,6 +2673,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/proto-list": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz",
+      "integrity": "sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/queue-microtask": {
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
@@ -2431,6 +2825,42 @@
         "queue-microtask": "^1.2.2"
       }
     },
+    "node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/siginfo": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
@@ -2438,6 +2868,19 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/source-map-js": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
@@ -2461,6 +2904,110 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/string-width": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eastasianwidth": "^0.2.0",
+        "emoji-regex": "^9.2.2",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/string-width-cjs": {
+      "name": "string-width",
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/string-width-cjs/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/string-width-cjs/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/string-width-cjs/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.2.2"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/strip-ansi-cjs": {
+      "name": "strip-ansi",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi-cjs/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/sucrase": {
       "version": "3.35.1",
       "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz",
@@ -2906,6 +3453,13 @@
         }
       }
     },
+    "node_modules/vue-component-type-helpers": {
+      "version": "2.2.12",
+      "resolved": "https://registry.npmjs.org/vue-component-type-helpers/-/vue-component-type-helpers-2.2.12.tgz",
+      "integrity": "sha512-YbGqHZ5/eW4SnkPNR44mKVc6ZKQoRs/Rux1sxC6rdwXb4qpbOSYfDr9DsTHolOTGmIKgM9j141mZbBeg05R1pw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/vue-demi": {
       "version": "0.14.10",
       "resolved": "https://registry.npmjs.org/vue-demi/-/vue-demi-0.14.10.tgz",
@@ -2964,6 +3518,32 @@
         "typescript": ">=5.0.0"
       }
     },
+    "node_modules/whatwg-mimetype": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-3.0.0.tgz",
+      "integrity": "sha512-nt+N2dzIutVRxARx1nghPKGv1xHikU7HKdfafKkLNLindmPU/ch3U31NOCGGA/dmPcmb1VlofO0vnKAcsm0o/Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/why-is-node-running": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
@@ -2980,6 +3560,126 @@
       "engines": {
         "node": ">=8"
       }
+    },
+    "node_modules/wrap-ansi": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
+      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.1.0",
+        "string-width": "^5.0.1",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs": {
+      "name": "wrap-ansi",
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
     }
   }
 }
diff --git a/frontend/package.json b/frontend/package.json
index 521cffc..912ec8a 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -21,7 +21,9 @@
   "devDependencies": {
     "@types/node": "^22.10.2",
     "@vitejs/plugin-vue": "^5.2.1",
+    "@vue/test-utils": "^2.4.6",
     "autoprefixer": "^10.4.21",
+    "happy-dom": "^20.7.0",
     "postcss": "^8.5.3",
     "tailwindcss": "^3.4.17",
     "typescript": "^5.7.2",
diff --git a/frontend/src/composables/useRequestState.test.ts b/frontend/src/composables/useRequestState.test.ts
new file mode 100644
index 0000000..d8e8168
--- /dev/null
+++ b/frontend/src/composables/useRequestState.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { ApiRequestError } from "@/lib/api/errors";
+import { useRequestState } from "@/composables/useRequestState";
+
+describe("useRequestState", () => {
+  it("initializes with all values null", () => {
+    const { errorMessage, errorRequestId, successMessage } = useRequestState();
+    expect(errorMessage.value).toBeNull();
+    expect(errorRequestId.value).toBeNull();
+    expect(successMessage.value).toBeNull();
+  });
+
+  it("assignError extracts message and requestId from ApiRequestError", () => {
+    const { errorMessage, errorRequestId, assignError } = useRequestState();
+    assignError(
+      new ApiRequestError({ status: 409, code: "conflict", message: "Conflict occurred", requestId: "req-42" }),
+      "fallback",
+    );
+    expect(errorMessage.value).toBe("Conflict occurred");
+    expect(errorRequestId.value).toBe("req-42");
+  });
+
+  it("assignError uses Error.message for generic errors", () => {
+    const { errorMessage, errorRequestId, assignError } = useRequestState();
+    assignError(new Error("something broke"), "fallback");
+    expect(errorMessage.value).toBe("something broke");
+    expect(errorRequestId.value).toBeNull();
+  });
+
+  it("assignError uses fallback for non-Error values", () => {
+    const { errorMessage, assignError } = useRequestState();
+    assignError("not an error object", "fallback text");
+    expect(errorMessage.value).toBe("fallback text");
+  });
+
+  it("setSuccess sets the success message", () => {
+    const { successMessage, setSuccess } = useRequestState();
+    setSuccess("Operation completed");
+    expect(successMessage.value).toBe("Operation completed");
+  });
+
+  it("clearAlerts resets all messages", () => {
+    const { errorMessage, errorRequestId, successMessage, assignError, setSuccess, clearAlerts } = useRequestState();
+    assignError(new ApiRequestError({ status: 500, code: "err", message: "fail", requestId: "r1" }), "fb");
+    setSuccess("ok");
+    clearAlerts();
+    expect(errorMessage.value).toBeNull();
+    expect(errorRequestId.value).toBeNull();
+    expect(successMessage.value).toBeNull();
+  });
+});
diff --git a/frontend/src/composables/useRequestState.ts b/frontend/src/composables/useRequestState.ts
new file mode 100644
index 0000000..0e4c783
--- /dev/null
+++ b/frontend/src/composables/useRequestState.ts
@@ -0,0 +1,40 @@
+import { ref } from "vue";
+import { ApiRequestError } from "@/lib/api/errors";
+
+export function useRequestState() {
+  const errorMessage = ref<string | null>(null);
+  const errorRequestId = ref<string | null>(null);
+  const successMessage = ref<string | null>(null);
+
+  function clearAlerts(): void {
+    errorMessage.value = null;
+    errorRequestId.value = null;
+    successMessage.value = null;
+  }
+
+  function assignError(error: unknown, fallback: string): void {
+    if (error instanceof ApiRequestError) {
+      errorMessage.value = error.message;
+      errorRequestId.value = error.requestId;
+      return;
+    }
+    if (error instanceof Error && error.message) {
+      errorMessage.value = error.message;
+      return;
+    }
+    errorMessage.value = fallback;
+  }
+
+  function setSuccess(message: string): void {
+    successMessage.value = message;
+  }
+
+  return {
+    errorMessage,
+    errorRequestId,
+    successMessage,
+    clearAlerts,
+    assignError,
+    setSuccess,
+  };
+}
diff --git a/frontend/src/features/publications/components/PublicationTableRow.test.ts b/frontend/src/features/publications/components/PublicationTableRow.test.ts
new file mode 100644
index 0000000..3a1110d
--- /dev/null
+++ b/frontend/src/features/publications/components/PublicationTableRow.test.ts
@@ -0,0 +1,139 @@
+// @vitest-environment happy-dom
+import { describe, expect, it } from "vitest";
+import { mount } from "@vue/test-utils";
+import PublicationTableRow from "./PublicationTableRow.vue";
+import type { PublicationItem } from "@/features/publications";
+
+function buildItem(overrides: Partial<PublicationItem> = {}): PublicationItem {
+  return {
+    publication_id: 1,
+    scholar_profile_id: 10,
+    title: "Test Publication",
+    year: 2025,
+    citation_count: 42,
+    pub_url: "https://example.com/pub",
+    pdf_url: null,
+    pdf_status: null,
+    is_read: false,
+    is_favorite: false,
+    is_new_in_latest_run: true,
+    scholar_label: "Dr. Test",
+    first_seen_at: "2025-01-15T00:00:00Z",
+    display_identifier: null,
+    ...overrides,
+  } as PublicationItem;
+}
+
+const defaultProps = {
+  item: buildItem(),
+  itemKey: "pub-1",
+  selected: false,
+  favoriteUpdating: false,
+  retrying: false,
+  canRetry: false,
+};
+
+describe("PublicationTableRow", () => {
+  it("renders the publication title", () => {
+    const wrapper = mount(PublicationTableRow, { props: defaultProps });
+    expect(wrapper.text()).toContain("Test Publication");
+  });
+
+  it("renders scholar label", () => {
+    const wrapper = mount(PublicationTableRow, { props: defaultProps });
+    expect(wrapper.text()).toContain("Dr. Test");
+  });
+
+  it("renders year and citation count", () => {
+    const wrapper = mount(PublicationTableRow, { props: defaultProps });
+    expect(wrapper.text()).toContain("2025");
+    expect(wrapper.text()).toContain("42");
+  });
+
+  it("shows New badge when is_new_in_latest_run is true", () => {
+    const wrapper = mount(PublicationTableRow, { props: defaultProps });
+    expect(wrapper.text()).toContain("New");
+  });
+
+  it("shows Seen badge when is_new_in_latest_run is false", () => {
+    const wrapper = mount(PublicationTableRow, {
+      props: { ...defaultProps, item: buildItem({ is_new_in_latest_run: false }) },
+    });
+    expect(wrapper.text()).toContain("Seen");
+  });
+
+  it("shows Unread badge for unread items", () => {
+    const wrapper = mount(PublicationTableRow, { props: defaultProps });
+    expect(wrapper.text()).toContain("Unread");
+  });
+
+  it("shows Read badge for read items", () => {
+    const wrapper = mount(PublicationTableRow, {
+      props: { ...defaultProps, item: buildItem({ is_read: true }) },
+    });
+    expect(wrapper.text()).toContain("Read");
+  });
+
+  it("disables checkbox when item is read", () => {
+    const wrapper = mount(PublicationTableRow, {
+      props: { ...defaultProps, item: buildItem({ is_read: true }) },
+    });
+    const checkbox = wrapper.find('input[type="checkbox"]');
+    expect((checkbox.element as HTMLInputElement).disabled).toBe(true);
+  });
+
+  it("emits toggle-selection when checkbox is changed", async () => {
+    const wrapper = mount(PublicationTableRow, { props: defaultProps });
+    await wrapper.find('input[type="checkbox"]').trigger("change");
+    expect(wrapper.emitted("toggle-selection")).toHaveLength(1);
+  });
+
+  it("emits toggle-favorite when star button is clicked", async () => {
+    const wrapper = mount(PublicationTableRow, { props: defaultProps });
+    await wrapper.find(".favorite-star-button").trigger("click");
+    expect(wrapper.emitted("toggle-favorite")).toHaveLength(1);
+  });
+
+  it("shows filled star when item is favorite", () => {
+    const wrapper = mount(PublicationTableRow, {
+      props: { ...defaultProps, item: buildItem({ is_favorite: true }) },
+    });
+    expect(wrapper.find(".favorite-star-on").exists()).toBe(true);
+    expect(wrapper.text()).toContain("★");
+  });
+
+  it("shows empty star when item is not favorite", () => {
+    const wrapper = mount(PublicationTableRow, { props: defaultProps });
+    expect(wrapper.find(".favorite-star-off").exists()).toBe(true);
+    expect(wrapper.text()).toContain("☆");
+  });
+
+  it("shows Available link when pdf_url is set", () => {
+    const wrapper = mount(PublicationTableRow, {
+      props: { ...defaultProps, item: buildItem({ pdf_url: "https://example.com/paper.pdf" }) },
+    });
+    expect(wrapper.text()).toContain("Available");
+  });
+
+  it("shows retry button when canRetry is true and no pdf_url", () => {
+    const wrapper = mount(PublicationTableRow, {
+      props: { ...defaultProps, canRetry: true },
+    });
+    expect(wrapper.text()).toContain("Missing (Retry)");
+  });
+
+  it("emits retry-pdf when retry button is clicked", async () => {
+    const wrapper = mount(PublicationTableRow, {
+      props: { ...defaultProps, canRetry: true },
+    });
+    await wrapper.find(".pdf-retry-button").trigger("click");
+    expect(wrapper.emitted("retry-pdf")).toHaveLength(1);
+  });
+
+  it("shows Retrying... label when retrying", () => {
+    const wrapper = mount(PublicationTableRow, {
+      props: { ...defaultProps, canRetry: true, retrying: true },
+    });
+    expect(wrapper.text()).toContain("Retrying...");
+  });
+});
diff --git a/frontend/src/features/publications/components/PublicationTableRow.vue b/frontend/src/features/publications/components/PublicationTableRow.vue
new file mode 100644
index 0000000..01307ff
--- /dev/null
+++ b/frontend/src/features/publications/components/PublicationTableRow.vue
@@ -0,0 +1,178 @@
+<script setup lang="ts">
+import AppBadge from "@/components/ui/AppBadge.vue";
+import type { PublicationItem } from "@/features/publications";
+
+const props = defineProps<{
+  item: PublicationItem;
+  itemKey: string;
+  selected: boolean;
+  favoriteUpdating: boolean;
+  retrying: boolean;
+  canRetry: boolean;
+}>();
+
+const emit = defineEmits<{
+  (e: "toggle-selection", event: Event): void;
+  (e: "toggle-favorite"): void;
+  (e: "retry-pdf"): void;
+}>();
+
+function primaryUrl(): string | null {
+  return props.item.pub_url || props.item.pdf_url;
+}
+
+function identifierUrl(): string | null {
+  return props.item.display_identifier?.url ?? null;
+}
+
+function identifierLabel(): string | null {
+  return props.item.display_identifier?.label ?? null;
+}
+
+function pdfPendingLabel(): string {
+  if (props.item.pdf_status === "queued") return "Queued";
+  if (props.item.pdf_status === "running") return "Resolving...";
+  if (props.item.pdf_status === "failed") return "Missing";
+  return "Untracked";
+}
+
+function formatDate(value: string): string {
+  const asDate = new Date(value);
+  if (Number.isNaN(asDate.getTime())) return value;
+  return asDate.toLocaleDateString();
+}
+</script>
+
+<template>
+  <tr>
+    <td>
+      <input
+        type="checkbox"
+        class="h-4 w-4 rounded border-stroke-interactive bg-surface-input text-brand-600 focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset"
+        :checked="selected"
+        :disabled="item.is_read"
+        :aria-label="`Select publication ${item.title}`"
+        @change="emit('toggle-selection', $event)"
+      />
+    </td>
+    <td>
+      <button
+        type="button"
+        class="favorite-star-button"
+        :class="item.is_favorite ? 'favorite-star-on' : 'favorite-star-off'"
+        :aria-label="item.is_favorite ? `Remove ${item.title} from favorites` : `Add ${item.title} to favorites`"
+        :aria-pressed="item.is_favorite"
+        :disabled="favoriteUpdating"
+        @click="emit('toggle-favorite')"
+      >
+        {{ item.is_favorite ? "★" : "☆" }}
+      </button>
+    </td>
+    <td class="max-w-0">
+      <div class="grid min-w-0 gap-1">
+        <a
+          v-if="primaryUrl()"
+          :href="primaryUrl() || ''"
+          target="_blank"
+          rel="noreferrer"
+          class="link-inline block truncate font-medium"
+          :title="item.title"
+        >
+          {{ item.title }}
+        </a>
+        <span v-else class="block truncate font-medium" :title="item.title">{{ item.title }}</span>
+        <a
+          v-if="identifierUrl()"
+          :href="identifierUrl() || ''"
+          target="_blank"
+          rel="noreferrer"
+          class="link-inline block truncate text-xs"
+          :title="identifierLabel() || ''"
+        >
+          {{ identifierLabel() }}
+        </a>
+      </div>
+    </td>
+    <td>
+      <span class="block truncate" :title="item.scholar_label">{{ item.scholar_label }}</span>
+    </td>
+    <td class="whitespace-nowrap">
+      <a
+        v-if="item.pdf_url"
+        :href="item.pdf_url"
+        target="_blank"
+        rel="noreferrer"
+        class="pdf-link-button"
+        title="Open PDF"
+      >
+        <svg class="mr-1 h-3 w-3" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+          <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14" />
+        </svg>
+        Available
+      </a>
+      <button
+        v-else-if="canRetry"
+        type="button"
+        class="pdf-retry-button"
+        :disabled="retrying"
+        @click="emit('retry-pdf')"
+      >
+        <svg v-if="retrying" class="mr-1 h-3 w-3 animate-spin" viewBox="0 0 24 24" fill="none">
+          <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+          <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+        </svg>
+        {{ retrying ? "Retrying..." : "Missing (Retry)" }}
+      </button>
+      <span v-else class="pdf-state-label" :class="{ 'bg-surface-accent-muted border-accent-300 text-accent-700': item.pdf_status === 'running' || item.pdf_status === 'queued' }">
+        <svg v-if="item.pdf_status === 'running'" class="mr-1 h-3 w-3 animate-spin text-accent-600" viewBox="0 0 24 24" fill="none">
+          <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+          <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+        </svg>
+        {{ pdfPendingLabel() }}
+      </span>
+    </td>
+    <td class="whitespace-nowrap">{{ item.year ?? "n/a" }}</td>
+    <td class="whitespace-nowrap">{{ item.citation_count }}</td>
+    <td>
+      <div class="status-badges-row">
+        <AppBadge :tone="item.is_new_in_latest_run ? 'info' : 'neutral'">
+          {{ item.is_new_in_latest_run ? "New" : "Seen" }}
+        </AppBadge>
+        <AppBadge :tone="item.is_read ? 'success' : 'warning'">
+          {{ item.is_read ? "Read" : "Unread" }}
+        </AppBadge>
+      </div>
+    </td>
+    <td class="whitespace-nowrap">{{ formatDate(item.first_seen_at) }}</td>
+  </tr>
+</template>
+
+<style scoped>
+.favorite-star-button {
+  @apply inline-flex h-7 w-7 items-center justify-center rounded-full border text-sm leading-none transition focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset disabled:cursor-not-allowed disabled:opacity-50;
+}
+
+.favorite-star-on {
+  @apply border-warning-300 bg-warning-100 text-warning-700 hover:bg-warning-200;
+}
+
+.favorite-star-off {
+  @apply border-stroke-default bg-surface-card-muted text-ink-muted hover:border-stroke-interactive hover:text-ink-secondary;
+}
+
+.pdf-link-button {
+  @apply inline-flex items-center rounded-full border px-2 py-0.5 text-xs font-medium border-state-success-border bg-state-success-bg text-state-success-text shadow-sm transition hover:brightness-95 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset;
+}
+
+.pdf-retry-button {
+  @apply inline-flex items-center rounded-full border px-2 py-0.5 text-xs font-medium border-state-warning-border bg-state-warning-bg text-state-warning-text transition hover:brightness-95 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset disabled:cursor-not-allowed disabled:opacity-50;
+}
+
+.pdf-state-label {
+  @apply inline-flex items-center rounded-full border px-2 py-0.5 text-xs font-medium border-stroke-default bg-surface-card-muted text-secondary;
+}
+
+.status-badges-row {
+  @apply inline-flex items-center gap-1 whitespace-nowrap;
+}
+</style>
diff --git a/frontend/src/features/publications/components/PublicationToolbar.test.ts b/frontend/src/features/publications/components/PublicationToolbar.test.ts
new file mode 100644
index 0000000..2d1a39c
--- /dev/null
+++ b/frontend/src/features/publications/components/PublicationToolbar.test.ts
@@ -0,0 +1,89 @@
+// @vitest-environment happy-dom
+import { describe, expect, it } from "vitest";
+import { mount } from "@vue/test-utils";
+import PublicationToolbar from "./PublicationToolbar.vue";
+
+const defaultProps = {
+  mode: "all" as const,
+  selectedScholarFilter: "",
+  searchQuery: "",
+  favoriteOnly: false,
+  actionBusy: false,
+  loading: false,
+  scholars: [],
+  startRunDisabled: false,
+  startRunDisabledReason: null,
+  startRunButtonLabel: "Check now",
+};
+
+describe("PublicationToolbar", () => {
+  it("renders mode, scholar filter, and search inputs", () => {
+    const wrapper = mount(PublicationToolbar, { props: defaultProps });
+    expect(wrapper.text()).toContain("Status");
+    expect(wrapper.text()).toContain("Scholar");
+    expect(wrapper.text()).toContain("Search");
+  });
+
+  it("renders the start run button with provided label", () => {
+    const wrapper = mount(PublicationToolbar, { props: defaultProps });
+    expect(wrapper.text()).toContain("Check now");
+  });
+
+  it("disables start run button when startRunDisabled is true", () => {
+    const wrapper = mount(PublicationToolbar, {
+      props: { ...defaultProps, startRunDisabled: true, startRunDisabledReason: "Cooldown active" },
+    });
+    const buttons = wrapper.findAll("button");
+    const runButton = buttons.find((b) => b.text().includes("Check now"));
+    expect(runButton?.attributes("disabled")).toBeDefined();
+  });
+
+  it("emits start-run when start button is clicked", async () => {
+    const wrapper = mount(PublicationToolbar, { props: defaultProps });
+    const buttons = wrapper.findAll("button");
+    const runButton = buttons.find((b) => b.text().includes("Check now"));
+    await runButton?.trigger("click");
+    expect(wrapper.emitted("start-run")).toHaveLength(1);
+  });
+
+  it("emits favorite-only-changed when star filter is clicked", async () => {
+    const wrapper = mount(PublicationToolbar, { props: defaultProps });
+    await wrapper.find(".favorite-filter-button").trigger("click");
+    expect(wrapper.emitted("favorite-only-changed")).toHaveLength(1);
+  });
+
+  it("shows active star filter style when favoriteOnly is true", () => {
+    const wrapper = mount(PublicationToolbar, { props: { ...defaultProps, favoriteOnly: true } });
+    expect(wrapper.find(".favorite-filter-on").exists()).toBe(true);
+  });
+
+  it("shows inactive star filter style when favoriteOnly is false", () => {
+    const wrapper = mount(PublicationToolbar, { props: defaultProps });
+    expect(wrapper.find(".favorite-filter-off").exists()).toBe(true);
+  });
+
+  it("renders scholar options from props", () => {
+    const scholars = [
+      { id: 1, scholar_id: "abc123", display_name: "Alice", profile_image_url: null, profile_image_source: "none" as const, is_enabled: true, baseline_completed: true, last_run_dt: null, last_run_status: null },
+      { id: 2, scholar_id: "def456", display_name: "", profile_image_url: null, profile_image_source: "none" as const, is_enabled: true, baseline_completed: true, last_run_dt: null, last_run_status: null },
+    ];
+    const wrapper = mount(PublicationToolbar, { props: { ...defaultProps, scholars } });
+    expect(wrapper.text()).toContain("Alice");
+    expect(wrapper.text()).toContain("def456");
+  });
+
+  it("shows clear button only when search query is non-empty", () => {
+    const empty = mount(PublicationToolbar, { props: defaultProps });
+    expect(empty.text()).not.toContain("Clear");
+
+    const withQuery = mount(PublicationToolbar, { props: { ...defaultProps, searchQuery: "test" } });
+    expect(withQuery.text()).toContain("Clear");
+  });
+
+  it("emits reset-search when clear button is clicked", async () => {
+    const wrapper = mount(PublicationToolbar, { props: { ...defaultProps, searchQuery: "test" } });
+    const clearButton = wrapper.findAll("button").find((b) => b.text().includes("Clear"));
+    await clearButton?.trigger("click");
+    expect(wrapper.emitted("reset-search")).toHaveLength(1);
+  });
+});
diff --git a/frontend/src/features/publications/components/PublicationToolbar.vue b/frontend/src/features/publications/components/PublicationToolbar.vue
new file mode 100644
index 0000000..4f34939
--- /dev/null
+++ b/frontend/src/features/publications/components/PublicationToolbar.vue
@@ -0,0 +1,148 @@
+<script setup lang="ts">
+import AppButton from "@/components/ui/AppButton.vue";
+import AppHelpHint from "@/components/ui/AppHelpHint.vue";
+import AppInput from "@/components/ui/AppInput.vue";
+import AppRefreshButton from "@/components/ui/AppRefreshButton.vue";
+import AppSelect from "@/components/ui/AppSelect.vue";
+import type { PublicationMode } from "@/features/publications";
+import type { ScholarProfile } from "@/features/scholars";
+
+defineProps<{
+  mode: PublicationMode;
+  selectedScholarFilter: string;
+  searchQuery: string;
+  favoriteOnly: boolean;
+  actionBusy: boolean;
+  loading: boolean;
+  scholars: ScholarProfile[];
+  startRunDisabled: boolean;
+  startRunDisabledReason: string | null;
+  startRunButtonLabel: string;
+}>();
+
+const emit = defineEmits<{
+  (e: "update:mode", value: PublicationMode): void;
+  (e: "update:selectedScholarFilter", value: string): void;
+  (e: "update:searchQuery", value: string): void;
+  (e: "mode-changed"): void;
+  (e: "scholar-filter-changed"): void;
+  (e: "favorite-only-changed"): void;
+  (e: "reset-search"): void;
+  (e: "start-run"): void;
+  (e: "refresh"): void;
+}>();
+
+function scholarLabel(item: ScholarProfile): string {
+  return item.display_name || item.scholar_id;
+}
+</script>
+
+<template>
+  <div class="grid gap-3 xl:grid-cols-[minmax(0,13rem)_minmax(0,18rem)_minmax(0,1fr)_auto] xl:items-end">
+    <div class="grid gap-1 text-xs text-secondary">
+      <div class="flex items-center gap-1">
+        <span>Status</span>
+        <AppHelpHint text="All shows full history. Unread and New narrow the dataset before search." />
+      </div>
+      <AppSelect
+        :model-value="mode"
+        :disabled="actionBusy"
+        @update:model-value="emit('update:mode', $event as PublicationMode)"
+        @change="emit('mode-changed')"
+      >
+        <option value="all">All records</option>
+        <option value="unread">Unread</option>
+        <option value="latest">New (latest run)</option>
+      </AppSelect>
+    </div>
+
+    <label class="grid gap-1 text-xs text-secondary" for="publications-scholar-filter">
+      <span class="inline-flex items-center gap-1">
+        Scholar
+        <AppHelpHint text="Filter to one tracked scholar profile. Filter is synced to URL query." />
+      </span>
+      <AppSelect
+        id="publications-scholar-filter"
+        :model-value="selectedScholarFilter"
+        :disabled="actionBusy"
+        @update:model-value="emit('update:selectedScholarFilter', $event as string)"
+        @change="emit('scholar-filter-changed')"
+      >
+        <option value="">All scholars</option>
+        <option v-for="scholar in scholars" :key="scholar.id" :value="String(scholar.id)">
+          {{ scholarLabel(scholar) }}
+        </option>
+      </AppSelect>
+    </label>
+
+    <label class="grid gap-1 text-xs text-secondary" for="publications-search-input">
+      <span class="inline-flex items-center gap-1">
+        Search
+        <AppHelpHint text="Searches title, scholar name, and venue." />
+      </span>
+      <div class="flex min-w-0 items-center gap-2">
+        <AppInput
+          id="publications-search-input"
+          :model-value="searchQuery"
+          placeholder="Search title, scholar, venue, year"
+          :disabled="loading"
+          @update:model-value="emit('update:searchQuery', $event as string)"
+        />
+        <AppButton
+          v-if="searchQuery.trim().length > 0"
+          variant="secondary"
+          class="shrink-0"
+          :disabled="loading"
+          @click="emit('reset-search')"
+        >
+          Clear
+        </AppButton>
+      </div>
+    </label>
+
+    <div class="flex flex-wrap items-end justify-end gap-2">
+      <button
+        type="button"
+        class="favorite-filter-button"
+        :class="favoriteOnly ? 'favorite-filter-on' : 'favorite-filter-off'"
+        :disabled="actionBusy"
+        :title="favoriteOnly ? 'Favorites-only filter is active' : 'Show only favorites'"
+        :aria-pressed="favoriteOnly"
+        :aria-label="favoriteOnly ? 'Disable favorites-only filter' : 'Enable favorites-only filter'"
+        @click="emit('favorite-only-changed')"
+      >
+        <span aria-hidden="true">{{ favoriteOnly ? "★" : "☆" }}</span>
+      </button>
+      <AppButton
+        variant="secondary"
+        :disabled="startRunDisabled"
+        :title="startRunDisabledReason || undefined"
+        @click="emit('start-run')"
+      >
+        {{ startRunButtonLabel }}
+      </AppButton>
+      <AppRefreshButton
+        variant="ghost"
+        :disabled="loading"
+        :loading="loading"
+        title="Refresh publications"
+        loading-title="Refreshing publications"
+        @click="emit('refresh')"
+      />
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.favorite-filter-button {
+  @apply inline-flex min-h-10 h-10 w-10 items-center justify-center rounded-full border text-base leading-none transition focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset disabled:cursor-not-allowed disabled:opacity-50;
+}
+
+.favorite-filter-on {
+  @apply border-warning-300 bg-warning-100 text-warning-700 hover:bg-warning-200;
+}
+
+.favorite-filter-off {
+  @apply border-stroke-default bg-surface-card-muted text-ink-muted hover:border-stroke-interactive hover:text-ink-secondary;
+}
+</style>
diff --git a/frontend/src/features/publications/composables/usePublicationData.test.ts b/frontend/src/features/publications/composables/usePublicationData.test.ts
new file mode 100644
index 0000000..e06d9c7
--- /dev/null
+++ b/frontend/src/features/publications/composables/usePublicationData.test.ts
@@ -0,0 +1,118 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { createPinia, setActivePinia } from "pinia";
+
+vi.mock("vue-router", () => ({
+  useRoute: vi.fn(() => ({ query: {} })),
+  useRouter: vi.fn(() => ({ replace: vi.fn() })),
+}));
+
+vi.mock("@/features/publications", async (importOriginal) => {
+  const original = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...original,
+    listPublications: vi.fn(),
+  };
+});
+
+vi.mock("@/features/scholars", () => ({
+  listScholars: vi.fn(),
+}));
+
+import { listPublications } from "@/features/publications";
+import { listScholars } from "@/features/scholars";
+import { usePublicationData } from "./usePublicationData";
+
+const mockedListPublications = vi.mocked(listPublications);
+const mockedListScholars = vi.mocked(listScholars);
+
+describe("usePublicationData", () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+    mockedListPublications.mockReset();
+    mockedListScholars.mockReset();
+  });
+
+  it("initializes with default filter values", () => {
+    const data = usePublicationData();
+    expect(data.mode.value).toBe("all");
+    expect(data.favoriteOnly.value).toBe(false);
+    expect(data.searchQuery.value).toBe("");
+    expect(data.selectedScholarFilter.value).toBe("");
+    expect(data.loading.value).toBe(true);
+  });
+
+  it("loadScholarFilters calls listScholars", async () => {
+    mockedListScholars.mockResolvedValueOnce([
+      { id: 1, scholar_id: "abc", display_name: "Test", profile_image_url: null, profile_image_source: "none" as const, is_enabled: true, baseline_completed: true, last_run_dt: null, last_run_status: null },
+    ]);
+    const data = usePublicationData();
+    await data.loadScholarFilters();
+    expect(mockedListScholars).toHaveBeenCalled();
+    expect(data.scholars.value).toHaveLength(1);
+  });
+
+  it("loadPublications calls listPublications with current filters", async () => {
+    mockedListPublications.mockResolvedValueOnce({
+      publications: [],
+      mode: "all" as const,
+      favorite_only: false,
+      selected_scholar_profile_id: null,
+      unread_count: 0,
+      favorites_count: 0,
+      latest_count: 0,
+      new_count: 0,
+      total_count: 0,
+      page: 1,
+      page_size: 25,
+      snapshot: "",
+      has_next: false,
+      has_prev: false,
+    });
+    const data = usePublicationData();
+    await data.loadPublications();
+    expect(mockedListPublications).toHaveBeenCalled();
+  });
+
+  it("resetPageAndSnapshot resets page to 1", () => {
+    const data = usePublicationData();
+    data.currentPage.value = 5;
+    data.resetPageAndSnapshot();
+    expect(data.currentPage.value).toBe(1);
+  });
+
+  it("toggleSort reverses direction for same key", async () => {
+    mockedListPublications.mockResolvedValue({
+      publications: [],
+      mode: "all" as const,
+      favorite_only: false,
+      selected_scholar_profile_id: null,
+      unread_count: 0,
+      favorites_count: 0,
+      latest_count: 0,
+      new_count: 0,
+      total_count: 0,
+      page: 1,
+      page_size: 25,
+      snapshot: "",
+      has_next: false,
+      has_prev: false,
+    });
+    const data = usePublicationData();
+    const initialDirection = data.sortDirection.value;
+    await data.toggleSort(data.sortKey.value);
+    expect(data.sortDirection.value).toBe(initialDirection === "asc" ? "desc" : "asc");
+  });
+
+  it("sortMarker returns arrow indicators", () => {
+    const data = usePublicationData();
+    expect(data.sortMarker(data.sortKey.value)).toMatch(/[↑↓]/);
+    expect(data.sortMarker("year" as never)).toBe("↕");
+  });
+
+  it("computed pagination properties work correctly", () => {
+    const data = usePublicationData();
+    expect(data.hasPrevPage.value).toBe(false);
+    expect(data.totalPages.value).toBe(1);
+    expect(data.totalCount.value).toBe(0);
+  });
+});
diff --git a/frontend/src/features/publications/composables/usePublicationData.ts b/frontend/src/features/publications/composables/usePublicationData.ts
new file mode 100644
index 0000000..e48209e
--- /dev/null
+++ b/frontend/src/features/publications/composables/usePublicationData.ts
@@ -0,0 +1,338 @@
+import { computed, ref, watch } from "vue";
+import { useRoute, useRouter } from "vue-router";
+import {
+  listPublications,
+  type PublicationItem,
+  type PublicationMode,
+  type PublicationsResult,
+} from "@/features/publications";
+import { listScholars, type ScholarProfile } from "@/features/scholars";
+import { ApiRequestError } from "@/lib/api/errors";
+import { useRunStatusStore } from "@/stores/run_status";
+
+export type PublicationSortKey =
+  | "title"
+  | "scholar"
+  | "year"
+  | "citations"
+  | "first_seen"
+  | "pdf_status";
+
+export function publicationKey(item: PublicationItem): string {
+  return `${item.scholar_profile_id}:${item.publication_id}`;
+}
+
+export function usePublicationData() {
+  const loading = ref(true);
+  const mode = ref<PublicationMode>("all");
+  const favoriteOnly = ref(false);
+  const selectedScholarFilter = ref("");
+  const searchQuery = ref("");
+  const sortKey = ref<PublicationSortKey>("first_seen");
+  const sortDirection = ref<"asc" | "desc">("desc");
+  const currentPage = ref(1);
+  const pageSize = ref("50");
+  const publicationSnapshot = ref<string | null>(null);
+
+  const scholars = ref<ScholarProfile[]>([]);
+  const listState = ref<PublicationsResult | null>(null);
+
+  const errorMessage = ref<string | null>(null);
+  const errorRequestId = ref<string | null>(null);
+  const successMessage = ref<string | null>(null);
+  const route = useRoute();
+  const router = useRouter();
+  const textCollator = new Intl.Collator(undefined, { sensitivity: "base", numeric: true });
+  const runStatus = useRunStatusStore();
+
+  // --- Route sync ---
+
+  function normalizeScholarFilterQuery(value: unknown): string {
+    if (Array.isArray(value)) return normalizeScholarFilterQuery(value[0]);
+    if (typeof value !== "string") return "";
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? String(parsed) : "";
+  }
+
+  function normalizeFavoriteOnlyQuery(value: unknown): boolean {
+    if (Array.isArray(value)) return normalizeFavoriteOnlyQuery(value[0]);
+    if (typeof value !== "string") return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+  }
+
+  function normalizePageQuery(value: unknown): number {
+    if (Array.isArray(value)) return normalizePageQuery(value[0]);
+    if (typeof value !== "string") return 1;
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : 1;
+  }
+
+  function syncFiltersFromRoute(): boolean {
+    let changed = false;
+    const nextScholar = normalizeScholarFilterQuery(route.query.scholar);
+    const nextFavoriteOnly = normalizeFavoriteOnlyQuery(route.query.favorite);
+    const nextPage = normalizePageQuery(route.query.page);
+    if (selectedScholarFilter.value !== nextScholar) { selectedScholarFilter.value = nextScholar; changed = true; }
+    if (favoriteOnly.value !== nextFavoriteOnly) { favoriteOnly.value = nextFavoriteOnly; changed = true; }
+    if (currentPage.value !== nextPage) { currentPage.value = nextPage; changed = true; }
+    return changed;
+  }
+
+  async function syncFiltersToRoute(): Promise<void> {
+    const nextScholar = selectedScholarFilter.value.trim();
+    const currentScholar = normalizeScholarFilterQuery(route.query.scholar);
+    const currentFavoriteOnly = normalizeFavoriteOnlyQuery(route.query.favorite);
+    const currentPageQuery = normalizePageQuery(route.query.page);
+    if (
+      nextScholar === currentScholar
+      && favoriteOnly.value === currentFavoriteOnly
+      && currentPage.value === currentPageQuery
+    ) {
+      return;
+    }
+    await router.replace({
+      query: {
+        ...route.query,
+        scholar: nextScholar || undefined,
+        favorite: favoriteOnly.value ? "1" : undefined,
+        page: currentPage.value > 1 ? String(currentPage.value) : undefined,
+      },
+    });
+  }
+
+  // --- Sorting helpers ---
+
+  function publicationSortValue(item: PublicationItem, key: PublicationSortKey): number | string {
+    if (key === "title") return item.title;
+    if (key === "scholar") return item.scholar_label;
+    if (key === "year") return item.year ?? -1;
+    if (key === "citations") return item.citation_count;
+    if (key === "pdf_status") {
+      if (item.pdf_url || item.pdf_status === "resolved") return 4;
+      if (item.pdf_status === "running") return 3;
+      if (item.pdf_status === "queued") return 2;
+      if (item.pdf_status === "failed") return 0;
+      return 1;
+    }
+    const timestamp = Date.parse(item.first_seen_at);
+    return Number.isNaN(timestamp) ? 0 : timestamp;
+  }
+
+  // --- Computed ---
+
+  const selectedScholarName = computed(() => {
+    const selectedId = Number(selectedScholarFilter.value);
+    if (!Number.isInteger(selectedId) || selectedId <= 0) return "all scholars";
+    const profile = scholars.value.find((item) => item.id === selectedId);
+    return profile ? (profile.display_name || profile.scholar_id) : "the selected scholar";
+  });
+
+  const filteredPublications = computed(() => {
+    let stream = [...runStatus.livePublications];
+    if (favoriteOnly.value) stream = stream.filter((p) => p.is_favorite);
+    if (mode.value === "unread") stream = stream.filter((p) => !p.is_read);
+    const selectedScholarId = Number(selectedScholarFilter.value);
+    if (Number.isInteger(selectedScholarId) && selectedScholarId > 0) {
+      stream = stream.filter((p) => p.scholar_profile_id === selectedScholarId);
+    }
+    const base = listState.value?.publications ?? [];
+    const merged = [...stream, ...base];
+    const seenKeys = new Set<string>();
+    const deduped: typeof base = [];
+    for (const item of merged) {
+      const key = publicationKey(item);
+      if (!seenKeys.has(key)) { seenKeys.add(key); deduped.push(item); }
+    }
+    return deduped;
+  });
+
+  const sortedPublications = computed(() => {
+    const direction = sortDirection.value === "asc" ? 1 : -1;
+    return [...filteredPublications.value].sort((left, right) => {
+      const leftValue = publicationSortValue(left, sortKey.value);
+      const rightValue = publicationSortValue(right, sortKey.value);
+      let comparison = 0;
+      if (typeof leftValue === "string" && typeof rightValue === "string") {
+        comparison = textCollator.compare(leftValue, rightValue);
+      } else {
+        comparison = Number(leftValue) - Number(rightValue);
+      }
+      if (comparison !== 0) return comparison * direction;
+      return right.publication_id - left.publication_id;
+    });
+  });
+
+  const visibleUnreadKeys = computed(() => {
+    const keys = new Set<string>();
+    for (const item of sortedPublications.value) {
+      if (!item.is_read) keys.add(publicationKey(item));
+    }
+    return keys;
+  });
+
+  const pageSizeValue = computed(() => {
+    const parsed = Number(pageSize.value);
+    if (!Number.isInteger(parsed)) return 50;
+    return Math.max(10, Math.min(200, parsed));
+  });
+  const hasNextPage = computed(() => Boolean(listState.value?.has_next));
+  const hasPrevPage = computed(() => Boolean(listState.value?.has_prev));
+  const totalPages = computed(() => {
+    if (!listState.value) return 1;
+    return Math.max(1, Math.ceil(listState.value.total_count / Math.max(listState.value.page_size, 1)));
+  });
+  const totalCount = computed(() => listState.value?.total_count ?? 0);
+  const visibleCount = computed(() => sortedPublications.value.length);
+  const visibleUnreadCount = computed(() => visibleUnreadKeys.value.size);
+  const visibleFavoriteCount = computed(
+    () => sortedPublications.value.filter((item) => item.is_favorite).length,
+  );
+
+  // --- Data loading ---
+
+  async function loadScholarFilters(): Promise<void> {
+    try { scholars.value = await listScholars(); } catch { scholars.value = []; }
+  }
+
+  function selectedScholarId(): number | undefined {
+    const parsed = Number(selectedScholarFilter.value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+  }
+
+  async function loadPublications(): Promise<void> {
+    loading.value = true;
+    errorMessage.value = null;
+    errorRequestId.value = null;
+    try {
+      listState.value = await listPublications({
+        mode: mode.value,
+        favoriteOnly: favoriteOnly.value,
+        scholarProfileId: selectedScholarId(),
+        search: searchQuery.value.trim() || undefined,
+        sortBy: sortKey.value,
+        sortDir: sortDirection.value,
+        page: currentPage.value,
+        pageSize: pageSizeValue.value,
+        snapshot: publicationSnapshot.value ?? undefined,
+      });
+      publicationSnapshot.value = listState.value.snapshot;
+      currentPage.value = listState.value.page;
+      pageSize.value = String(listState.value.page_size);
+    } catch (error) {
+      listState.value = null;
+      if (error instanceof ApiRequestError) {
+        errorMessage.value = error.message;
+        errorRequestId.value = error.requestId;
+      } else {
+        errorMessage.value = "Unable to load publications.";
+      }
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  function resetPageAndSnapshot(): void {
+    currentPage.value = 1;
+    publicationSnapshot.value = null;
+  }
+
+  async function toggleSort(nextKey: PublicationSortKey): Promise<void> {
+    if (sortKey.value === nextKey) {
+      sortDirection.value = sortDirection.value === "asc" ? "desc" : "asc";
+    } else {
+      sortKey.value = nextKey;
+      sortDirection.value = nextKey === "first_seen" || nextKey === "pdf_status" ? "desc" : "asc";
+    }
+    resetPageAndSnapshot();
+    await loadPublications();
+  }
+
+  function sortMarker(key: PublicationSortKey): string {
+    if (sortKey.value !== key) return "↕";
+    return sortDirection.value === "asc" ? "↑" : "↓";
+  }
+
+  function replacePublication(updated: PublicationItem): void {
+    if (!listState.value) return;
+    listState.value.publications = listState.value.publications.map((item) =>
+      publicationKey(item) !== publicationKey(updated) ? item : updated,
+    );
+  }
+
+  // --- Search debounce watcher setup ---
+
+  let searchDebounceTimer: ReturnType<typeof setTimeout> | null = null;
+  watch(searchQuery, () => {
+    if (searchDebounceTimer !== null) clearTimeout(searchDebounceTimer);
+    searchDebounceTimer = setTimeout(() => {
+      resetPageAndSnapshot();
+      void loadPublications();
+    }, 300);
+  });
+
+  // --- Run-triggered refresh watcher ---
+
+  watch(
+    () => runStatus.latestRun,
+    async (nextRun, previousRun) => {
+      const nextRunId = nextRun && (nextRun.status === "running" || nextRun.status === "resolving") ? nextRun.id : null;
+      const previousRunId = previousRun && (previousRun.status === "running" || previousRun.status === "resolving") ? previousRun.id : null;
+      if (nextRunId === null || nextRunId === previousRunId) return;
+      resetPageAndSnapshot();
+      await loadPublications();
+    },
+  );
+
+  // --- Route watcher ---
+
+  watch(
+    () => [route.query.scholar, route.query.favorite, route.query.page],
+    async () => {
+      const previousScholar = selectedScholarFilter.value;
+      const previousFavorite = favoriteOnly.value;
+      const changed = syncFiltersFromRoute();
+      if (!changed) return;
+      if (selectedScholarFilter.value !== previousScholar || favoriteOnly.value !== previousFavorite) {
+        publicationSnapshot.value = null;
+      }
+      await loadPublications();
+    },
+  );
+
+  return {
+    loading,
+    mode,
+    favoriteOnly,
+    selectedScholarFilter,
+    searchQuery,
+    sortKey,
+    sortDirection,
+    currentPage,
+    pageSize,
+    scholars,
+    listState,
+    errorMessage,
+    errorRequestId,
+    successMessage,
+    selectedScholarName,
+    sortedPublications,
+    visibleUnreadKeys,
+    pageSizeValue,
+    hasNextPage,
+    hasPrevPage,
+    totalPages,
+    totalCount,
+    visibleCount,
+    visibleUnreadCount,
+    visibleFavoriteCount,
+    loadScholarFilters,
+    loadPublications,
+    resetPageAndSnapshot,
+    toggleSort,
+    sortMarker,
+    replacePublication,
+    syncFiltersFromRoute,
+    syncFiltersToRoute,
+  };
+}
diff --git a/frontend/src/features/scholars/components/ScholarBatchAdd.test.ts b/frontend/src/features/scholars/components/ScholarBatchAdd.test.ts
new file mode 100644
index 0000000..2d76eac
--- /dev/null
+++ b/frontend/src/features/scholars/components/ScholarBatchAdd.test.ts
@@ -0,0 +1,76 @@
+// @vitest-environment happy-dom
+import { describe, expect, it } from "vitest";
+import { mount } from "@vue/test-utils";
+import ScholarBatchAdd from "./ScholarBatchAdd.vue";
+
+const defaultProps = { saving: false, loading: false };
+
+describe("ScholarBatchAdd", () => {
+  it("renders the heading and input", () => {
+    const wrapper = mount(ScholarBatchAdd, { props: defaultProps });
+    expect(wrapper.text()).toContain("Add Scholar Profiles");
+    expect(wrapper.find("textarea").exists()).toBe(true);
+  });
+
+  it("shows parsed ID count as 0 for empty input", () => {
+    const wrapper = mount(ScholarBatchAdd, { props: defaultProps });
+    expect(wrapper.text()).toContain("Parsed IDs:");
+  });
+
+  it("parses bare scholar IDs from textarea input", async () => {
+    const wrapper = mount(ScholarBatchAdd, { props: defaultProps });
+    await wrapper.find("textarea").setValue("A-UbBTPM15wL");
+    expect(wrapper.text()).toContain("1");
+  });
+
+  it("parses scholar IDs from Google Scholar URLs", async () => {
+    const wrapper = mount(ScholarBatchAdd, { props: defaultProps });
+    await wrapper.find("textarea").setValue(
+      "https://scholar.google.com/citations?hl=en&user=A-UbBTPM15wL",
+    );
+    expect(wrapper.text()).toContain("1");
+  });
+
+  it("deduplicates IDs from mixed input", async () => {
+    const wrapper = mount(ScholarBatchAdd, { props: defaultProps });
+    await wrapper.find("textarea").setValue(
+      "A-UbBTPM15wL\nhttps://scholar.google.com/citations?user=A-UbBTPM15wL",
+    );
+    expect(wrapper.text()).toContain("1");
+  });
+
+  it("parses multiple IDs separated by commas", async () => {
+    const wrapper = mount(ScholarBatchAdd, { props: defaultProps });
+    await wrapper.find("textarea").setValue("A-UbBTPM15wL, B-UbBTPM15wL");
+    expect(wrapper.text()).toContain("2");
+  });
+
+  it("emits add-scholars with parsed IDs on submit", async () => {
+    const wrapper = mount(ScholarBatchAdd, { props: defaultProps });
+    await wrapper.find("textarea").setValue("A-UbBTPM15wL");
+    await wrapper.find("form").trigger("submit");
+    const emitted = wrapper.emitted("add-scholars");
+    expect(emitted).toHaveLength(1);
+    expect(emitted![0][0]).toEqual(["A-UbBTPM15wL"]);
+  });
+
+  it("clears textarea after successful submit", async () => {
+    const wrapper = mount(ScholarBatchAdd, { props: defaultProps });
+    const textarea = wrapper.find("textarea");
+    await textarea.setValue("A-UbBTPM15wL");
+    await wrapper.find("form").trigger("submit");
+    expect((textarea.element as HTMLTextAreaElement).value).toBe("");
+  });
+
+  it("does not emit when input contains no valid IDs", async () => {
+    const wrapper = mount(ScholarBatchAdd, { props: defaultProps });
+    await wrapper.find("textarea").setValue("not-a-valid-id");
+    await wrapper.find("form").trigger("submit");
+    expect(wrapper.emitted("add-scholars")).toBeUndefined();
+  });
+
+  it("shows Adding... label when saving prop is true", () => {
+    const wrapper = mount(ScholarBatchAdd, { props: { ...defaultProps, saving: true } });
+    expect(wrapper.text()).toContain("Adding...");
+  });
+});
diff --git a/frontend/src/features/scholars/components/ScholarBatchAdd.vue b/frontend/src/features/scholars/components/ScholarBatchAdd.vue
new file mode 100644
index 0000000..bfafbda
--- /dev/null
+++ b/frontend/src/features/scholars/components/ScholarBatchAdd.vue
@@ -0,0 +1,89 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import AppButton from "@/components/ui/AppButton.vue";
+import AppCard from "@/components/ui/AppCard.vue";
+import AppHelpHint from "@/components/ui/AppHelpHint.vue";
+
+defineProps<{
+  saving: boolean;
+  loading: boolean;
+}>();
+
+const emit = defineEmits<{
+  (e: "add-scholars", ids: string[]): void;
+}>();
+
+const scholarBatchInput = ref("");
+
+const SCHOLAR_ID_PATTERN = /^[a-zA-Z0-9_-]{12}$/;
+const URL_USER_PARAM_PATTERN = /(?:\?|&)user=([a-zA-Z0-9_-]{12})(?:&|#|$)/i;
+
+function parseScholarIds(raw: string): string[] {
+  const ordered: string[] = [];
+  const seen = new Set<string>();
+  const tokens = raw.split(/[\s,;]+/).map((v) => v.trim()).filter((v) => v.length > 0);
+  for (const token of tokens) {
+    let candidate: string | null = null;
+    if (SCHOLAR_ID_PATTERN.test(token)) candidate = token;
+    if (!candidate) {
+      const directParamMatch = token.match(URL_USER_PARAM_PATTERN);
+      if (directParamMatch) candidate = directParamMatch[1];
+    }
+    if (!candidate && token.includes("scholar.google")) {
+      try {
+        const parsed = new URL(token);
+        const userParam = parsed.searchParams.get("user");
+        if (userParam && SCHOLAR_ID_PATTERN.test(userParam)) candidate = userParam;
+      } catch (_error) { /* Ignore non-URL tokens. */ }
+    }
+    if (!candidate || seen.has(candidate)) continue;
+    seen.add(candidate);
+    ordered.push(candidate);
+  }
+  return ordered;
+}
+
+const parsedBatchCount = computed(() => parseScholarIds(scholarBatchInput.value).length);
+
+function onSubmit(): void {
+  const ids = parseScholarIds(scholarBatchInput.value);
+  if (ids.length > 0) {
+    emit("add-scholars", ids);
+    scholarBatchInput.value = "";
+  }
+}
+</script>
+
+<template>
+  <AppCard class="space-y-4 xl:flex xl:min-h-0 xl:flex-col">
+    <div class="space-y-1">
+      <div class="flex items-center gap-1">
+        <h2 class="text-lg font-semibold text-ink-primary">Add Scholar Profiles</h2>
+        <AppHelpHint text="A scholar profile is a Google Scholar author page that Scholarr will monitor for publication changes." />
+      </div>
+      <p class="text-sm text-secondary">Paste one or more Scholar IDs or profile URLs and add them in one action.</p>
+    </div>
+
+    <form class="grid gap-3" @submit.prevent="onSubmit">
+      <label class="grid gap-2 text-sm font-medium text-ink-secondary" for="scholar-batch-input">
+        <span>Scholar IDs or profile URLs</span>
+        <textarea
+          id="scholar-batch-input"
+          v-model="scholarBatchInput"
+          rows="5"
+          placeholder="A-UbBTPM15wL&#10;https://scholar.google.com/citations?hl=en&user=A-UbBTPM15wL"
+          class="w-full rounded-lg border border-stroke-interactive bg-surface-input px-3 py-2 text-sm text-ink-primary outline-none ring-focus-ring transition placeholder:text-ink-muted focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset disabled:cursor-not-allowed disabled:opacity-60"
+        />
+      </label>
+
+      <div class="flex flex-wrap items-center justify-between gap-2">
+        <p class="text-xs text-secondary">
+          Parsed IDs: <strong class="text-ink-primary">{{ parsedBatchCount }}</strong>
+        </p>
+        <AppButton type="submit" :disabled="saving || loading">
+          {{ saving ? "Adding..." : "Add scholars" }}
+        </AppButton>
+      </div>
+    </form>
+  </AppCard>
+</template>
diff --git a/frontend/src/features/scholars/components/ScholarNameSearch.test.ts b/frontend/src/features/scholars/components/ScholarNameSearch.test.ts
new file mode 100644
index 0000000..56873f1
--- /dev/null
+++ b/frontend/src/features/scholars/components/ScholarNameSearch.test.ts
@@ -0,0 +1,43 @@
+// @vitest-environment happy-dom
+import { describe, expect, it } from "vitest";
+import { mount } from "@vue/test-utils";
+import ScholarNameSearch from "./ScholarNameSearch.vue";
+
+const defaultProps = {
+  trackedScholarIds: new Set<string>(),
+  addingCandidateScholarId: null,
+};
+
+describe("ScholarNameSearch", () => {
+  it("renders the search heading", () => {
+    const wrapper = mount(ScholarNameSearch, {
+      props: defaultProps,
+      global: { stubs: { ScholarAvatar: true } },
+    });
+    expect(wrapper.text()).toContain("Search by Name");
+  });
+
+  it("shows WIP badge indicating the feature is incomplete", () => {
+    const wrapper = mount(ScholarNameSearch, {
+      props: defaultProps,
+      global: { stubs: { ScholarAvatar: true } },
+    });
+    expect(wrapper.text()).toContain("WIP");
+  });
+
+  it("renders the search input", () => {
+    const wrapper = mount(ScholarNameSearch, {
+      props: defaultProps,
+      global: { stubs: { ScholarAvatar: true } },
+    });
+    expect(wrapper.find("form").exists()).toBe(true);
+  });
+
+  it("shows warning about Google Scholar login challenges", () => {
+    const wrapper = mount(ScholarNameSearch, {
+      props: defaultProps,
+      global: { stubs: { ScholarAvatar: true } },
+    });
+    expect(wrapper.text()).toContain("login challenge");
+  });
+});
diff --git a/frontend/src/features/scholars/components/ScholarNameSearch.vue b/frontend/src/features/scholars/components/ScholarNameSearch.vue
new file mode 100644
index 0000000..4a82af2
--- /dev/null
+++ b/frontend/src/features/scholars/components/ScholarNameSearch.vue
@@ -0,0 +1,167 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import AsyncStateGate from "@/components/patterns/AsyncStateGate.vue";
+import RequestStateAlerts from "@/components/patterns/RequestStateAlerts.vue";
+import AppAlert from "@/components/ui/AppAlert.vue";
+import AppBadge from "@/components/ui/AppBadge.vue";
+import AppButton from "@/components/ui/AppButton.vue";
+import AppCard from "@/components/ui/AppCard.vue";
+import AppHelpHint from "@/components/ui/AppHelpHint.vue";
+import AppInput from "@/components/ui/AppInput.vue";
+import ScholarAvatar from "@/features/scholars/components/ScholarAvatar.vue";
+import type { ScholarSearchCandidate, ScholarSearchResult } from "@/features/scholars";
+
+defineProps<{
+  trackedScholarIds: Set<string>;
+  addingCandidateScholarId: string | null;
+}>();
+
+const emit = defineEmits<{
+  (e: "add-candidate", candidate: ScholarSearchCandidate): void;
+}>();
+
+const nameSearchWip = true;
+const searchingByName = ref(false);
+const searchQuery = ref("");
+const searchResult = ref<ScholarSearchResult | null>(null);
+const searchErrorMessage = ref<string | null>(null);
+const searchErrorRequestId = ref<string | null>(null);
+
+const searchHasRun = computed(() => searchResult.value !== null);
+const searchIsDegraded = computed(() => {
+  if (!searchResult.value) return false;
+  return searchResult.value.state === "blocked_or_captcha" || searchResult.value.state === "network_error";
+});
+const searchStateTone = computed(() => {
+  const result = searchResult.value;
+  if (!result) return "neutral" as const;
+  if (result.state === "ok") return "success" as const;
+  if (result.state === "blocked_or_captcha" || result.state === "network_error") return "warning" as const;
+  return "neutral" as const;
+});
+const emptySearchCandidates = computed(() => {
+  const result = searchResult.value;
+  if (!result) return false;
+  return result.candidates.length === 0;
+});
+</script>
+
+<template>
+  <AppCard class="relative space-y-4 select-none xl:flex xl:min-h-0 xl:flex-col xl:overflow-hidden">
+    <div class="flex flex-wrap items-start justify-between gap-2">
+      <div class="space-y-1">
+        <div class="flex items-center gap-1">
+          <h2 class="text-lg font-semibold text-ink-primary">Search by Name</h2>
+          <AppHelpHint text="Google Scholar now challenges this endpoint with account login and anti-bot checks, so this workflow stays disabled." />
+        </div>
+        <p class="text-sm text-secondary">
+          This helper remains paused because Google Scholar currently requires account login for reliable name search access.
+        </p>
+      </div>
+      <AppHelpHint text="Name search is kept as WIP. Use direct Scholar ID or profile URL adds for production tracking.">
+        <template #trigger>
+          <AppBadge tone="warning">WIP</AppBadge>
+        </template>
+      </AppHelpHint>
+    </div>
+
+    <form class="pointer-events-none flex flex-wrap items-center gap-2 opacity-60">
+      <div class="min-w-0 flex-1">
+        <AppInput
+          id="scholar-search-name"
+          v-model="searchQuery"
+          placeholder="e.g. Geoffrey Hinton"
+          :disabled="nameSearchWip"
+        />
+      </div>
+      <AppButton type="button" :disabled="nameSearchWip">
+        Search
+      </AppButton>
+    </form>
+    <p class="text-xs text-secondary">
+      Direct Scholar ID/URL adds above are the supported path until name search can run without login challenges.
+    </p>
+
+    <div class="min-h-0 xl:flex-1 xl:overflow-y-auto xl:pr-1">
+      <RequestStateAlerts
+        :error-message="searchErrorMessage"
+        :error-request-id="searchErrorRequestId"
+        error-title="Search request failed"
+      />
+
+      <AsyncStateGate :loading="searchingByName" :loading-lines="4" :show-empty="false">
+        <template v-if="searchResult">
+          <div class="flex flex-wrap items-center justify-between gap-2">
+            <p class="text-sm text-secondary">
+              {{ searchResult.candidates.length }} candidate{{ searchResult.candidates.length === 1 ? "" : "s" }}
+              for <strong class="text-ink-primary">{{ searchResult.query }}</strong>
+            </p>
+            <AppBadge :tone="searchStateTone">{{ searchResult.state }}</AppBadge>
+          </div>
+
+          <p v-if="searchResult.state !== 'ok' || searchResult.warnings.length > 0" class="text-xs text-secondary">
+            <span>State reason: <code>{{ searchResult.state_reason }}</code></span>
+            <span v-if="searchResult.action_hint">. {{ searchResult.action_hint }}</span>
+            <span v-if="searchResult.warnings.length > 0">. Warnings: {{ searchResult.warnings.join(", ") }}</span>
+          </p>
+
+          <AppAlert v-if="searchIsDegraded" tone="warning">
+            <template #title>Name search is degraded</template>
+            <p>This endpoint throttles aggressively to avoid blocks. Use Scholar URL/ID adds for dependable tracking.</p>
+          </AppAlert>
+
+          <AsyncStateGate
+            :loading="false"
+            :show-empty="true"
+            :empty="emptySearchCandidates"
+            empty-title="No scholar matches returned"
+            empty-body="Try another query later or add directly by Scholar URL/ID."
+          >
+            <ul class="grid gap-3">
+              <li
+                v-for="candidate in searchResult.candidates"
+                :key="candidate.scholar_id"
+                class="rounded-xl border border-stroke-default bg-surface-card-muted/70 p-3"
+              >
+                <div class="flex items-start gap-3">
+                  <ScholarAvatar
+                    size="sm"
+                    :label="candidate.display_name"
+                    :scholar-id="candidate.scholar_id"
+                    :image-url="candidate.profile_image_url"
+                  />
+                  <div class="min-w-0 flex-1 space-y-1">
+                    <div class="flex flex-wrap items-center gap-2">
+                      <strong class="text-sm text-ink-primary">{{ candidate.display_name }}</strong>
+                      <code class="text-xs text-secondary">{{ candidate.scholar_id }}</code>
+                      <AppBadge v-if="trackedScholarIds.has(candidate.scholar_id)" tone="success">Tracked</AppBadge>
+                    </div>
+                    <p class="truncate text-xs text-secondary">{{ candidate.affiliation || "No affiliation provided" }}</p>
+                    <div class="flex flex-wrap items-center gap-2 text-xs text-secondary">
+                      <span v-if="candidate.email_domain">Email: {{ candidate.email_domain }}</span>
+                      <span v-if="candidate.cited_by_count !== null">Cited by: {{ candidate.cited_by_count }}</span>
+                    </div>
+                  </div>
+                  <div class="grid shrink-0 gap-2">
+                    <AppButton
+                      :disabled="trackedScholarIds.has(candidate.scholar_id) || addingCandidateScholarId === candidate.scholar_id"
+                      @click="emit('add-candidate', candidate)"
+                    >
+                      {{ addingCandidateScholarId === candidate.scholar_id ? "Adding..." : "Add" }}
+                    </AppButton>
+                    <a :href="candidate.profile_url" target="_blank" rel="noreferrer" class="link-inline text-xs text-center">
+                      Open profile
+                    </a>
+                  </div>
+                </div>
+              </li>
+            </ul>
+          </AsyncStateGate>
+        </template>
+        <p v-else-if="!searchErrorMessage && !searchHasRun" class="text-sm text-secondary">
+          Name search remains disabled while login-gated responses are unresolved.
+        </p>
+      </AsyncStateGate>
+    </div>
+  </AppCard>
+</template>
diff --git a/frontend/src/features/scholars/components/ScholarSettingsModal.test.ts b/frontend/src/features/scholars/components/ScholarSettingsModal.test.ts
new file mode 100644
index 0000000..6a3830b
--- /dev/null
+++ b/frontend/src/features/scholars/components/ScholarSettingsModal.test.ts
@@ -0,0 +1,92 @@
+// @vitest-environment happy-dom
+import { describe, expect, it } from "vitest";
+import { mount } from "@vue/test-utils";
+import ScholarSettingsModal from "./ScholarSettingsModal.vue";
+import type { ScholarProfile } from "@/features/scholars";
+
+function buildScholar(overrides: Partial<ScholarProfile> = {}): ScholarProfile {
+  return {
+    id: 1,
+    scholar_id: "abcDEF123456",
+    display_name: "Dr. Test Scholar",
+    profile_image_url: null,
+    profile_image_source: "none" as const,
+    is_enabled: true,
+    baseline_completed: true,
+    last_run_dt: null,
+    last_run_status: null,
+    ...overrides,
+  };
+}
+
+const defaultProps = {
+  scholar: buildScholar(),
+  imageUrlDraft: "",
+  imageBusy: false,
+  imageSaving: false,
+  imageUploading: false,
+  saving: false,
+};
+
+describe("ScholarSettingsModal", () => {
+  it("renders scholar name and ID when scholar is provided", () => {
+    const wrapper = mount(ScholarSettingsModal, {
+      props: defaultProps,
+      global: { stubs: { AppModal: false, RouterLink: true, ScholarAvatar: true } },
+    });
+    expect(wrapper.text()).toContain("Dr. Test Scholar");
+    expect(wrapper.text()).toContain("abcDEF123456");
+  });
+
+  it("renders nothing when scholar is null", () => {
+    const wrapper = mount(ScholarSettingsModal, {
+      props: { ...defaultProps, scholar: null },
+      global: { stubs: { AppModal: false, RouterLink: true, ScholarAvatar: true } },
+    });
+    expect(wrapper.text()).not.toContain("Dr. Test Scholar");
+  });
+
+  it("emits close when close event fires", async () => {
+    const wrapper = mount(ScholarSettingsModal, {
+      props: defaultProps,
+      global: { stubs: { RouterLink: true, ScholarAvatar: true } },
+    });
+    const modal = wrapper.findComponent({ name: "AppModal" });
+    if (modal.exists()) {
+      modal.vm.$emit("close");
+      expect(wrapper.emitted("close")).toHaveLength(1);
+    }
+  });
+
+  it("emits delete when delete button is clicked", async () => {
+    const wrapper = mount(ScholarSettingsModal, {
+      props: defaultProps,
+      global: { stubs: { RouterLink: true, ScholarAvatar: true } },
+    });
+    const deleteButton = wrapper.findAll("button").find((b) => b.text().includes("Delete"));
+    if (deleteButton) {
+      await deleteButton.trigger("click");
+      expect(wrapper.emitted("delete")).toHaveLength(1);
+    }
+  });
+
+  it("emits toggle when enable/disable button is clicked", async () => {
+    const wrapper = mount(ScholarSettingsModal, {
+      props: defaultProps,
+      global: { stubs: { RouterLink: true, ScholarAvatar: true } },
+    });
+    const toggleButton = wrapper.findAll("button").find((b) => b.text().includes("Disable"));
+    if (toggleButton) {
+      await toggleButton.trigger("click");
+      expect(wrapper.emitted("toggle")).toHaveLength(1);
+    }
+  });
+
+  it("shows Enable button for disabled scholars", () => {
+    const wrapper = mount(ScholarSettingsModal, {
+      props: { ...defaultProps, scholar: buildScholar({ is_enabled: false }) },
+      global: { stubs: { RouterLink: true, ScholarAvatar: true } },
+    });
+    expect(wrapper.text()).toContain("Enable");
+  });
+});
diff --git a/frontend/src/features/scholars/components/ScholarSettingsModal.vue b/frontend/src/features/scholars/components/ScholarSettingsModal.vue
new file mode 100644
index 0000000..4a129f8
--- /dev/null
+++ b/frontend/src/features/scholars/components/ScholarSettingsModal.vue
@@ -0,0 +1,113 @@
+<script setup lang="ts">
+import AppButton from "@/components/ui/AppButton.vue";
+import AppInput from "@/components/ui/AppInput.vue";
+import AppModal from "@/components/ui/AppModal.vue";
+import ScholarAvatar from "@/features/scholars/components/ScholarAvatar.vue";
+import type { ScholarProfile } from "@/features/scholars";
+
+const props = defineProps<{
+  scholar: ScholarProfile | null;
+  imageUrlDraft: string;
+  imageBusy: boolean;
+  imageSaving: boolean;
+  imageUploading: boolean;
+  saving: boolean;
+}>();
+
+const emit = defineEmits<{
+  (e: "close"): void;
+  (e: "update:image-url-draft", value: string): void;
+  (e: "save-image-url"): void;
+  (e: "upload-image", event: Event): void;
+  (e: "reset-image"): void;
+  (e: "toggle"): void;
+  (e: "delete"): void;
+}>();
+
+function scholarLabel(profile: ScholarProfile): string {
+  return profile.display_name || profile.scholar_id;
+}
+
+function scholarProfileUrl(scholarId: string): string {
+  return `https://scholar.google.com/citations?hl=en&user=${encodeURIComponent(scholarId)}`;
+}
+
+function scholarPublicationsRoute(profile: ScholarProfile): { name: string; query: { scholar: string } } {
+  return { name: "publications", query: { scholar: String(profile.id) } };
+}
+</script>
+
+<template>
+  <AppModal :open="scholar !== null" title="Scholar settings" @close="emit('close')">
+    <div v-if="scholar" class="grid gap-4">
+      <div class="flex items-start gap-3">
+        <ScholarAvatar
+          :label="scholar.display_name"
+          :scholar-id="scholar.scholar_id"
+          :image-url="scholar.profile_image_url"
+        />
+        <div class="min-w-0 space-y-1">
+          <p class="truncate text-sm font-semibold text-ink-primary">{{ scholarLabel(scholar) }}</p>
+          <p class="text-xs text-secondary">ID: <code>{{ scholar.scholar_id }}</code></p>
+          <div class="flex flex-wrap items-center gap-3">
+            <RouterLink :to="scholarPublicationsRoute(scholar)" class="link-inline text-xs">
+              View publications
+            </RouterLink>
+            <a :href="scholarProfileUrl(scholar.scholar_id)" target="_blank" rel="noreferrer" class="link-inline text-xs">
+              Open Google Scholar profile
+            </a>
+          </div>
+        </div>
+      </div>
+
+      <div class="grid gap-2">
+        <label class="text-sm font-medium text-ink-secondary" :for="`scholar-image-url-${scholar.id}`">
+          Profile image URL override
+        </label>
+        <div class="flex flex-wrap items-center gap-2">
+          <div class="min-w-0 flex-1">
+            <AppInput
+              :id="`scholar-image-url-${scholar.id}`"
+              :model-value="imageUrlDraft"
+              placeholder="https://example.com/avatar.jpg"
+              :disabled="imageBusy"
+              @update:model-value="emit('update:image-url-draft', $event as string)"
+            />
+          </div>
+          <AppButton variant="secondary" :disabled="imageBusy" @click="emit('save-image-url')">
+            {{ imageSaving ? "Saving..." : "Save URL" }}
+          </AppButton>
+        </div>
+        <div class="flex flex-wrap items-center gap-2">
+          <label
+            :for="`scholar-image-upload-${scholar.id}`"
+            class="inline-flex min-h-10 cursor-pointer items-center justify-center rounded-lg border border-stroke-strong bg-action-secondary-bg px-3 py-2 text-sm font-semibold text-action-secondary-text transition hover:bg-action-secondary-hover-bg focus-within:outline-none focus-within:ring-2 focus-within:ring-focus-ring focus-within:ring-offset-2 focus-within:ring-offset-focus-offset"
+            :class="{ 'pointer-events-none opacity-60': imageBusy }"
+          >
+            {{ imageUploading ? "Uploading..." : "Upload image" }}
+          </label>
+          <input
+            :id="`scholar-image-upload-${scholar.id}`"
+            type="file"
+            class="sr-only"
+            accept="image/jpeg,image/png,image/webp,image/gif"
+            :disabled="imageBusy"
+            @change="emit('upload-image', $event)"
+          />
+          <AppButton variant="ghost" :disabled="imageBusy" @click="emit('reset-image')">
+            Reset image
+          </AppButton>
+        </div>
+      </div>
+
+      <div class="flex flex-wrap items-center justify-between gap-2 border-t border-stroke-default pt-3">
+        <AppButton variant="secondary" :disabled="imageBusy || saving" @click="emit('toggle')">
+          {{ scholar.is_enabled ? "Disable scholar" : "Enable scholar" }}
+        </AppButton>
+        <AppButton variant="danger" :disabled="imageBusy || saving" @click="emit('delete')">
+          Delete scholar
+        </AppButton>
+      </div>
+    </div>
+  </AppModal>
+</template>
diff --git a/frontend/src/features/settings/SettingsAdminPanel.vue b/frontend/src/features/settings/SettingsAdminPanel.vue
index 9225ba5..585dd6a 100644
--- a/frontend/src/features/settings/SettingsAdminPanel.vue
+++ b/frontend/src/features/settings/SettingsAdminPanel.vue
@@ -1,599 +1,53 @@
 <script setup lang="ts">
-import { computed, onMounted, ref, watch } from "vue";
+import { onMounted, ref, watch } from "vue";
 
 import AsyncStateGate from "@/components/patterns/AsyncStateGate.vue";
 import RequestStateAlerts from "@/components/patterns/RequestStateAlerts.vue";
-import AppBadge from "@/components/ui/AppBadge.vue";
-import AppButton from "@/components/ui/AppButton.vue";
-import AppCard from "@/components/ui/AppCard.vue";
-import AppCheckbox from "@/components/ui/AppCheckbox.vue";
-import AppHelpHint from "@/components/ui/AppHelpHint.vue";
-import AppInput from "@/components/ui/AppInput.vue";
-import AppModal from "@/components/ui/AppModal.vue";
-import AppRefreshButton from "@/components/ui/AppRefreshButton.vue";
-import AppSelect from "@/components/ui/AppSelect.vue";
-import AppTable from "@/components/ui/AppTable.vue";
-import {
-  dropAllPublications,
-  getAdminDbIntegrityReport,
-  listAdminDbRepairJobs,
-  listAdminPdfQueue,
-  requeueAdminPdfLookup,
-  requeueAllAdminPdfLookups,
-  triggerPublicationNearDuplicateRepair,
-  triggerPublicationLinkRepair,
-  type AdminDbIntegrityCheck,
-  type AdminDbIntegrityReport,
-  type AdminDbRepairJob,
-  type AdminPdfQueueItem,
-  type NearDuplicateCluster,
-  type TriggerPublicationNearDuplicateRepairResult,
-  type TriggerPublicationLinkRepairResult,
-} from "@/features/admin_dbops";
-import {
-  createAdminUser,
-  listAdminUsers,
-  resetAdminUserPassword,
-  setAdminUserActive,
-  type AdminUser,
-} from "@/features/admin_users";
-import { ApiRequestError } from "@/lib/api/errors";
+import AdminIntegritySection from "@/features/settings/components/AdminIntegritySection.vue";
+import AdminPdfQueueSection from "@/features/settings/components/AdminPdfQueueSection.vue";
+import AdminRepairsSection from "@/features/settings/components/AdminRepairsSection.vue";
+import AdminUsersSection from "@/features/settings/components/AdminUsersSection.vue";
+import { useRequestState } from "@/composables/useRequestState";
 
 const SECTION_USERS = "users";
 const SECTION_INTEGRITY = "integrity";
 const SECTION_REPAIRS = "repairs";
 const SECTION_PDF = "pdf";
-const SCOPE_SINGLE_USER = "single_user";
-const SCOPE_ALL_USERS = "all_users";
-const APPLY_ALL_USERS_CONFIRM_TEXT = "REPAIR ALL USERS";
-const APPLY_NEAR_DUPLICATES_CONFIRM_TEXT = "MERGE SELECTED DUPLICATES";
-const DROP_PUBLICATIONS_CONFIRM_TEXT = "DROP ALL PUBLICATIONS";
-
-type RepairScopeMode = typeof SCOPE_SINGLE_USER | typeof SCOPE_ALL_USERS;
 
 const props = defineProps<{
   section: "users" | "integrity" | "repairs" | "pdf";
 }>();
 
 const loading = ref(true);
-const errorMessage = ref<string | null>(null);
-const errorRequestId = ref<string | null>(null);
-const successMessage = ref<string | null>(null);
+const { errorMessage, errorRequestId, successMessage, clearAlerts, assignError } = useRequestState();
 
-const refreshingUsers = ref(false);
-const creating = ref(false);
-const togglingUserId = ref<number | null>(null);
-const resettingPassword = ref(false);
-
-const users = ref<AdminUser[]>([]);
-const email = ref("");
-const password = ref("");
-const createIsAdmin = ref(false);
-const activeUserId = ref<number | null>(null);
-const resetPassword = ref("");
-
-const refreshingIntegrity = ref(false);
-const integrityReport = ref<AdminDbIntegrityReport | null>(null);
-
-const refreshingJobs = ref(false);
-const runningRepair = ref(false);
-const repairJobs = ref<AdminDbRepairJob[]>([]);
-const lastRepairResult = ref<TriggerPublicationLinkRepairResult | null>(null);
-const repairScopeMode = ref<RepairScopeMode>(SCOPE_SINGLE_USER);
-const repairUserId = ref("");
-const repairScholarIds = ref("");
-const repairRequestedBy = ref("");
-const repairDryRun = ref(true);
-const repairGcOrphans = ref(false);
-const repairConfirmationText = ref("");
-const runningNearDuplicateScan = ref(false);
-const applyingNearDuplicateRepair = ref(false);
-const nearDuplicateRequestedBy = ref("");
-const nearDuplicateSimilarityThreshold = ref("0.78");
-const nearDuplicateMinSharedTokens = ref("3");
-const nearDuplicateMaxYearDelta = ref("1");
-const nearDuplicateMaxClusters = ref("25");
-const nearDuplicateConfirmationText = ref("");
-const nearDuplicateSelectedClusterKeys = ref<Set<string>>(new Set());
-const nearDuplicateClusters = ref<NearDuplicateCluster[]>([]);
-const lastNearDuplicateResult = ref<TriggerPublicationNearDuplicateRepairResult | null>(null);
-
-const droppingPublications = ref(false);
-const dropConfirmationText = ref("");
-const dropResult = ref<{ deleted_count: number; message: string } | null>(null);
-const dropConfirmationValid = computed(
-  () => dropConfirmationText.value.trim() === DROP_PUBLICATIONS_CONFIRM_TEXT,
-);
-
-const refreshingPdfQueue = ref(false);
-const requeueingPublicationId = ref<number | null>(null);
-const requeueingAllPdfs = ref(false);
-const pdfQueueItems = ref<AdminPdfQueueItem[]>([]);
-const pdfQueueStatusFilter = ref("");
-const pdfQueuePage = ref(1);
-const pdfQueuePageSize = ref("50");
-const pdfQueueTotalCount = ref(0);
-const pdfQueueHasNext = ref(false);
-const pdfQueueHasPrev = ref(false);
-
-const activeUser = computed(() => users.value.find((user) => user.id === activeUserId.value) ?? null);
-const typedConfirmationRequired = computed(
-  () => repairScopeMode.value === SCOPE_ALL_USERS && !repairDryRun.value,
-);
-const nearDuplicateApplyEnabled = computed(() => nearDuplicateSelectedClusterKeys.value.size > 0);
-const pdfQueuePageSizeValue = computed(() => {
-  const parsed = Number(pdfQueuePageSize.value);
-  if (!Number.isFinite(parsed)) {
-    return 50;
-  }
-  return Math.max(1, Math.min(500, Math.trunc(parsed)));
-});
-const pdfQueueTotalPages = computed(() =>
-  Math.max(1, Math.ceil(pdfQueueTotalCount.value / Math.max(pdfQueuePageSizeValue.value, 1))),
-);
-const pdfQueueSummary = computed(() =>
-  `${pdfQueueTotalCount.value} item${pdfQueueTotalCount.value === 1 ? "" : "s"} total`,
-);
-
-function clearAlerts(): void {
-  errorMessage.value = null;
-  errorRequestId.value = null;
-  successMessage.value = null;
-}
-
-function formatTimestamp(value: string | null): string {
-  if (!value) {
-    return "n/a";
-  }
-  const parsed = new Date(value);
-  return Number.isNaN(parsed.getTime()) ? value : parsed.toLocaleString();
-}
-
-function statusTone(status: string): "success" | "warning" | "danger" | "info" | "neutral" {
-  if (status === "ok" || status === "completed" || status === "resolved") {
-    return "success";
-  }
-  if (status === "warning" || status === "running" || status === "queued") {
-    return "warning";
-  }
-  if (status === "failed") {
-    return "danger";
-  }
-  return "info";
-}
-
-function checkTone(check: AdminDbIntegrityCheck): "warning" | "danger" | "neutral" | "info" {
-  if (check.severity === "metric") {
-    return "info";
-  }
-  if (check.count <= 0) {
-    return "neutral";
-  }
-  return check.severity === "failure" ? "danger" : "warning";
-}
-
-function userRoleLabel(user: AdminUser): string {
-  return user.is_admin ? "Admin" : "User";
-}
-
-function canRequeuePdf(item: AdminPdfQueueItem): boolean {
-  return item.status !== "queued" && item.status !== "running";
-}
-
-function statusDotClass(user: AdminUser): string {
-  return user.is_active ? "bg-success-500 ring-success-200" : "bg-ink-muted/70 ring-stroke-default";
-}
-
-function assignError(error: unknown, fallback: string): void {
-  if (error instanceof ApiRequestError) {
-    errorMessage.value = error.message;
-    errorRequestId.value = error.requestId;
-    return;
-  }
-  if (error instanceof Error && error.message) {
-    errorMessage.value = error.message;
-    return;
-  }
-  errorMessage.value = fallback;
-}
-
-function parseScholarIds(raw: string): number[] {
-  const tokens = raw
-    .split(/[,\s]+/)
-    .map((token) => token.trim())
-    .filter((token) => token.length > 0);
-  const deduped = new Set<number>();
-  for (const token of tokens) {
-    const parsed = Number(token);
-    if (!Number.isInteger(parsed) || parsed < 1) {
-      throw new Error("Scholar profile IDs must be positive integers.");
-    }
-    deduped.add(parsed);
-  }
-  return [...deduped];
-}
-
-function parseRepairUserIdOrThrow(raw: string): number {
-  const parsed = Number((raw || "").trim());
-  if (!Number.isInteger(parsed) || parsed < 1) {
-    throw new Error("Select a valid target user.");
-  }
-  return parsed;
-}
-
-function validateTypedConfirmation(): string {
-  const normalized = repairConfirmationText.value.trim();
-  if (typedConfirmationRequired.value && normalized !== APPLY_ALL_USERS_CONFIRM_TEXT) {
-    throw new Error(`Type '${APPLY_ALL_USERS_CONFIRM_TEXT}' to apply repair for all users.`);
-  }
-  return normalized;
-}
-
-function parseBoundedNumber(
-  raw: string,
-  options: { minimum: number; maximum: number; fallback: number },
-): number {
-  const { minimum, maximum, fallback } = options;
-  const parsed = Number(raw.trim());
-  if (!Number.isFinite(parsed)) {
-    return fallback;
-  }
-  return Math.max(minimum, Math.min(maximum, parsed));
-}
-
-function nearDuplicatePayloadBase(): {
-  similarity_threshold: number;
-  min_shared_tokens: number;
-  max_year_delta: number;
-  max_clusters: number;
-  requested_by: string | undefined;
-} {
-  return {
-    similarity_threshold: parseBoundedNumber(nearDuplicateSimilarityThreshold.value, {
-      minimum: 0.5,
-      maximum: 1.0,
-      fallback: 0.78,
-    }),
-    min_shared_tokens: Math.trunc(
-      parseBoundedNumber(nearDuplicateMinSharedTokens.value, {
-        minimum: 1,
-        maximum: 8,
-        fallback: 3,
-      }),
-    ),
-    max_year_delta: Math.trunc(
-      parseBoundedNumber(nearDuplicateMaxYearDelta.value, {
-        minimum: 0,
-        maximum: 5,
-        fallback: 1,
-      }),
-    ),
-    max_clusters: Math.trunc(
-      parseBoundedNumber(nearDuplicateMaxClusters.value, {
-        minimum: 1,
-        maximum: 200,
-        fallback: 25,
-      }),
-    ),
-    requested_by: nearDuplicateRequestedBy.value.trim() || undefined,
-  };
-}
-
-function selectedNearDuplicateKeys(): string[] {
-  return [...nearDuplicateSelectedClusterKeys.value].sort((left, right) => left.localeCompare(right));
-}
-
-function checkboxEventChecked(event: Event): boolean {
-  return event.target instanceof HTMLInputElement ? event.target.checked : false;
-}
-
-function summaryCount(job: AdminDbRepairJob, key: string): string {
-  const value = job.summary[key];
-  return typeof value === "number" ? String(value) : "n/a";
-}
-
-function openUserModal(user: AdminUser): void {
-  activeUserId.value = user.id;
-  resetPassword.value = "";
-}
-
-function closeUserModal(): void {
-  activeUserId.value = null;
-  resetPassword.value = "";
-}
-
-function ensureRepairUserSelected(): void {
-  if (repairScopeMode.value !== SCOPE_SINGLE_USER || repairUserId.value || users.value.length === 0) {
-    return;
-  }
-  repairUserId.value = String(users.value[0].id);
-}
-
-async function refreshUsers(): Promise<void> {
-  refreshingUsers.value = true;
-  try {
-    users.value = await listAdminUsers();
-    ensureRepairUserSelected();
-    if (activeUserId.value !== null && !users.value.some((item) => item.id === activeUserId.value)) {
-      closeUserModal();
-    }
-  } finally {
-    refreshingUsers.value = false;
-  }
-}
-
-async function refreshIntegrity(): Promise<void> {
-  refreshingIntegrity.value = true;
-  try {
-    integrityReport.value = await getAdminDbIntegrityReport();
-  } finally {
-    refreshingIntegrity.value = false;
-  }
-}
-
-async function refreshRepairJobs(): Promise<void> {
-  refreshingJobs.value = true;
-  try {
-    repairJobs.value = await listAdminDbRepairJobs(30);
-  } finally {
-    refreshingJobs.value = false;
-  }
-}
-
-async function refreshPdfQueue(): Promise<void> {
-  refreshingPdfQueue.value = true;
-  try {
-    const status = pdfQueueStatusFilter.value.trim() || null;
-    const page = await listAdminPdfQueue(pdfQueuePage.value, pdfQueuePageSizeValue.value, status);
-    pdfQueueItems.value = page.items;
-    pdfQueueTotalCount.value = page.total_count;
-    pdfQueueHasNext.value = page.has_next;
-    pdfQueueHasPrev.value = page.has_prev;
-    pdfQueuePage.value = page.page;
-    pdfQueuePageSize.value = String(page.page_size);
-  } finally {
-    refreshingPdfQueue.value = false;
-  }
-}
+const usersRef = ref<InstanceType<typeof AdminUsersSection> | null>(null);
+const integrityRef = ref<InstanceType<typeof AdminIntegritySection> | null>(null);
+const repairsRef = ref<InstanceType<typeof AdminRepairsSection> | null>(null);
+const pdfQueueRef = ref<InstanceType<typeof AdminPdfQueueSection> | null>(null);
 
 async function refreshForSection(): Promise<void> {
-  if (props.section === SECTION_USERS) {
-    await refreshUsers();
+  if (props.section === SECTION_USERS && usersRef.value) {
+    await usersRef.value.load();
     return;
   }
-  if (props.section === SECTION_INTEGRITY) {
-    await refreshIntegrity();
+  if (props.section === SECTION_INTEGRITY && integrityRef.value) {
+    await integrityRef.value.load();
     return;
   }
   if (props.section === SECTION_REPAIRS) {
-    await Promise.all([refreshUsers(), refreshRepairJobs()]);
+    await Promise.all([
+      usersRef.value?.load(),
+      repairsRef.value?.load(),
+    ]);
     return;
   }
-  await refreshPdfQueue();
-}
-
-async function onCreateUser(): Promise<void> {
-  creating.value = true;
-  clearAlerts();
-  try {
-    if (!email.value.trim() || !password.value) {
-      throw new Error("Email and password are required.");
-    }
-    const created = await createAdminUser({
-      email: email.value.trim(),
-      password: password.value,
-      is_admin: createIsAdmin.value,
-    });
-    email.value = "";
-    password.value = "";
-    createIsAdmin.value = false;
-    successMessage.value = `User created: ${created.email}`;
-    await refreshUsers();
-  } catch (error) {
-    assignError(error, "Unable to create user.");
-  } finally {
-    creating.value = false;
+  if (props.section === SECTION_PDF && pdfQueueRef.value) {
+    await pdfQueueRef.value.load();
   }
 }
 
-async function onToggleUser(user: AdminUser): Promise<void> {
-  togglingUserId.value = user.id;
-  clearAlerts();
-  try {
-    const updated = await setAdminUserActive(user.id, !user.is_active);
-    successMessage.value = `${updated.email} is now ${updated.is_active ? "active" : "inactive"}.`;
-    await refreshUsers();
-  } catch (error) {
-    assignError(error, "Unable to update user.");
-  } finally {
-    togglingUserId.value = null;
-  }
-}
-
-async function onResetPassword(): Promise<void> {
-  const user = activeUser.value;
-  if (!user) {
-    return;
-  }
-  resettingPassword.value = true;
-  clearAlerts();
-  try {
-    const candidate = resetPassword.value.trim();
-    if (candidate.length < 12) {
-      throw new Error("New password must be at least 12 characters.");
-    }
-    const result = await resetAdminUserPassword(user.id, candidate);
-    resetPassword.value = "";
-    successMessage.value = result.message || `Password reset for ${user.email}.`;
-  } catch (error) {
-    assignError(error, "Unable to reset password.");
-  } finally {
-    resettingPassword.value = false;
-  }
-}
-
-async function onRunRepair(): Promise<void> {
-  runningRepair.value = true;
-  clearAlerts();
-  try {
-    const scopeMode = repairScopeMode.value;
-    const payload = {
-      scope_mode: scopeMode,
-      scholar_profile_ids: parseScholarIds(repairScholarIds.value),
-      dry_run: repairDryRun.value,
-      gc_orphan_publications: repairGcOrphans.value,
-      requested_by: repairRequestedBy.value.trim() || undefined,
-      confirmation_text: validateTypedConfirmation() || undefined,
-      user_id: scopeMode === SCOPE_SINGLE_USER ? parseRepairUserIdOrThrow(repairUserId.value) : undefined,
-    };
-    const result = await triggerPublicationLinkRepair(payload);
-    lastRepairResult.value = result;
-    successMessage.value = `Repair job #${result.job_id} completed (${result.status}).`;
-    repairConfirmationText.value = "";
-    await Promise.all([refreshIntegrity(), refreshRepairJobs(), refreshPdfQueue()]);
-  } catch (error) {
-    assignError(error, "Unable to run publication link repair.");
-  } finally {
-    runningRepair.value = false;
-  }
-}
-
-function onToggleNearDuplicateClusterSelection(clusterKey: string, checked: boolean): void {
-  const next = new Set(nearDuplicateSelectedClusterKeys.value);
-  if (checked) {
-    next.add(clusterKey);
-  } else {
-    next.delete(clusterKey);
-  }
-  nearDuplicateSelectedClusterKeys.value = next;
-}
-
-async function onRunNearDuplicateScan(): Promise<void> {
-  runningNearDuplicateScan.value = true;
-  clearAlerts();
-  try {
-    const result = await triggerPublicationNearDuplicateRepair({
-      dry_run: true,
-      ...nearDuplicatePayloadBase(),
-    });
-    nearDuplicateClusters.value = result.clusters;
-    nearDuplicateSelectedClusterKeys.value = new Set();
-    nearDuplicateConfirmationText.value = "";
-    lastNearDuplicateResult.value = result;
-    successMessage.value = `Near-duplicate scan completed (job #${result.job_id}).`;
-    await refreshRepairJobs();
-  } catch (error) {
-    assignError(error, "Unable to scan for near-duplicate publications.");
-  } finally {
-    runningNearDuplicateScan.value = false;
-  }
-}
-
-async function onApplyNearDuplicateRepair(): Promise<void> {
-  applyingNearDuplicateRepair.value = true;
-  clearAlerts();
-  try {
-    const selectedKeys = selectedNearDuplicateKeys();
-    if (selectedKeys.length === 0) {
-      throw new Error("Select at least one near-duplicate cluster before applying.");
-    }
-    if (nearDuplicateConfirmationText.value.trim() !== APPLY_NEAR_DUPLICATES_CONFIRM_TEXT) {
-      throw new Error(`Type '${APPLY_NEAR_DUPLICATES_CONFIRM_TEXT}' to confirm merge.`);
-    }
-    const result = await triggerPublicationNearDuplicateRepair({
-      dry_run: false,
-      selected_cluster_keys: selectedKeys,
-      confirmation_text: nearDuplicateConfirmationText.value.trim(),
-      ...nearDuplicatePayloadBase(),
-    });
-    nearDuplicateClusters.value = result.clusters;
-    nearDuplicateSelectedClusterKeys.value = new Set();
-    nearDuplicateConfirmationText.value = "";
-    lastNearDuplicateResult.value = result;
-    successMessage.value = `Merged selected near-duplicate clusters (job #${result.job_id}).`;
-    await refreshRepairJobs();
-  } catch (error) {
-    assignError(error, "Unable to apply near-duplicate merge.");
-  } finally {
-    applyingNearDuplicateRepair.value = false;
-  }
-}
-
-function onScopeModeChange(): void {
-  ensureRepairUserSelected();
-}
-
-async function onPdfQueueFilterChanged(): Promise<void> {
-  pdfQueuePage.value = 1;
-  await refreshPdfQueue();
-}
-
-async function onPdfQueuePageSizeChanged(): Promise<void> {
-  pdfQueuePage.value = 1;
-  await refreshPdfQueue();
-}
-
-async function onPdfQueuePrevPage(): Promise<void> {
-  if (!pdfQueueHasPrev.value || pdfQueuePage.value <= 1) {
-    return;
-  }
-  pdfQueuePage.value = Math.max(pdfQueuePage.value - 1, 1);
-  await refreshPdfQueue();
-}
-
-async function onPdfQueueNextPage(): Promise<void> {
-  if (!pdfQueueHasNext.value) {
-    return;
-  }
-  pdfQueuePage.value += 1;
-  await refreshPdfQueue();
-}
-
-async function onRequeuePdf(item: AdminPdfQueueItem): Promise<void> {
-  requeueingPublicationId.value = item.publication_id;
-  clearAlerts();
-  try {
-    const result = await requeueAdminPdfLookup(item.publication_id);
-    successMessage.value = result.message;
-    await refreshPdfQueue();
-  } catch (error) {
-    assignError(error, "Unable to requeue PDF lookup.");
-  } finally {
-    requeueingPublicationId.value = null;
-  }
-}
-
-async function onRequeueAllPdfs(): Promise<void> {
-  requeueingAllPdfs.value = true;
-  clearAlerts();
-  try {
-    const result = await requeueAllAdminPdfLookups(5000);
-    successMessage.value = result.message;
-    await refreshPdfQueue();
-  } catch (error) {
-    assignError(error, "Unable to queue missing PDF lookups.");
-  } finally {
-    requeueingAllPdfs.value = false;
-  }
-}
-
-async function onDropAllPublications(): Promise<void> {
-  droppingPublications.value = true;
-  clearAlerts();
-  dropResult.value = null;
-  try {
-    const result = await dropAllPublications(dropConfirmationText.value.trim());
-    dropResult.value = result;
-    successMessage.value = result.message;
-    dropConfirmationText.value = "";
-  } catch (error) {
-    assignError(error, "Unable to drop publications.");
-  } finally {
-    droppingPublications.value = false;
-  }
-}
-
-onMounted(async () => {
+async function loadSection(): Promise<void> {
   loading.value = true;
   clearAlerts();
   try {
@@ -603,22 +57,10 @@ onMounted(async () => {
   } finally {
     loading.value = false;
   }
-});
+}
 
-watch(
-  () => props.section,
-  async () => {
-    loading.value = true;
-    clearAlerts();
-    try {
-      await refreshForSection();
-    } catch (error) {
-      assignError(error, "Unable to load admin data.");
-    } finally {
-      loading.value = false;
-    }
-  },
-);
+onMounted(loadSection);
+watch(() => props.section, loadSection);
 </script>
 
 <template>
@@ -633,491 +75,10 @@ watch(
     />
 
     <AsyncStateGate :loading="loading" :loading-lines="10" :show-empty="false">
-      <AppCard v-if="props.section === SECTION_USERS" class="space-y-4">
-        <div class="flex flex-wrap items-center justify-between gap-2">
-          <div class="flex items-center gap-1">
-            <h2 class="text-lg font-semibold text-ink-primary">Users</h2>
-            <AppHelpHint text="Create accounts, toggle active status, and reset passwords." />
-          </div>
-          <AppRefreshButton
-            variant="secondary"
-            :loading="refreshingUsers"
-            title="Refresh users"
-            loading-title="Refreshing users"
-            @click="refreshUsers"
-          />
-        </div>
-
-        <form class="grid gap-3 md:grid-cols-3" @submit.prevent="onCreateUser">
-          <label class="grid gap-1 text-sm font-medium text-ink-secondary">
-            <span>Email</span>
-            <AppInput v-model="email" type="email" autocomplete="off" />
-          </label>
-          <label class="grid gap-1 text-sm font-medium text-ink-secondary">
-            <span>Password</span>
-            <AppInput v-model="password" type="password" autocomplete="new-password" />
-          </label>
-          <div class="grid gap-2 text-sm font-medium text-ink-secondary">
-            <span>Role</span>
-            <div class="flex items-center gap-3">
-              <AppCheckbox id="admin-create-user-is-admin" v-model="createIsAdmin" label="Grant admin" />
-              <AppButton type="submit" :disabled="creating">
-                {{ creating ? "Creating..." : "Create user" }}
-              </AppButton>
-            </div>
-          </div>
-        </form>
-
-        <AppTable label="Users table">
-          <thead>
-            <tr>
-              <th scope="col">Email</th>
-              <th scope="col">Role</th>
-              <th scope="col">Status</th>
-              <th scope="col">Actions</th>
-            </tr>
-          </thead>
-          <tbody>
-            <tr v-for="user in users" :key="user.id">
-              <td class="align-middle">
-                <button
-                  type="button"
-                  class="group inline-flex items-center gap-2 rounded-md px-1 py-0.5 text-left text-ink-primary transition hover:bg-surface-card-muted focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset"
-                  @click="openUserModal(user)"
-                >
-                  <span
-                    :class="statusDotClass(user)"
-                    class="h-2.5 w-2.5 rounded-full ring-2"
-                    :aria-label="user.is_active ? 'Active user' : 'Inactive user'"
-                  />
-                  <span class="underline-offset-2 group-hover:underline">{{ user.email }}</span>
-                </button>
-              </td>
-              <td>{{ userRoleLabel(user) }}</td>
-              <td>{{ user.is_active ? "active" : "inactive" }}</td>
-              <td class="flex flex-wrap items-center gap-2">
-                <AppButton variant="secondary" :disabled="togglingUserId === user.id" @click="onToggleUser(user)">
-                  {{ togglingUserId === user.id ? "Updating..." : user.is_active ? "Deactivate" : "Activate" }}
-                </AppButton>
-                <AppButton variant="ghost" @click="openUserModal(user)">Manage</AppButton>
-              </td>
-            </tr>
-          </tbody>
-        </AppTable>
-      </AppCard>
-
-      <AppCard v-if="props.section === SECTION_INTEGRITY" class="space-y-3">
-        <div class="flex flex-wrap items-center justify-between gap-2">
-          <div class="flex items-center gap-1">
-            <h2 class="text-lg font-semibold text-ink-primary">Integrity Report</h2>
-            <AppHelpHint text="Read-only checks for known corruption patterns and data drift." />
-          </div>
-          <AppRefreshButton
-            variant="secondary"
-            :loading="refreshingIntegrity"
-            title="Refresh integrity report"
-            loading-title="Refreshing integrity report"
-            @click="refreshIntegrity"
-          />
-        </div>
-
-        <div v-if="integrityReport" class="flex flex-wrap items-center gap-2 text-xs">
-          <AppBadge :tone="statusTone(integrityReport.status)">Status: {{ integrityReport.status }}</AppBadge>
-          <AppBadge tone="warning">Warnings: {{ integrityReport.warnings.length }}</AppBadge>
-          <AppBadge tone="danger">Failures: {{ integrityReport.failures.length }}</AppBadge>
-          <span class="text-secondary">Checked: {{ formatTimestamp(integrityReport.checked_at) }}</span>
-        </div>
-
-        <AppTable v-if="integrityReport" label="Integrity checks">
-          <thead>
-            <tr>
-              <th scope="col">Check</th>
-              <th scope="col">Count</th>
-              <th scope="col">Severity</th>
-              <th scope="col">Message</th>
-            </tr>
-          </thead>
-          <tbody>
-            <tr v-for="check in integrityReport.checks" :key="check.name">
-              <td>{{ check.name }}</td>
-              <td>{{ check.count }}</td>
-              <td><AppBadge :tone="checkTone(check)">{{ check.severity }}</AppBadge></td>
-              <td>{{ check.message }}</td>
-            </tr>
-          </tbody>
-        </AppTable>
-      </AppCard>
-
-      <section v-if="props.section === SECTION_REPAIRS" class="grid gap-4">
-        <AppCard class="space-y-3">
-          <div class="flex items-center gap-1">
-            <h2 class="text-lg font-semibold text-ink-primary">Publication Link Repair</h2>
-            <AppHelpHint text="Dry-run first. For all-users apply mode, typed confirmation is required." />
-          </div>
-
-          <form class="grid gap-3 md:grid-cols-2" @submit.prevent="onRunRepair">
-            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
-              <span>Scope</span>
-              <AppSelect v-model="repairScopeMode" @change="onScopeModeChange">
-                <option :value="SCOPE_SINGLE_USER">Single user</option>
-                <option :value="SCOPE_ALL_USERS">All users</option>
-              </AppSelect>
-            </label>
-            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
-              <span>Target user</span>
-              <AppSelect v-model="repairUserId" :disabled="repairScopeMode === SCOPE_ALL_USERS || users.length === 0">
-                <option value="" disabled>Select user</option>
-                <option v-for="user in users" :key="user.id" :value="String(user.id)">
-                  {{ user.email }} (ID {{ user.id }})
-                </option>
-              </AppSelect>
-            </label>
-            <label class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2">
-              <span>Scholar profile IDs (optional)</span>
-              <AppInput v-model="repairScholarIds" placeholder="e.g. 12,13,14" />
-            </label>
-            <label class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2">
-              <span>Requested by (optional)</span>
-              <AppInput v-model="repairRequestedBy" placeholder="email/name/ticket id" />
-            </label>
-            <div class="flex flex-wrap items-center gap-4 md:col-span-2">
-              <AppCheckbox id="repair-dry-run" v-model="repairDryRun" label="Dry-run (no writes)" />
-              <AppCheckbox id="repair-gc-orphans" v-model="repairGcOrphans" label="Delete orphan publications" />
-            </div>
-            <label v-if="typedConfirmationRequired" class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2">
-              <span>Type '{{ APPLY_ALL_USERS_CONFIRM_TEXT }}' to confirm</span>
-              <AppInput v-model="repairConfirmationText" :placeholder="APPLY_ALL_USERS_CONFIRM_TEXT" />
-            </label>
-            <p v-if="repairScopeMode === SCOPE_ALL_USERS" class="text-xs text-secondary md:col-span-2">
-              All-users scope includes every scholar profile across all accounts.
-            </p>
-            <div class="md:col-span-2">
-              <AppButton type="submit" :disabled="runningRepair">
-                {{ runningRepair ? "Running..." : "Run repair job" }}
-              </AppButton>
-            </div>
-          </form>
-
-          <div v-if="lastRepairResult" class="rounded-lg border border-stroke-default bg-surface-card-muted p-3 text-xs">
-            <div class="mb-2 flex flex-wrap items-center gap-2">
-              <AppBadge :tone="statusTone(lastRepairResult.status)">Job #{{ lastRepairResult.job_id }}</AppBadge>
-              <span class="text-secondary">Status: {{ lastRepairResult.status }}</span>
-            </div>
-            <pre class="overflow-x-auto text-secondary">{{ JSON.stringify(lastRepairResult.summary, null, 2) }}</pre>
-          </div>
-        </AppCard>
-
-        <AppCard class="space-y-3">
-          <div class="flex items-center gap-1">
-            <h2 class="text-lg font-semibold text-ink-primary">Near-Duplicate Publication Repair</h2>
-            <AppHelpHint text="Run a dry-run scan first, verify candidate clusters, then merge only selected clusters." />
-          </div>
-
-          <form class="grid gap-3 md:grid-cols-2" @submit.prevent="onRunNearDuplicateScan">
-            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
-              <span>Similarity threshold</span>
-              <AppInput v-model="nearDuplicateSimilarityThreshold" placeholder="0.78" />
-            </label>
-            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
-              <span>Min shared tokens</span>
-              <AppInput v-model="nearDuplicateMinSharedTokens" placeholder="3" />
-            </label>
-            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
-              <span>Max year delta</span>
-              <AppInput v-model="nearDuplicateMaxYearDelta" placeholder="1" />
-            </label>
-            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
-              <span>Max preview clusters</span>
-              <AppInput v-model="nearDuplicateMaxClusters" placeholder="25" />
-            </label>
-            <label class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2">
-              <span>Requested by (optional)</span>
-              <AppInput v-model="nearDuplicateRequestedBy" placeholder="email/name/ticket id" />
-            </label>
-            <div class="md:col-span-2">
-              <AppButton type="submit" :disabled="runningNearDuplicateScan">
-                {{ runningNearDuplicateScan ? "Scanning..." : "Scan near-duplicate clusters" }}
-              </AppButton>
-            </div>
-          </form>
-
-          <div v-if="nearDuplicateClusters.length > 0" class="space-y-3">
-            <AppTable label="Near duplicate clusters table">
-              <thead>
-                <tr>
-                  <th scope="col">Select</th>
-                  <th scope="col">Cluster</th>
-                  <th scope="col">Winner</th>
-                  <th scope="col">Members</th>
-                  <th scope="col">Similarity</th>
-                </tr>
-              </thead>
-              <tbody>
-                <tr v-for="cluster in nearDuplicateClusters" :key="cluster.cluster_key">
-                  <td>
-                    <input
-                      :id="`near-dup-${cluster.cluster_key}`"
-                      class="h-4 w-4 rounded border-stroke-default bg-surface-card"
-                      type="checkbox"
-                      :checked="nearDuplicateSelectedClusterKeys.has(cluster.cluster_key)"
-                      @change="onToggleNearDuplicateClusterSelection(cluster.cluster_key, checkboxEventChecked($event))"
-                    />
-                  </td>
-                  <td class="font-mono text-xs">{{ cluster.cluster_key }}</td>
-                  <td>#{{ cluster.winner_publication_id }}</td>
-                  <td>
-                    <div class="grid gap-1">
-                      <span v-for="member in cluster.members" :key="member.publication_id" class="text-xs text-secondary">
-                        #{{ member.publication_id }} · {{ member.title }}
-                      </span>
-                    </div>
-                  </td>
-                  <td>{{ cluster.similarity_score.toFixed(2) }}</td>
-                </tr>
-              </tbody>
-            </AppTable>
-
-            <form class="grid gap-3 md:grid-cols-2" @submit.prevent="onApplyNearDuplicateRepair">
-              <label class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2">
-                <span>Type '{{ APPLY_NEAR_DUPLICATES_CONFIRM_TEXT }}' to merge selected clusters</span>
-                <AppInput v-model="nearDuplicateConfirmationText" :placeholder="APPLY_NEAR_DUPLICATES_CONFIRM_TEXT" />
-              </label>
-              <div class="md:col-span-2">
-                <AppButton type="submit" :disabled="applyingNearDuplicateRepair || !nearDuplicateApplyEnabled">
-                  {{ applyingNearDuplicateRepair ? "Merging..." : "Merge selected clusters" }}
-                </AppButton>
-              </div>
-            </form>
-          </div>
-
-          <div v-if="lastNearDuplicateResult" class="rounded-lg border border-stroke-default bg-surface-card-muted p-3 text-xs">
-            <div class="mb-2 flex flex-wrap items-center gap-2">
-              <AppBadge :tone="statusTone(lastNearDuplicateResult.status)">Job #{{ lastNearDuplicateResult.job_id }}</AppBadge>
-              <span class="text-secondary">Status: {{ lastNearDuplicateResult.status }}</span>
-            </div>
-            <pre class="overflow-x-auto text-secondary">{{ JSON.stringify(lastNearDuplicateResult.summary, null, 2) }}</pre>
-          </div>
-        </AppCard>
-
-        <AppCard class="space-y-3">
-          <div class="flex flex-wrap items-center justify-between gap-2">
-            <div class="flex items-center gap-1">
-              <h2 class="text-lg font-semibold text-ink-primary">Recent Repair Jobs</h2>
-              <AppHelpHint text="Audit history and summary counters for each repair job." />
-            </div>
-            <AppRefreshButton
-              variant="secondary"
-              :loading="refreshingJobs"
-              title="Refresh repair jobs"
-              loading-title="Refreshing repair jobs"
-              @click="refreshRepairJobs"
-            />
-          </div>
-          <AppTable label="Repair jobs table">
-            <thead>
-              <tr>
-                <th scope="col">Job</th>
-                <th scope="col">Status</th>
-                <th scope="col">Mode</th>
-                <th scope="col">Requested by</th>
-                <th scope="col">Created</th>
-                <th scope="col">Links in scope</th>
-                <th scope="col">Links deleted</th>
-              </tr>
-            </thead>
-            <tbody>
-              <tr v-for="job in repairJobs" :key="job.id">
-                <td>#{{ job.id }} · {{ job.job_name }}</td>
-                <td><AppBadge :tone="statusTone(job.status)">{{ job.status }}</AppBadge></td>
-                <td>{{ job.dry_run ? "dry-run" : "apply" }}</td>
-                <td>{{ job.requested_by || "n/a" }}</td>
-                <td>{{ formatTimestamp(job.created_at) }}</td>
-                <td>{{ summaryCount(job, "links_in_scope") }}</td>
-                <td>{{ summaryCount(job, "links_deleted") }}</td>
-              </tr>
-            </tbody>
-          </AppTable>
-        </AppCard>
-
-        <AppCard class="space-y-3 border-danger-300 dark:border-danger-700">
-          <div class="flex items-center gap-1">
-            <h2 class="text-lg font-semibold text-danger-600 dark:text-danger-400">Drop All Publications</h2>
-            <AppHelpHint text="Permanently delete ALL publications, links, identifiers, and PDF jobs. Scholar baselines will be reset so the next run re-discovers everything." />
-          </div>
-
-          <p class="text-sm text-secondary">
-            This action is <strong>irreversible</strong>. It deletes every publication record across all users.
-            The next ingestion run will re-populate all data from scratch.
-          </p>
-
-          <form class="grid gap-3" @submit.prevent="onDropAllPublications">
-            <label class="grid gap-1 text-sm font-medium text-ink-secondary">
-              <span>Type '{{ DROP_PUBLICATIONS_CONFIRM_TEXT }}' to confirm</span>
-              <AppInput
-                v-model="dropConfirmationText"
-                :placeholder="DROP_PUBLICATIONS_CONFIRM_TEXT"
-                autocomplete="off"
-              />
-            </label>
-            <div>
-              <AppButton
-                type="submit"
-                variant="danger"
-                :disabled="droppingPublications || !dropConfirmationValid"
-              >
-                {{ droppingPublications ? "Dropping..." : "Drop all publications" }}
-              </AppButton>
-            </div>
-          </form>
-
-          <div v-if="dropResult" class="rounded-lg border border-stroke-default bg-surface-card-muted p-3 text-xs">
-            <div class="mb-1 flex items-center gap-2">
-              <AppBadge tone="danger">Deleted: {{ dropResult.deleted_count }}</AppBadge>
-            </div>
-            <p class="text-secondary">{{ dropResult.message }}</p>
-          </div>
-        </AppCard>
-      </section>
-
-      <AppCard v-if="props.section === SECTION_PDF" class="space-y-3">
-        <div class="flex flex-wrap items-center justify-between gap-2">
-          <div class="flex items-center gap-1">
-            <h2 class="text-lg font-semibold text-ink-primary">PDF Gathering Queue</h2>
-            <AppHelpHint text="Live queue and outcome history for PDF acquisition across all publications." />
-          </div>
-          <div class="flex items-center gap-2">
-            <AppSelect v-model="pdfQueueStatusFilter" class="min-w-[12rem] !py-1.5 !text-sm" @change="onPdfQueueFilterChanged">
-              <option value="">All statuses</option>
-              <option value="untracked">untracked</option>
-              <option value="queued">queued</option>
-              <option value="running">running</option>
-              <option value="failed">failed</option>
-              <option value="resolved">resolved</option>
-            </AppSelect>
-            <AppSelect v-model="pdfQueuePageSize" class="min-w-[10rem] !py-1.5 !text-sm" @change="onPdfQueuePageSizeChanged">
-              <option value="25">25 / page</option>
-              <option value="50">50 / page</option>
-              <option value="100">100 / page</option>
-            </AppSelect>
-            <AppButton
-              variant="secondary"
-              class="!min-h-8 whitespace-nowrap !px-2.5 !py-1 !text-xs"
-              :disabled="requeueingAllPdfs"
-              title="Queue all missing PDFs"
-              @click="onRequeueAllPdfs"
-            >
-              {{ requeueingAllPdfs ? "Queueing..." : "Queue all" }}
-            </AppButton>
-            <AppRefreshButton
-              variant="secondary"
-              size="sm"
-              :loading="refreshingPdfQueue"
-              title="Refresh PDF queue"
-              loading-title="Refreshing PDF queue"
-              @click="refreshPdfQueue"
-            />
-          </div>
-        </div>
-
-        <AppTable label="PDF queue table">
-          <thead>
-            <tr>
-              <th scope="col">Publication</th>
-              <th scope="col">Status</th>
-              <th scope="col">Attempts</th>
-              <th scope="col">Failure reason</th>
-              <th scope="col">Source</th>
-              <th scope="col">Requested by</th>
-              <th scope="col">Queued</th>
-              <th scope="col">Last attempt</th>
-              <th scope="col">Resolved</th>
-              <th scope="col">Actions</th>
-            </tr>
-          </thead>
-          <tbody>
-            <tr v-for="item in pdfQueueItems" :key="item.publication_id">
-              <td>
-                <div class="grid gap-1">
-                  <span class="font-medium text-ink-primary">{{ item.title }}</span>
-                  <a
-                    v-if="item.display_identifier?.url"
-                    :href="item.display_identifier.url"
-                    target="_blank"
-                    rel="noreferrer"
-                    class="link-inline text-xs"
-                  >
-                    {{ item.display_identifier.label }}
-                  </a>
-                </div>
-              </td>
-              <td><AppBadge :tone="statusTone(item.status)">{{ item.status }}</AppBadge></td>
-              <td>{{ item.attempt_count }}</td>
-              <td>{{ item.last_failure_reason || "n/a" }}</td>
-              <td>{{ item.last_source || "n/a" }}</td>
-              <td>{{ item.requested_by_email || "n/a" }}</td>
-              <td>{{ formatTimestamp(item.queued_at) }}</td>
-              <td>{{ formatTimestamp(item.last_attempt_at) }}</td>
-              <td>{{ formatTimestamp(item.resolved_at) }}</td>
-              <td>
-                <AppButton
-                  variant="ghost"
-                  :disabled="requeueingPublicationId === item.publication_id || !canRequeuePdf(item)"
-                  @click="onRequeuePdf(item)"
-                >
-                  {{ requeueingPublicationId === item.publication_id ? "Requeueing..." : "Requeue" }}
-                </AppButton>
-              </td>
-            </tr>
-          </tbody>
-        </AppTable>
-
-        <div class="flex flex-wrap items-center justify-between gap-2 text-xs text-secondary">
-          <span>{{ pdfQueueSummary }}</span>
-          <div class="flex items-center gap-2">
-            <span>Page {{ pdfQueuePage }} / {{ pdfQueueTotalPages }}</span>
-            <AppButton variant="ghost" :disabled="!pdfQueueHasPrev" @click="onPdfQueuePrevPage">Prev</AppButton>
-            <AppButton variant="ghost" :disabled="!pdfQueueHasNext" @click="onPdfQueueNextPage">Next</AppButton>
-          </div>
-        </div>
-      </AppCard>
+      <AdminUsersSection v-if="props.section === SECTION_USERS || props.section === SECTION_REPAIRS" v-show="props.section === SECTION_USERS" ref="usersRef" />
+      <AdminIntegritySection v-if="props.section === SECTION_INTEGRITY" ref="integrityRef" />
+      <AdminRepairsSection v-if="props.section === SECTION_REPAIRS" ref="repairsRef" :users="usersRef?.users ?? []" />
+      <AdminPdfQueueSection v-if="props.section === SECTION_PDF" ref="pdfQueueRef" />
     </AsyncStateGate>
-
-    <AppModal :open="activeUser !== null" title="User settings" @close="closeUserModal">
-      <div v-if="activeUser" class="grid gap-4">
-        <div class="space-y-1">
-          <div class="flex items-center gap-2">
-            <span
-              :class="statusDotClass(activeUser)"
-              class="h-2.5 w-2.5 rounded-full ring-2"
-              :aria-label="activeUser.is_active ? 'Active user' : 'Inactive user'"
-            />
-            <p class="truncate text-sm font-semibold text-ink-primary">{{ activeUser.email }}</p>
-          </div>
-          <p class="text-sm text-secondary">Role: {{ userRoleLabel(activeUser) }}</p>
-          <p class="text-xs text-secondary">Last updated: {{ formatTimestamp(activeUser.updated_at) }}</p>
-        </div>
-
-        <div class="grid gap-2">
-          <label class="grid gap-1 text-sm font-medium text-ink-secondary">
-            <span>New password</span>
-            <AppInput
-              id="admin-reset-password"
-              v-model="resetPassword"
-              type="password"
-              autocomplete="new-password"
-              placeholder="At least 12 characters"
-            />
-          </label>
-          <div class="flex flex-wrap gap-2">
-            <AppButton :disabled="resettingPassword" @click="onResetPassword">
-              {{ resettingPassword ? "Resetting..." : "Reset password" }}
-            </AppButton>
-            <AppButton variant="secondary" :disabled="togglingUserId === activeUser.id" @click="onToggleUser(activeUser)">
-              {{ togglingUserId === activeUser.id ? "Updating..." : activeUser.is_active ? "Deactivate user" : "Activate user" }}
-            </AppButton>
-          </div>
-        </div>
-      </div>
-    </AppModal>
   </section>
 </template>
diff --git a/frontend/src/features/settings/components/AdminIntegritySection.test.ts b/frontend/src/features/settings/components/AdminIntegritySection.test.ts
new file mode 100644
index 0000000..c69ab73
--- /dev/null
+++ b/frontend/src/features/settings/components/AdminIntegritySection.test.ts
@@ -0,0 +1,72 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { mount, flushPromises } from "@vue/test-utils";
+import AdminIntegritySection from "./AdminIntegritySection.vue";
+
+vi.mock("@/features/admin_dbops", () => ({
+  getAdminDbIntegrityReport: vi.fn(),
+}));
+
+import { getAdminDbIntegrityReport, type AdminDbIntegrityReport } from "@/features/admin_dbops";
+
+const mockedGetReport = vi.mocked(getAdminDbIntegrityReport);
+
+function buildReport(overrides: Partial<AdminDbIntegrityReport> = {}): AdminDbIntegrityReport {
+  return {
+    status: "ok",
+    warnings: [],
+    failures: [],
+    checked_at: "2025-01-15T12:00:00Z",
+    checks: [
+      { name: "orphaned_publications", count: 0, severity: "metric", message: "No orphaned publications found." },
+    ],
+    ...overrides,
+  };
+}
+
+describe("AdminIntegritySection", () => {
+  beforeEach(() => {
+    mockedGetReport.mockReset();
+  });
+
+  it("renders the section heading", () => {
+    const wrapper = mount(AdminIntegritySection);
+    expect(wrapper.text()).toContain("Integrity Report");
+  });
+
+  it("exposes load function that fetches integrity report", async () => {
+    mockedGetReport.mockResolvedValueOnce(buildReport());
+    const wrapper = mount(AdminIntegritySection);
+    const vm = wrapper.vm as unknown as { load: () => Promise<void> };
+    await vm.load();
+    await flushPromises();
+    expect(mockedGetReport).toHaveBeenCalled();
+  });
+
+  it("renders check results after loading", async () => {
+    mockedGetReport.mockResolvedValueOnce(buildReport());
+    const wrapper = mount(AdminIntegritySection);
+    const vm = wrapper.vm as unknown as { load: () => Promise<void> };
+    await vm.load();
+    await flushPromises();
+    expect(wrapper.text()).toContain("orphaned_publications");
+  });
+
+  it("displays warning count when present", async () => {
+    mockedGetReport.mockResolvedValueOnce(buildReport({ warnings: ["w1", "w2", "w3"] }));
+    const wrapper = mount(AdminIntegritySection);
+    const vm = wrapper.vm as unknown as { load: () => Promise<void> };
+    await vm.load();
+    await flushPromises();
+    expect(wrapper.text()).toContain("3");
+  });
+
+  it("renders status badge", async () => {
+    mockedGetReport.mockResolvedValueOnce(buildReport({ status: "failed" }));
+    const wrapper = mount(AdminIntegritySection);
+    const vm = wrapper.vm as unknown as { load: () => Promise<void> };
+    await vm.load();
+    await flushPromises();
+    expect(wrapper.text()).toContain("failed");
+  });
+});
diff --git a/frontend/src/features/settings/components/AdminIntegritySection.vue b/frontend/src/features/settings/components/AdminIntegritySection.vue
new file mode 100644
index 0000000..2c536d5
--- /dev/null
+++ b/frontend/src/features/settings/components/AdminIntegritySection.vue
@@ -0,0 +1,88 @@
+<script setup lang="ts">
+import { ref } from "vue";
+import AppBadge from "@/components/ui/AppBadge.vue";
+import AppCard from "@/components/ui/AppCard.vue";
+import AppHelpHint from "@/components/ui/AppHelpHint.vue";
+import AppRefreshButton from "@/components/ui/AppRefreshButton.vue";
+import AppTable from "@/components/ui/AppTable.vue";
+import {
+  getAdminDbIntegrityReport,
+  type AdminDbIntegrityCheck,
+  type AdminDbIntegrityReport,
+} from "@/features/admin_dbops";
+
+const refreshingIntegrity = ref(false);
+const integrityReport = ref<AdminDbIntegrityReport | null>(null);
+
+function formatTimestamp(value: string | null): string {
+  if (!value) return "n/a";
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? value : parsed.toLocaleString();
+}
+
+function statusTone(status: string): "success" | "warning" | "danger" | "info" | "neutral" {
+  if (status === "ok" || status === "completed" || status === "resolved") return "success";
+  if (status === "warning" || status === "running" || status === "queued") return "warning";
+  if (status === "failed") return "danger";
+  return "info";
+}
+
+function checkTone(check: AdminDbIntegrityCheck): "warning" | "danger" | "neutral" | "info" {
+  if (check.severity === "metric") return "info";
+  if (check.count <= 0) return "neutral";
+  return check.severity === "failure" ? "danger" : "warning";
+}
+
+async function refreshIntegrity(): Promise<void> {
+  refreshingIntegrity.value = true;
+  try {
+    integrityReport.value = await getAdminDbIntegrityReport();
+  } finally {
+    refreshingIntegrity.value = false;
+  }
+}
+
+async function load(): Promise<void> {
+  await refreshIntegrity();
+}
+
+defineExpose({ load });
+</script>
+
+<template>
+  <AppCard class="space-y-3">
+    <div class="flex flex-wrap items-center justify-between gap-2">
+      <div class="flex items-center gap-1">
+        <h2 class="text-lg font-semibold text-ink-primary">Integrity Report</h2>
+        <AppHelpHint text="Read-only checks for known corruption patterns and data drift." />
+      </div>
+      <AppRefreshButton variant="secondary" :loading="refreshingIntegrity" title="Refresh integrity report" loading-title="Refreshing integrity report" @click="refreshIntegrity" />
+    </div>
+
+    <div v-if="integrityReport" class="flex flex-wrap items-center gap-2 text-xs">
+      <AppBadge :tone="statusTone(integrityReport.status)">Status: {{ integrityReport.status }}</AppBadge>
+      <AppBadge tone="warning">Warnings: {{ integrityReport.warnings.length }}</AppBadge>
+      <AppBadge tone="danger">Failures: {{ integrityReport.failures.length }}</AppBadge>
+      <span class="text-secondary">Checked: {{ formatTimestamp(integrityReport.checked_at) }}</span>
+    </div>
+
+    <AppTable v-if="integrityReport" label="Integrity checks">
+      <thead>
+        <tr>
+          <th scope="col">Check</th>
+          <th scope="col">Count</th>
+          <th scope="col">Severity</th>
+          <th scope="col">Message</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr v-for="check in integrityReport.checks" :key="check.name">
+          <td>{{ check.name }}</td>
+          <td>{{ check.count }}</td>
+          <td><AppBadge :tone="checkTone(check)">{{ check.severity }}</AppBadge></td>
+          <td>{{ check.message }}</td>
+        </tr>
+      </tbody>
+    </AppTable>
+  </AppCard>
+</template>
diff --git a/frontend/src/features/settings/components/AdminPdfQueueSection.test.ts b/frontend/src/features/settings/components/AdminPdfQueueSection.test.ts
new file mode 100644
index 0000000..bdd0793
--- /dev/null
+++ b/frontend/src/features/settings/components/AdminPdfQueueSection.test.ts
@@ -0,0 +1,104 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { mount, flushPromises } from "@vue/test-utils";
+import AdminPdfQueueSection from "./AdminPdfQueueSection.vue";
+
+vi.mock("@/features/admin_dbops", () => ({
+  listAdminPdfQueue: vi.fn(),
+  requeueAdminPdfLookup: vi.fn(),
+  requeueAllAdminPdfLookups: vi.fn(),
+}));
+
+import { listAdminPdfQueue } from "@/features/admin_dbops";
+
+const mockedListQueue = vi.mocked(listAdminPdfQueue);
+
+function buildQueueItem(overrides: Record<string, unknown> = {}) {
+  return {
+    publication_id: 1,
+    title: "Test Paper",
+    display_identifier: null,
+    pdf_url: null,
+    status: "queued",
+    attempt_count: 0,
+    last_failure_reason: null,
+    last_failure_detail: null,
+    last_source: "unpaywall",
+    requested_by_user_id: null,
+    requested_by_email: null,
+    queued_at: "2025-01-15T12:00:00Z",
+    last_attempt_at: null,
+    resolved_at: null,
+    updated_at: "2025-01-15T12:00:00Z",
+    ...overrides,
+  };
+}
+
+describe("AdminPdfQueueSection", () => {
+  beforeEach(() => {
+    mockedListQueue.mockReset();
+  });
+
+  it("renders the PDF queue heading", () => {
+    const wrapper = mount(AdminPdfQueueSection);
+    expect(wrapper.text()).toContain("PDF");
+  });
+
+  it("exposes load function that fetches PDF queue", async () => {
+    mockedListQueue.mockResolvedValueOnce({
+      items: [buildQueueItem()],
+      total_count: 1,
+      has_next: false,
+      has_prev: false,
+      page: 1,
+      page_size: 50,
+    });
+    const wrapper = mount(AdminPdfQueueSection);
+    const vm = wrapper.vm as unknown as { load: () => Promise<void> };
+    await vm.load();
+    await flushPromises();
+    expect(mockedListQueue).toHaveBeenCalled();
+  });
+
+  it("renders queue items after loading", async () => {
+    mockedListQueue.mockResolvedValueOnce({
+      items: [buildQueueItem({ title: "My Paper" })],
+      total_count: 1,
+      has_next: false,
+      has_prev: false,
+      page: 1,
+      page_size: 50,
+    });
+    const wrapper = mount(AdminPdfQueueSection);
+    const vm = wrapper.vm as unknown as { load: () => Promise<void> };
+    await vm.load();
+    await flushPromises();
+    expect(wrapper.text()).toContain("My Paper");
+  });
+
+  it("renders status filter dropdown", () => {
+    const wrapper = mount(AdminPdfQueueSection);
+    expect(wrapper.text()).toContain("Status");
+  });
+
+  it("renders queue all button", () => {
+    const wrapper = mount(AdminPdfQueueSection);
+    expect(wrapper.text()).toContain("Queue all");
+  });
+
+  it("shows pagination summary after loading", async () => {
+    mockedListQueue.mockResolvedValueOnce({
+      items: Array.from({ length: 3 }, (_, i) => buildQueueItem({ publication_id: i + 1 })),
+      total_count: 3,
+      has_next: false,
+      has_prev: false,
+      page: 1,
+      page_size: 50,
+    });
+    const wrapper = mount(AdminPdfQueueSection);
+    const vm = wrapper.vm as unknown as { load: () => Promise<void> };
+    await vm.load();
+    await flushPromises();
+    expect(wrapper.text()).toContain("3");
+  });
+});
diff --git a/frontend/src/features/settings/components/AdminPdfQueueSection.vue b/frontend/src/features/settings/components/AdminPdfQueueSection.vue
new file mode 100644
index 0000000..f1500ca
--- /dev/null
+++ b/frontend/src/features/settings/components/AdminPdfQueueSection.vue
@@ -0,0 +1,203 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import AppBadge from "@/components/ui/AppBadge.vue";
+import AppButton from "@/components/ui/AppButton.vue";
+import AppCard from "@/components/ui/AppCard.vue";
+import AppHelpHint from "@/components/ui/AppHelpHint.vue";
+import AppRefreshButton from "@/components/ui/AppRefreshButton.vue";
+import AppSelect from "@/components/ui/AppSelect.vue";
+import AppTable from "@/components/ui/AppTable.vue";
+import {
+  listAdminPdfQueue,
+  requeueAdminPdfLookup,
+  requeueAllAdminPdfLookups,
+  type AdminPdfQueueItem,
+} from "@/features/admin_dbops";
+import { useRequestState } from "@/composables/useRequestState";
+
+const { clearAlerts, assignError, setSuccess } = useRequestState();
+
+const refreshingPdfQueue = ref(false);
+const requeueingPublicationId = ref<number | null>(null);
+const requeueingAllPdfs = ref(false);
+const pdfQueueItems = ref<AdminPdfQueueItem[]>([]);
+const pdfQueueStatusFilter = ref("");
+const pdfQueuePage = ref(1);
+const pdfQueuePageSize = ref("50");
+const pdfQueueTotalCount = ref(0);
+const pdfQueueHasNext = ref(false);
+const pdfQueueHasPrev = ref(false);
+
+const pdfQueuePageSizeValue = computed(() => {
+  const parsed = Number(pdfQueuePageSize.value);
+  if (!Number.isFinite(parsed)) return 50;
+  return Math.max(1, Math.min(500, Math.trunc(parsed)));
+});
+const pdfQueueTotalPages = computed(() =>
+  Math.max(1, Math.ceil(pdfQueueTotalCount.value / Math.max(pdfQueuePageSizeValue.value, 1))),
+);
+const pdfQueueSummary = computed(() =>
+  `${pdfQueueTotalCount.value} item${pdfQueueTotalCount.value === 1 ? "" : "s"} total`,
+);
+
+function statusTone(status: string): "success" | "warning" | "danger" | "info" | "neutral" {
+  if (status === "ok" || status === "completed" || status === "resolved") return "success";
+  if (status === "warning" || status === "running" || status === "queued") return "warning";
+  if (status === "failed") return "danger";
+  return "info";
+}
+
+function formatTimestamp(value: string | null): string {
+  if (!value) return "n/a";
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? value : parsed.toLocaleString();
+}
+
+function canRequeuePdf(item: AdminPdfQueueItem): boolean {
+  return item.status !== "queued" && item.status !== "running";
+}
+
+async function refreshPdfQueue(): Promise<void> {
+  refreshingPdfQueue.value = true;
+  try {
+    const status = pdfQueueStatusFilter.value.trim() || null;
+    const page = await listAdminPdfQueue(pdfQueuePage.value, pdfQueuePageSizeValue.value, status);
+    pdfQueueItems.value = page.items;
+    pdfQueueTotalCount.value = page.total_count;
+    pdfQueueHasNext.value = page.has_next;
+    pdfQueueHasPrev.value = page.has_prev;
+    pdfQueuePage.value = page.page;
+    pdfQueuePageSize.value = String(page.page_size);
+  } finally {
+    refreshingPdfQueue.value = false;
+  }
+}
+
+async function onPdfQueueFilterChanged(): Promise<void> {
+  pdfQueuePage.value = 1;
+  await refreshPdfQueue();
+}
+
+async function onPdfQueuePageSizeChanged(): Promise<void> {
+  pdfQueuePage.value = 1;
+  await refreshPdfQueue();
+}
+
+async function onPdfQueuePrevPage(): Promise<void> {
+  if (!pdfQueueHasPrev.value || pdfQueuePage.value <= 1) return;
+  pdfQueuePage.value = Math.max(pdfQueuePage.value - 1, 1);
+  await refreshPdfQueue();
+}
+
+async function onPdfQueueNextPage(): Promise<void> {
+  if (!pdfQueueHasNext.value) return;
+  pdfQueuePage.value += 1;
+  await refreshPdfQueue();
+}
+
+async function onRequeuePdf(item: AdminPdfQueueItem): Promise<void> {
+  requeueingPublicationId.value = item.publication_id;
+  clearAlerts();
+  try {
+    const result = await requeueAdminPdfLookup(item.publication_id);
+    setSuccess(result.message);
+    await refreshPdfQueue();
+  } catch (error) {
+    assignError(error, "Unable to requeue PDF lookup.");
+  } finally {
+    requeueingPublicationId.value = null;
+  }
+}
+
+async function onRequeueAllPdfs(): Promise<void> {
+  requeueingAllPdfs.value = true;
+  clearAlerts();
+  try {
+    const result = await requeueAllAdminPdfLookups(5000);
+    setSuccess(result.message);
+    await refreshPdfQueue();
+  } catch (error) {
+    assignError(error, "Unable to queue missing PDF lookups.");
+  } finally {
+    requeueingAllPdfs.value = false;
+  }
+}
+
+async function load(): Promise<void> {
+  await refreshPdfQueue();
+}
+
+defineExpose({ load });
+</script>
+
+<template>
+  <AppCard class="space-y-3">
+    <div class="flex flex-wrap items-center justify-between gap-2">
+      <div class="flex items-center gap-1">
+        <h2 class="text-lg font-semibold text-ink-primary">PDF Gathering Queue</h2>
+        <AppHelpHint text="Live queue and outcome history for PDF acquisition across all publications." />
+      </div>
+      <div class="flex items-center gap-2">
+        <AppSelect v-model="pdfQueueStatusFilter" class="min-w-[12rem] !py-1.5 !text-sm" @change="onPdfQueueFilterChanged">
+          <option value="">All statuses</option>
+          <option value="untracked">untracked</option>
+          <option value="queued">queued</option>
+          <option value="running">running</option>
+          <option value="failed">failed</option>
+          <option value="resolved">resolved</option>
+        </AppSelect>
+        <AppSelect v-model="pdfQueuePageSize" class="min-w-[10rem] !py-1.5 !text-sm" @change="onPdfQueuePageSizeChanged">
+          <option value="25">25 / page</option>
+          <option value="50">50 / page</option>
+          <option value="100">100 / page</option>
+        </AppSelect>
+        <AppButton variant="secondary" class="!min-h-8 whitespace-nowrap !px-2.5 !py-1 !text-xs" :disabled="requeueingAllPdfs" title="Queue all missing PDFs" @click="onRequeueAllPdfs">
+          {{ requeueingAllPdfs ? "Queueing..." : "Queue all" }}
+        </AppButton>
+        <AppRefreshButton variant="secondary" size="sm" :loading="refreshingPdfQueue" title="Refresh PDF queue" loading-title="Refreshing PDF queue" @click="refreshPdfQueue" />
+      </div>
+    </div>
+
+    <AppTable label="PDF queue table">
+      <thead>
+        <tr>
+          <th scope="col">Publication</th><th scope="col">Status</th><th scope="col">Attempts</th>
+          <th scope="col">Failure reason</th><th scope="col">Source</th><th scope="col">Requested by</th>
+          <th scope="col">Queued</th><th scope="col">Last attempt</th><th scope="col">Resolved</th><th scope="col">Actions</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr v-for="item in pdfQueueItems" :key="item.publication_id">
+          <td>
+            <div class="grid gap-1">
+              <span class="font-medium text-ink-primary">{{ item.title }}</span>
+              <a v-if="item.display_identifier?.url" :href="item.display_identifier.url" target="_blank" rel="noreferrer" class="link-inline text-xs">{{ item.display_identifier.label }}</a>
+            </div>
+          </td>
+          <td><AppBadge :tone="statusTone(item.status)">{{ item.status }}</AppBadge></td>
+          <td>{{ item.attempt_count }}</td>
+          <td>{{ item.last_failure_reason || "n/a" }}</td>
+          <td>{{ item.last_source || "n/a" }}</td>
+          <td>{{ item.requested_by_email || "n/a" }}</td>
+          <td>{{ formatTimestamp(item.queued_at) }}</td>
+          <td>{{ formatTimestamp(item.last_attempt_at) }}</td>
+          <td>{{ formatTimestamp(item.resolved_at) }}</td>
+          <td>
+            <AppButton variant="ghost" :disabled="requeueingPublicationId === item.publication_id || !canRequeuePdf(item)" @click="onRequeuePdf(item)">
+              {{ requeueingPublicationId === item.publication_id ? "Requeueing..." : "Requeue" }}
+            </AppButton>
+          </td>
+        </tr>
+      </tbody>
+    </AppTable>
+
+    <div class="flex flex-wrap items-center justify-between gap-2 text-xs text-secondary">
+      <span>{{ pdfQueueSummary }}</span>
+      <div class="flex items-center gap-2">
+        <span>Page {{ pdfQueuePage }} / {{ pdfQueueTotalPages }}</span>
+        <AppButton variant="ghost" :disabled="!pdfQueueHasPrev" @click="onPdfQueuePrevPage">Prev</AppButton>
+        <AppButton variant="ghost" :disabled="!pdfQueueHasNext" @click="onPdfQueueNextPage">Next</AppButton>
+      </div>
+    </div>
+  </AppCard>
+</template>
diff --git a/frontend/src/features/settings/components/AdminRepairsSection.test.ts b/frontend/src/features/settings/components/AdminRepairsSection.test.ts
new file mode 100644
index 0000000..c7c4685
--- /dev/null
+++ b/frontend/src/features/settings/components/AdminRepairsSection.test.ts
@@ -0,0 +1,91 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { mount, flushPromises } from "@vue/test-utils";
+import AdminRepairsSection from "./AdminRepairsSection.vue";
+
+vi.mock("@/features/admin_dbops", () => ({
+  listAdminDbRepairJobs: vi.fn(),
+  triggerPublicationLinkRepair: vi.fn(),
+  triggerPublicationNearDuplicateRepair: vi.fn(),
+  dropAllPublications: vi.fn(),
+}));
+
+import { listAdminDbRepairJobs, dropAllPublications } from "@/features/admin_dbops";
+
+const mockedListJobs = vi.mocked(listAdminDbRepairJobs);
+const mockedDrop = vi.mocked(dropAllPublications);
+
+function buildUser(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 1,
+    email: "admin@test.com",
+    is_admin: true,
+    is_active: true,
+    created_at: "2025-01-01T00:00:00Z",
+    updated_at: "2025-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+describe("AdminRepairsSection", () => {
+  beforeEach(() => {
+    mockedListJobs.mockReset();
+    mockedDrop.mockReset();
+  });
+
+  it("renders the repair sections", () => {
+    const wrapper = mount(AdminRepairsSection, { props: { users: [buildUser()] } });
+    expect(wrapper.text()).toContain("Publication Link Repair");
+    expect(wrapper.text()).toContain("Near-Duplicate");
+    expect(wrapper.text()).toContain("Drop All Publications");
+  });
+
+  it("exposes load function that fetches repair jobs", async () => {
+    mockedListJobs.mockResolvedValueOnce([]);
+    const wrapper = mount(AdminRepairsSection, { props: { users: [buildUser()] } });
+    const vm = wrapper.vm as unknown as { load: () => Promise<void> };
+    await vm.load();
+    await flushPromises();
+    expect(mockedListJobs).toHaveBeenCalled();
+  });
+
+  it("renders repair job rows after loading", async () => {
+    mockedListJobs.mockResolvedValueOnce([
+      {
+        id: 1,
+        job_name: "publication_link_repair",
+        status: "completed",
+        dry_run: true,
+        requested_by: "admin@test.com",
+        scope: {},
+        summary: { links_in_scope: 100, links_deleted: 5 },
+        error_text: null,
+        started_at: "2025-01-15T12:00:00Z",
+        finished_at: "2025-01-15T12:01:00Z",
+        created_at: "2025-01-15T12:00:00Z",
+        updated_at: "2025-01-15T12:01:00Z",
+      },
+    ]);
+    const wrapper = mount(AdminRepairsSection, { props: { users: [buildUser()] } });
+    const vm = wrapper.vm as unknown as { load: () => Promise<void> };
+    await vm.load();
+    await flushPromises();
+    expect(wrapper.text()).toContain("publication_link_repair");
+  });
+
+  it("has typed confirmation guard for drop all publications", () => {
+    const wrapper = mount(AdminRepairsSection, { props: { users: [buildUser()] } });
+    const dropButton = wrapper.findAll("button").find((b) => b.text().includes("Drop all publications"));
+    expect(dropButton?.attributes("disabled")).toBeDefined();
+  });
+
+  it("renders dry-run toggle in repair form", () => {
+    const wrapper = mount(AdminRepairsSection, { props: { users: [buildUser()] } });
+    expect(wrapper.text()).toContain("Dry-run");
+  });
+
+  it("renders scope mode selector", () => {
+    const wrapper = mount(AdminRepairsSection, { props: { users: [buildUser()] } });
+    expect(wrapper.text()).toContain("Scope");
+  });
+});
diff --git a/frontend/src/features/settings/components/AdminRepairsSection.vue b/frontend/src/features/settings/components/AdminRepairsSection.vue
new file mode 100644
index 0000000..3f3a88a
--- /dev/null
+++ b/frontend/src/features/settings/components/AdminRepairsSection.vue
@@ -0,0 +1,372 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import AppBadge from "@/components/ui/AppBadge.vue";
+import AppButton from "@/components/ui/AppButton.vue";
+import AppCard from "@/components/ui/AppCard.vue";
+import AppCheckbox from "@/components/ui/AppCheckbox.vue";
+import AppHelpHint from "@/components/ui/AppHelpHint.vue";
+import AppInput from "@/components/ui/AppInput.vue";
+import AppRefreshButton from "@/components/ui/AppRefreshButton.vue";
+import AppSelect from "@/components/ui/AppSelect.vue";
+import AppTable from "@/components/ui/AppTable.vue";
+import {
+  dropAllPublications,
+  listAdminDbRepairJobs,
+  triggerPublicationLinkRepair,
+  triggerPublicationNearDuplicateRepair,
+  type AdminDbRepairJob,
+  type NearDuplicateCluster,
+  type TriggerPublicationLinkRepairResult,
+  type TriggerPublicationNearDuplicateRepairResult,
+} from "@/features/admin_dbops";
+import type { AdminUser } from "@/features/admin_users";
+import { useRequestState } from "@/composables/useRequestState";
+
+const props = defineProps<{
+  users: AdminUser[];
+}>();
+
+const SCOPE_SINGLE_USER = "single_user";
+const SCOPE_ALL_USERS = "all_users";
+const APPLY_ALL_USERS_CONFIRM_TEXT = "REPAIR ALL USERS";
+const APPLY_NEAR_DUPLICATES_CONFIRM_TEXT = "MERGE SELECTED DUPLICATES";
+const DROP_PUBLICATIONS_CONFIRM_TEXT = "DROP ALL PUBLICATIONS";
+
+type RepairScopeMode = typeof SCOPE_SINGLE_USER | typeof SCOPE_ALL_USERS;
+
+const { clearAlerts, assignError, setSuccess } = useRequestState();
+
+const refreshingJobs = ref(false);
+const runningRepair = ref(false);
+const repairJobs = ref<AdminDbRepairJob[]>([]);
+const lastRepairResult = ref<TriggerPublicationLinkRepairResult | null>(null);
+const repairScopeMode = ref<RepairScopeMode>(SCOPE_SINGLE_USER);
+const repairUserId = ref("");
+const repairScholarIds = ref("");
+const repairRequestedBy = ref("");
+const repairDryRun = ref(true);
+const repairGcOrphans = ref(false);
+const repairConfirmationText = ref("");
+
+const runningNearDuplicateScan = ref(false);
+const applyingNearDuplicateRepair = ref(false);
+const nearDuplicateRequestedBy = ref("");
+const nearDuplicateSimilarityThreshold = ref("0.78");
+const nearDuplicateMinSharedTokens = ref("3");
+const nearDuplicateMaxYearDelta = ref("1");
+const nearDuplicateMaxClusters = ref("25");
+const nearDuplicateConfirmationText = ref("");
+const nearDuplicateSelectedClusterKeys = ref<Set<string>>(new Set());
+const nearDuplicateClusters = ref<NearDuplicateCluster[]>([]);
+const lastNearDuplicateResult = ref<TriggerPublicationNearDuplicateRepairResult | null>(null);
+
+const droppingPublications = ref(false);
+const dropConfirmationText = ref("");
+const dropResult = ref<{ deleted_count: number; message: string } | null>(null);
+const dropConfirmationValid = computed(() => dropConfirmationText.value.trim() === DROP_PUBLICATIONS_CONFIRM_TEXT);
+
+const typedConfirmationRequired = computed(
+  () => repairScopeMode.value === SCOPE_ALL_USERS && !repairDryRun.value,
+);
+const nearDuplicateApplyEnabled = computed(() => nearDuplicateSelectedClusterKeys.value.size > 0);
+
+function statusTone(status: string): "success" | "warning" | "danger" | "info" | "neutral" {
+  if (status === "ok" || status === "completed" || status === "resolved") return "success";
+  if (status === "warning" || status === "running" || status === "queued") return "warning";
+  if (status === "failed") return "danger";
+  return "info";
+}
+
+function formatTimestamp(value: string | null): string {
+  if (!value) return "n/a";
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? value : parsed.toLocaleString();
+}
+
+function parseScholarIds(raw: string): number[] {
+  const tokens = raw.split(/[,\s]+/).map((t) => t.trim()).filter((t) => t.length > 0);
+  const deduped = new Set<number>();
+  for (const token of tokens) {
+    const parsed = Number(token);
+    if (!Number.isInteger(parsed) || parsed < 1) throw new Error("Scholar profile IDs must be positive integers.");
+    deduped.add(parsed);
+  }
+  return [...deduped];
+}
+
+function parseRepairUserIdOrThrow(raw: string): number {
+  const parsed = Number((raw || "").trim());
+  if (!Number.isInteger(parsed) || parsed < 1) throw new Error("Select a valid target user.");
+  return parsed;
+}
+
+function validateTypedConfirmation(): string {
+  const normalized = repairConfirmationText.value.trim();
+  if (typedConfirmationRequired.value && normalized !== APPLY_ALL_USERS_CONFIRM_TEXT) {
+    throw new Error(`Type '${APPLY_ALL_USERS_CONFIRM_TEXT}' to apply repair for all users.`);
+  }
+  return normalized;
+}
+
+function parseBoundedNumber(raw: string, opts: { minimum: number; maximum: number; fallback: number }): number {
+  const parsed = Number(raw.trim());
+  if (!Number.isFinite(parsed)) return opts.fallback;
+  return Math.max(opts.minimum, Math.min(opts.maximum, parsed));
+}
+
+function nearDuplicatePayloadBase() {
+  return {
+    similarity_threshold: parseBoundedNumber(nearDuplicateSimilarityThreshold.value, { minimum: 0.5, maximum: 1.0, fallback: 0.78 }),
+    min_shared_tokens: Math.trunc(parseBoundedNumber(nearDuplicateMinSharedTokens.value, { minimum: 1, maximum: 8, fallback: 3 })),
+    max_year_delta: Math.trunc(parseBoundedNumber(nearDuplicateMaxYearDelta.value, { minimum: 0, maximum: 5, fallback: 1 })),
+    max_clusters: Math.trunc(parseBoundedNumber(nearDuplicateMaxClusters.value, { minimum: 1, maximum: 200, fallback: 25 })),
+    requested_by: nearDuplicateRequestedBy.value.trim() || undefined,
+  };
+}
+
+function checkboxEventChecked(event: Event): boolean {
+  return event.target instanceof HTMLInputElement ? event.target.checked : false;
+}
+
+function summaryCount(job: AdminDbRepairJob, key: string): string {
+  const value = job.summary[key];
+  return typeof value === "number" ? String(value) : "n/a";
+}
+
+function ensureRepairUserSelected(): void {
+  if (repairScopeMode.value !== SCOPE_SINGLE_USER || repairUserId.value || props.users.length === 0) return;
+  repairUserId.value = String(props.users[0].id);
+}
+
+async function refreshRepairJobs(): Promise<void> {
+  refreshingJobs.value = true;
+  try { repairJobs.value = await listAdminDbRepairJobs(30); } finally { refreshingJobs.value = false; }
+}
+
+async function onRunRepair(): Promise<void> {
+  runningRepair.value = true;
+  clearAlerts();
+  try {
+    const payload = {
+      scope_mode: repairScopeMode.value,
+      scholar_profile_ids: parseScholarIds(repairScholarIds.value),
+      dry_run: repairDryRun.value,
+      gc_orphan_publications: repairGcOrphans.value,
+      requested_by: repairRequestedBy.value.trim() || undefined,
+      confirmation_text: validateTypedConfirmation() || undefined,
+      user_id: repairScopeMode.value === SCOPE_SINGLE_USER ? parseRepairUserIdOrThrow(repairUserId.value) : undefined,
+    };
+    const result = await triggerPublicationLinkRepair(payload);
+    lastRepairResult.value = result;
+    setSuccess(`Repair job #${result.job_id} completed (${result.status}).`);
+    repairConfirmationText.value = "";
+    await refreshRepairJobs();
+  } catch (error) {
+    assignError(error, "Unable to run publication link repair.");
+  } finally {
+    runningRepair.value = false;
+  }
+}
+
+function onToggleNearDuplicateClusterSelection(clusterKey: string, checked: boolean): void {
+  const next = new Set(nearDuplicateSelectedClusterKeys.value);
+  if (checked) { next.add(clusterKey); } else { next.delete(clusterKey); }
+  nearDuplicateSelectedClusterKeys.value = next;
+}
+
+async function onRunNearDuplicateScan(): Promise<void> {
+  runningNearDuplicateScan.value = true;
+  clearAlerts();
+  try {
+    const result = await triggerPublicationNearDuplicateRepair({ dry_run: true, ...nearDuplicatePayloadBase() });
+    nearDuplicateClusters.value = result.clusters;
+    nearDuplicateSelectedClusterKeys.value = new Set();
+    nearDuplicateConfirmationText.value = "";
+    lastNearDuplicateResult.value = result;
+    setSuccess(`Near-duplicate scan completed (job #${result.job_id}).`);
+    await refreshRepairJobs();
+  } catch (error) {
+    assignError(error, "Unable to scan for near-duplicate publications.");
+  } finally {
+    runningNearDuplicateScan.value = false;
+  }
+}
+
+async function onApplyNearDuplicateRepair(): Promise<void> {
+  applyingNearDuplicateRepair.value = true;
+  clearAlerts();
+  try {
+    const selectedKeys = [...nearDuplicateSelectedClusterKeys.value].sort((a, b) => a.localeCompare(b));
+    if (selectedKeys.length === 0) throw new Error("Select at least one near-duplicate cluster before applying.");
+    if (nearDuplicateConfirmationText.value.trim() !== APPLY_NEAR_DUPLICATES_CONFIRM_TEXT) {
+      throw new Error(`Type '${APPLY_NEAR_DUPLICATES_CONFIRM_TEXT}' to confirm merge.`);
+    }
+    const result = await triggerPublicationNearDuplicateRepair({
+      dry_run: false,
+      selected_cluster_keys: selectedKeys,
+      confirmation_text: nearDuplicateConfirmationText.value.trim(),
+      ...nearDuplicatePayloadBase(),
+    });
+    nearDuplicateClusters.value = result.clusters;
+    nearDuplicateSelectedClusterKeys.value = new Set();
+    nearDuplicateConfirmationText.value = "";
+    lastNearDuplicateResult.value = result;
+    setSuccess(`Merged selected near-duplicate clusters (job #${result.job_id}).`);
+    await refreshRepairJobs();
+  } catch (error) {
+    assignError(error, "Unable to apply near-duplicate merge.");
+  } finally {
+    applyingNearDuplicateRepair.value = false;
+  }
+}
+
+async function onDropAllPublications(): Promise<void> {
+  droppingPublications.value = true;
+  clearAlerts();
+  dropResult.value = null;
+  try {
+    const result = await dropAllPublications(dropConfirmationText.value.trim());
+    dropResult.value = result;
+    setSuccess(result.message);
+    dropConfirmationText.value = "";
+  } catch (error) {
+    assignError(error, "Unable to drop publications.");
+  } finally {
+    droppingPublications.value = false;
+  }
+}
+
+async function load(): Promise<void> {
+  await refreshRepairJobs();
+  ensureRepairUserSelected();
+}
+
+defineExpose({ load });
+</script>
+
+<template>
+  <section class="grid gap-4">
+    <AppCard class="space-y-3">
+      <div class="flex items-center gap-1">
+        <h2 class="text-lg font-semibold text-ink-primary">Publication Link Repair</h2>
+        <AppHelpHint text="Dry-run first. For all-users apply mode, typed confirmation is required." />
+      </div>
+      <form class="grid gap-3 md:grid-cols-2" @submit.prevent="onRunRepair">
+        <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+          <span>Scope</span>
+          <AppSelect v-model="repairScopeMode" @change="ensureRepairUserSelected">
+            <option :value="SCOPE_SINGLE_USER">Single user</option>
+            <option :value="SCOPE_ALL_USERS">All users</option>
+          </AppSelect>
+        </label>
+        <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+          <span>Target user</span>
+          <AppSelect v-model="repairUserId" :disabled="repairScopeMode === SCOPE_ALL_USERS || users.length === 0">
+            <option value="" disabled>Select user</option>
+            <option v-for="user in users" :key="user.id" :value="String(user.id)">{{ user.email }} (ID {{ user.id }})</option>
+          </AppSelect>
+        </label>
+        <label class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2">
+          <span>Scholar profile IDs (optional)</span>
+          <AppInput v-model="repairScholarIds" placeholder="e.g. 12,13,14" />
+        </label>
+        <label class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2">
+          <span>Requested by (optional)</span>
+          <AppInput v-model="repairRequestedBy" placeholder="email/name/ticket id" />
+        </label>
+        <div class="flex flex-wrap items-center gap-4 md:col-span-2">
+          <AppCheckbox id="repair-dry-run" v-model="repairDryRun" label="Dry-run (no writes)" />
+          <AppCheckbox id="repair-gc-orphans" v-model="repairGcOrphans" label="Delete orphan publications" />
+        </div>
+        <label v-if="typedConfirmationRequired" class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2">
+          <span>Type '{{ APPLY_ALL_USERS_CONFIRM_TEXT }}' to confirm</span>
+          <AppInput v-model="repairConfirmationText" :placeholder="APPLY_ALL_USERS_CONFIRM_TEXT" />
+        </label>
+        <p v-if="repairScopeMode === SCOPE_ALL_USERS" class="text-xs text-secondary md:col-span-2">All-users scope includes every scholar profile across all accounts.</p>
+        <div class="md:col-span-2">
+          <AppButton type="submit" :disabled="runningRepair">{{ runningRepair ? "Running..." : "Run repair job" }}</AppButton>
+        </div>
+      </form>
+      <div v-if="lastRepairResult" class="rounded-lg border border-stroke-default bg-surface-card-muted p-3 text-xs">
+        <div class="mb-2 flex flex-wrap items-center gap-2">
+          <AppBadge :tone="statusTone(lastRepairResult.status)">Job #{{ lastRepairResult.job_id }}</AppBadge>
+          <span class="text-secondary">Status: {{ lastRepairResult.status }}</span>
+        </div>
+        <pre class="overflow-x-auto text-secondary">{{ JSON.stringify(lastRepairResult.summary, null, 2) }}</pre>
+      </div>
+    </AppCard>
+
+    <AppCard class="space-y-3">
+      <div class="flex items-center gap-1">
+        <h2 class="text-lg font-semibold text-ink-primary">Near-Duplicate Publication Repair</h2>
+        <AppHelpHint text="Run a dry-run scan first, verify candidate clusters, then merge only selected clusters." />
+      </div>
+      <form class="grid gap-3 md:grid-cols-2" @submit.prevent="onRunNearDuplicateScan">
+        <label class="grid gap-1 text-sm font-medium text-ink-secondary"><span>Similarity threshold</span><AppInput v-model="nearDuplicateSimilarityThreshold" placeholder="0.78" /></label>
+        <label class="grid gap-1 text-sm font-medium text-ink-secondary"><span>Min shared tokens</span><AppInput v-model="nearDuplicateMinSharedTokens" placeholder="3" /></label>
+        <label class="grid gap-1 text-sm font-medium text-ink-secondary"><span>Max year delta</span><AppInput v-model="nearDuplicateMaxYearDelta" placeholder="1" /></label>
+        <label class="grid gap-1 text-sm font-medium text-ink-secondary"><span>Max preview clusters</span><AppInput v-model="nearDuplicateMaxClusters" placeholder="25" /></label>
+        <label class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2"><span>Requested by (optional)</span><AppInput v-model="nearDuplicateRequestedBy" placeholder="email/name/ticket id" /></label>
+        <div class="md:col-span-2">
+          <AppButton type="submit" :disabled="runningNearDuplicateScan">{{ runningNearDuplicateScan ? "Scanning..." : "Scan near-duplicate clusters" }}</AppButton>
+        </div>
+      </form>
+      <div v-if="nearDuplicateClusters.length > 0" class="space-y-3">
+        <AppTable label="Near duplicate clusters table">
+          <thead><tr><th scope="col">Select</th><th scope="col">Cluster</th><th scope="col">Winner</th><th scope="col">Members</th><th scope="col">Similarity</th></tr></thead>
+          <tbody>
+            <tr v-for="cluster in nearDuplicateClusters" :key="cluster.cluster_key">
+              <td><input :id="`near-dup-${cluster.cluster_key}`" class="h-4 w-4 rounded border-stroke-default bg-surface-card" type="checkbox" :checked="nearDuplicateSelectedClusterKeys.has(cluster.cluster_key)" @change="onToggleNearDuplicateClusterSelection(cluster.cluster_key, checkboxEventChecked($event))" /></td>
+              <td class="font-mono text-xs">{{ cluster.cluster_key }}</td>
+              <td>#{{ cluster.winner_publication_id }}</td>
+              <td><div class="grid gap-1"><span v-for="member in cluster.members" :key="member.publication_id" class="text-xs text-secondary">#{{ member.publication_id }} · {{ member.title }}</span></div></td>
+              <td>{{ cluster.similarity_score.toFixed(2) }}</td>
+            </tr>
+          </tbody>
+        </AppTable>
+        <form class="grid gap-3 md:grid-cols-2" @submit.prevent="onApplyNearDuplicateRepair">
+          <label class="grid gap-1 text-sm font-medium text-ink-secondary md:col-span-2"><span>Type '{{ APPLY_NEAR_DUPLICATES_CONFIRM_TEXT }}' to merge selected clusters</span><AppInput v-model="nearDuplicateConfirmationText" :placeholder="APPLY_NEAR_DUPLICATES_CONFIRM_TEXT" /></label>
+          <div class="md:col-span-2"><AppButton type="submit" :disabled="applyingNearDuplicateRepair || !nearDuplicateApplyEnabled">{{ applyingNearDuplicateRepair ? "Merging..." : "Merge selected clusters" }}</AppButton></div>
+        </form>
+      </div>
+      <div v-if="lastNearDuplicateResult" class="rounded-lg border border-stroke-default bg-surface-card-muted p-3 text-xs">
+        <div class="mb-2 flex flex-wrap items-center gap-2"><AppBadge :tone="statusTone(lastNearDuplicateResult.status)">Job #{{ lastNearDuplicateResult.job_id }}</AppBadge><span class="text-secondary">Status: {{ lastNearDuplicateResult.status }}</span></div>
+        <pre class="overflow-x-auto text-secondary">{{ JSON.stringify(lastNearDuplicateResult.summary, null, 2) }}</pre>
+      </div>
+    </AppCard>
+
+    <AppCard class="space-y-3">
+      <div class="flex flex-wrap items-center justify-between gap-2">
+        <div class="flex items-center gap-1"><h2 class="text-lg font-semibold text-ink-primary">Recent Repair Jobs</h2><AppHelpHint text="Audit history and summary counters for each repair job." /></div>
+        <AppRefreshButton variant="secondary" :loading="refreshingJobs" title="Refresh repair jobs" loading-title="Refreshing repair jobs" @click="refreshRepairJobs" />
+      </div>
+      <AppTable label="Repair jobs table">
+        <thead><tr><th scope="col">Job</th><th scope="col">Status</th><th scope="col">Mode</th><th scope="col">Requested by</th><th scope="col">Created</th><th scope="col">Links in scope</th><th scope="col">Links deleted</th></tr></thead>
+        <tbody>
+          <tr v-for="job in repairJobs" :key="job.id">
+            <td>#{{ job.id }} · {{ job.job_name }}</td>
+            <td><AppBadge :tone="statusTone(job.status)">{{ job.status }}</AppBadge></td>
+            <td>{{ job.dry_run ? "dry-run" : "apply" }}</td>
+            <td>{{ job.requested_by || "n/a" }}</td>
+            <td>{{ formatTimestamp(job.created_at) }}</td>
+            <td>{{ summaryCount(job, "links_in_scope") }}</td>
+            <td>{{ summaryCount(job, "links_deleted") }}</td>
+          </tr>
+        </tbody>
+      </AppTable>
+    </AppCard>
+
+    <AppCard class="space-y-3 border-state-danger-border">
+      <div class="flex items-center gap-1"><h2 class="text-lg font-semibold text-state-danger-text">Drop All Publications</h2><AppHelpHint text="Permanently delete ALL publications, links, identifiers, and PDF jobs. Scholar baselines will be reset so the next run re-discovers everything." /></div>
+      <p class="text-sm text-secondary">This action is <strong>irreversible</strong>. It deletes every publication record across all users. The next ingestion run will re-populate all data from scratch.</p>
+      <form class="grid gap-3" @submit.prevent="onDropAllPublications">
+        <label class="grid gap-1 text-sm font-medium text-ink-secondary"><span>Type '{{ DROP_PUBLICATIONS_CONFIRM_TEXT }}' to confirm</span><AppInput v-model="dropConfirmationText" :placeholder="DROP_PUBLICATIONS_CONFIRM_TEXT" autocomplete="off" /></label>
+        <div><AppButton type="submit" variant="danger" :disabled="droppingPublications || !dropConfirmationValid">{{ droppingPublications ? "Dropping..." : "Drop all publications" }}</AppButton></div>
+      </form>
+      <div v-if="dropResult" class="rounded-lg border border-stroke-default bg-surface-card-muted p-3 text-xs">
+        <div class="mb-1 flex items-center gap-2"><AppBadge tone="danger">Deleted: {{ dropResult.deleted_count }}</AppBadge></div>
+        <p class="text-secondary">{{ dropResult.message }}</p>
+      </div>
+    </AppCard>
+  </section>
+</template>
diff --git a/frontend/src/features/settings/components/AdminUsersSection.test.ts b/frontend/src/features/settings/components/AdminUsersSection.test.ts
new file mode 100644
index 0000000..4926574
--- /dev/null
+++ b/frontend/src/features/settings/components/AdminUsersSection.test.ts
@@ -0,0 +1,84 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { mount, flushPromises } from "@vue/test-utils";
+import AdminUsersSection from "./AdminUsersSection.vue";
+
+vi.mock("@/features/admin_users", () => ({
+  listAdminUsers: vi.fn(),
+  createAdminUser: vi.fn(),
+  setAdminUserActive: vi.fn(),
+  resetAdminUserPassword: vi.fn(),
+}));
+
+import { listAdminUsers, createAdminUser } from "@/features/admin_users";
+
+const mockedListUsers = vi.mocked(listAdminUsers);
+const mockedCreateUser = vi.mocked(createAdminUser);
+
+function buildUser(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 1,
+    email: "user@example.com",
+    is_admin: false,
+    is_active: true,
+    created_at: "2025-01-01T00:00:00Z",
+    updated_at: "2025-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+describe("AdminUsersSection", () => {
+  beforeEach(() => {
+    mockedListUsers.mockReset();
+    mockedCreateUser.mockReset();
+  });
+
+  it("renders the create user form", () => {
+    const wrapper = mount(AdminUsersSection);
+    expect(wrapper.text()).toContain("Create user");
+  });
+
+  it("exposes load function that calls listAdminUsers", async () => {
+    mockedListUsers.mockResolvedValueOnce([buildUser()]);
+    const wrapper = mount(AdminUsersSection);
+    const vm = wrapper.vm as unknown as { load: () => Promise<void>; users: unknown[] };
+    await vm.load();
+    await flushPromises();
+    expect(mockedListUsers).toHaveBeenCalled();
+    expect(vm.users).toHaveLength(1);
+  });
+
+  it("renders user table after loading", async () => {
+    mockedListUsers.mockResolvedValueOnce([buildUser({ email: "alice@test.com" })]);
+    const wrapper = mount(AdminUsersSection);
+    const vm = wrapper.vm as unknown as { load: () => Promise<void> };
+    await vm.load();
+    await flushPromises();
+    expect(wrapper.text()).toContain("alice@test.com");
+  });
+
+  it("propagates error when load fails", async () => {
+    mockedListUsers.mockRejectedValueOnce(new Error("Network error"));
+    const wrapper = mount(AdminUsersSection);
+    const vm = wrapper.vm as unknown as { load: () => Promise<void> };
+    await expect(vm.load()).rejects.toThrow("Network error");
+  });
+
+  it("emits user creation via form submit", async () => {
+    mockedCreateUser.mockResolvedValueOnce(buildUser({ email: "new@test.com" }));
+    mockedListUsers.mockResolvedValue([]);
+    const wrapper = mount(AdminUsersSection);
+
+    const inputs = wrapper.findAll("input");
+    const emailInput = inputs.find((i) => (i.element as HTMLInputElement).type === "email");
+    const passwordInput = inputs.find((i) => (i.element as HTMLInputElement).type === "password");
+
+    if (emailInput && passwordInput) {
+      await emailInput.setValue("new@test.com");
+      await passwordInput.setValue("securepassword123");
+      await wrapper.find("form").trigger("submit");
+      await flushPromises();
+      expect(mockedCreateUser).toHaveBeenCalled();
+    }
+  });
+});
diff --git a/frontend/src/features/settings/components/AdminUsersSection.vue b/frontend/src/features/settings/components/AdminUsersSection.vue
new file mode 100644
index 0000000..18f6408
--- /dev/null
+++ b/frontend/src/features/settings/components/AdminUsersSection.vue
@@ -0,0 +1,211 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import AppButton from "@/components/ui/AppButton.vue";
+import AppCard from "@/components/ui/AppCard.vue";
+import AppCheckbox from "@/components/ui/AppCheckbox.vue";
+import AppHelpHint from "@/components/ui/AppHelpHint.vue";
+import AppInput from "@/components/ui/AppInput.vue";
+import AppModal from "@/components/ui/AppModal.vue";
+import AppRefreshButton from "@/components/ui/AppRefreshButton.vue";
+import AppTable from "@/components/ui/AppTable.vue";
+import {
+  createAdminUser,
+  listAdminUsers,
+  resetAdminUserPassword,
+  setAdminUserActive,
+  type AdminUser,
+} from "@/features/admin_users";
+import { useRequestState } from "@/composables/useRequestState";
+
+const { errorMessage, errorRequestId, successMessage, clearAlerts, assignError, setSuccess } = useRequestState();
+
+const refreshingUsers = ref(false);
+const creating = ref(false);
+const togglingUserId = ref<number | null>(null);
+const resettingPassword = ref(false);
+
+const users = ref<AdminUser[]>([]);
+const email = ref("");
+const password = ref("");
+const createIsAdmin = ref(false);
+const activeUserId = ref<number | null>(null);
+const resetPassword = ref("");
+
+const activeUser = computed(() => users.value.find((u) => u.id === activeUserId.value) ?? null);
+
+function userRoleLabel(user: AdminUser): string {
+  return user.is_admin ? "Admin" : "User";
+}
+
+function statusDotClass(user: AdminUser): string {
+  return user.is_active ? "bg-success-500 ring-success-200" : "bg-ink-muted/70 ring-stroke-default";
+}
+
+function formatTimestamp(value: string | null): string {
+  if (!value) return "n/a";
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? value : parsed.toLocaleString();
+}
+
+function openUserModal(user: AdminUser): void {
+  activeUserId.value = user.id;
+  resetPassword.value = "";
+}
+
+function closeUserModal(): void {
+  activeUserId.value = null;
+  resetPassword.value = "";
+}
+
+async function refreshUsers(): Promise<void> {
+  refreshingUsers.value = true;
+  try {
+    users.value = await listAdminUsers();
+    if (activeUserId.value !== null && !users.value.some((item) => item.id === activeUserId.value)) {
+      closeUserModal();
+    }
+  } finally {
+    refreshingUsers.value = false;
+  }
+}
+
+async function onCreateUser(): Promise<void> {
+  creating.value = true;
+  clearAlerts();
+  try {
+    if (!email.value.trim() || !password.value) throw new Error("Email and password are required.");
+    const created = await createAdminUser({ email: email.value.trim(), password: password.value, is_admin: createIsAdmin.value });
+    email.value = "";
+    password.value = "";
+    createIsAdmin.value = false;
+    setSuccess(`User created: ${created.email}`);
+    await refreshUsers();
+  } catch (error) {
+    assignError(error, "Unable to create user.");
+  } finally {
+    creating.value = false;
+  }
+}
+
+async function onToggleUser(user: AdminUser): Promise<void> {
+  togglingUserId.value = user.id;
+  clearAlerts();
+  try {
+    const updated = await setAdminUserActive(user.id, !user.is_active);
+    setSuccess(`${updated.email} is now ${updated.is_active ? "active" : "inactive"}.`);
+    await refreshUsers();
+  } catch (error) {
+    assignError(error, "Unable to update user.");
+  } finally {
+    togglingUserId.value = null;
+  }
+}
+
+async function onResetPassword(): Promise<void> {
+  const user = activeUser.value;
+  if (!user) return;
+  resettingPassword.value = true;
+  clearAlerts();
+  try {
+    const candidate = resetPassword.value.trim();
+    if (candidate.length < 12) throw new Error("New password must be at least 12 characters.");
+    const result = await resetAdminUserPassword(user.id, candidate);
+    resetPassword.value = "";
+    setSuccess(result.message || `Password reset for ${user.email}.`);
+  } catch (error) {
+    assignError(error, "Unable to reset password.");
+  } finally {
+    resettingPassword.value = false;
+  }
+}
+
+async function load(): Promise<void> {
+  await refreshUsers();
+}
+
+defineExpose({ load, errorMessage, errorRequestId, successMessage, users });
+</script>
+
+<template>
+  <AppCard class="space-y-4">
+    <div class="flex flex-wrap items-center justify-between gap-2">
+      <div class="flex items-center gap-1">
+        <h2 class="text-lg font-semibold text-ink-primary">Users</h2>
+        <AppHelpHint text="Create accounts, toggle active status, and reset passwords." />
+      </div>
+      <AppRefreshButton variant="secondary" :loading="refreshingUsers" title="Refresh users" loading-title="Refreshing users" @click="refreshUsers" />
+    </div>
+
+    <form class="grid gap-3 md:grid-cols-3" @submit.prevent="onCreateUser">
+      <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+        <span>Email</span>
+        <AppInput v-model="email" type="email" autocomplete="off" />
+      </label>
+      <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+        <span>Password</span>
+        <AppInput v-model="password" type="password" autocomplete="new-password" />
+      </label>
+      <div class="grid gap-2 text-sm font-medium text-ink-secondary">
+        <span>Role</span>
+        <div class="flex items-center gap-3">
+          <AppCheckbox id="admin-create-user-is-admin" v-model="createIsAdmin" label="Grant admin" />
+          <AppButton type="submit" :disabled="creating">{{ creating ? "Creating..." : "Create user" }}</AppButton>
+        </div>
+      </div>
+    </form>
+
+    <AppTable label="Users table">
+      <thead>
+        <tr>
+          <th scope="col">Email</th>
+          <th scope="col">Role</th>
+          <th scope="col">Status</th>
+          <th scope="col">Actions</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr v-for="user in users" :key="user.id">
+          <td class="align-middle">
+            <button type="button" class="group inline-flex items-center gap-2 rounded-md px-1 py-0.5 text-left text-ink-primary transition hover:bg-surface-card-muted focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset" @click="openUserModal(user)">
+              <span :class="statusDotClass(user)" class="h-2.5 w-2.5 rounded-full ring-2" :aria-label="user.is_active ? 'Active user' : 'Inactive user'" />
+              <span class="underline-offset-2 group-hover:underline">{{ user.email }}</span>
+            </button>
+          </td>
+          <td>{{ userRoleLabel(user) }}</td>
+          <td>{{ user.is_active ? "active" : "inactive" }}</td>
+          <td class="flex flex-wrap items-center gap-2">
+            <AppButton variant="secondary" :disabled="togglingUserId === user.id" @click="onToggleUser(user)">
+              {{ togglingUserId === user.id ? "Updating..." : user.is_active ? "Deactivate" : "Activate" }}
+            </AppButton>
+            <AppButton variant="ghost" @click="openUserModal(user)">Manage</AppButton>
+          </td>
+        </tr>
+      </tbody>
+    </AppTable>
+  </AppCard>
+
+  <AppModal :open="activeUser !== null" title="User settings" @close="closeUserModal">
+    <div v-if="activeUser" class="grid gap-4">
+      <div class="space-y-1">
+        <div class="flex items-center gap-2">
+          <span :class="statusDotClass(activeUser)" class="h-2.5 w-2.5 rounded-full ring-2" :aria-label="activeUser.is_active ? 'Active user' : 'Inactive user'" />
+          <p class="truncate text-sm font-semibold text-ink-primary">{{ activeUser.email }}</p>
+        </div>
+        <p class="text-sm text-secondary">Role: {{ userRoleLabel(activeUser) }}</p>
+        <p class="text-xs text-secondary">Last updated: {{ formatTimestamp(activeUser.updated_at) }}</p>
+      </div>
+      <div class="grid gap-2">
+        <label class="grid gap-1 text-sm font-medium text-ink-secondary">
+          <span>New password</span>
+          <AppInput id="admin-reset-password" v-model="resetPassword" type="password" autocomplete="new-password" placeholder="At least 12 characters" />
+        </label>
+        <div class="flex flex-wrap gap-2">
+          <AppButton :disabled="resettingPassword" @click="onResetPassword">{{ resettingPassword ? "Resetting..." : "Reset password" }}</AppButton>
+          <AppButton variant="secondary" :disabled="togglingUserId === activeUser.id" @click="onToggleUser(activeUser)">
+            {{ togglingUserId === activeUser.id ? "Updating..." : activeUser.is_active ? "Deactivate user" : "Activate user" }}
+          </AppButton>
+        </div>
+      </div>
+    </div>
+  </AppModal>
+</template>
diff --git a/frontend/src/pages/PublicationsPage.vue b/frontend/src/pages/PublicationsPage.vue
index e94074d..4f0ad86 100644
--- a/frontend/src/pages/PublicationsPage.vue
+++ b/frontend/src/pages/PublicationsPage.vue
@@ -1,359 +1,76 @@
 <script setup lang="ts">
 import { computed, onMounted, onUnmounted, ref, watch } from "vue";
-import { useRoute, useRouter } from "vue-router";
 
 import AppPage from "@/components/layout/AppPage.vue";
 import AsyncStateGate from "@/components/patterns/AsyncStateGate.vue";
 import RequestStateAlerts from "@/components/patterns/RequestStateAlerts.vue";
-import AppBadge from "@/components/ui/AppBadge.vue";
 import AppButton from "@/components/ui/AppButton.vue";
 import AppCard from "@/components/ui/AppCard.vue";
 import AppHelpHint from "@/components/ui/AppHelpHint.vue";
-import AppInput from "@/components/ui/AppInput.vue";
-import AppRefreshButton from "@/components/ui/AppRefreshButton.vue";
 import AppSelect from "@/components/ui/AppSelect.vue";
 import AppTable from "@/components/ui/AppTable.vue";
 import {
-  listPublications,
   markAllRead,
   markSelectedRead,
   retryPublicationPdf,
   togglePublicationFavorite,
   type PublicationItem,
-  type PublicationMode,
-  type PublicationsResult,
 } from "@/features/publications";
-import { listScholars, type ScholarProfile } from "@/features/scholars";
+import PublicationTableRow from "@/features/publications/components/PublicationTableRow.vue";
+import PublicationToolbar from "@/features/publications/components/PublicationToolbar.vue";
+import { publicationKey, usePublicationData } from "@/features/publications/composables/usePublicationData";
 import { ApiRequestError } from "@/lib/api/errors";
 import { useRunStatusStore } from "@/stores/run_status";
 import { useUserSettingsStore } from "@/stores/user_settings";
 
-type PublicationSortKey =
-  | "title"
-  | "scholar"
-  | "year"
-  | "citations"
-  | "first_seen"
-  | "pdf_status";
-
-type BulkAction =
-  | "mark_selected_read"
-  | "mark_all_unread_read"
-  | "select_all_visible_unread"
-  | "clear_selection";
+type BulkAction = "mark_selected_read" | "mark_all_unread_read" | "select_all_visible_unread" | "clear_selection";
 type BulkActionOption = { value: BulkAction; label: string };
 
-const loading = ref(true);
+const pub = usePublicationData();
+const runStatus = useRunStatusStore();
+const userSettings = useUserSettingsStore();
+
 const publishingAll = ref(false);
 const publishingSelected = ref(false);
-const mode = ref<PublicationMode>("all");
-const favoriteOnly = ref(false);
 const bulkAction = ref<BulkAction>("mark_all_unread_read");
-const selectedScholarFilter = ref("");
-const searchQuery = ref("");
-const sortKey = ref<PublicationSortKey>("first_seen");
-const sortDirection = ref<"asc" | "desc">("desc");
-const currentPage = ref(1);
-const pageSize = ref("50");
-const publicationSnapshot = ref<string | null>(null);
-
-const scholars = ref<ScholarProfile[]>([]);
-const listState = ref<PublicationsResult | null>(null);
 const selectedPublicationKeys = ref<Set<string>>(new Set());
 const retryingPublicationKeys = ref<Set<string>>(new Set());
 const favoriteUpdatingKeys = ref<Set<string>>(new Set());
 
-const errorMessage = ref<string | null>(null);
-const errorRequestId = ref<string | null>(null);
-const successMessage = ref<string | null>(null);
-const route = useRoute();
-const router = useRouter();
-const textCollator = new Intl.Collator(undefined, { sensitivity: "base", numeric: true });
-const runStatus = useRunStatusStore();
-const userSettings = useUserSettingsStore();
 const PUBLICATIONS_RUN_STATUS_SYNC_INTERVAL_MS = 5000;
 let runStatusSyncTimer: ReturnType<typeof setInterval> | null = null;
 
-function normalizeScholarFilterQuery(value: unknown): string {
-  if (Array.isArray(value)) {
-    return normalizeScholarFilterQuery(value[0]);
-  }
-  if (typeof value !== "string") {
-    return "";
-  }
-  const parsed = Number(value);
-  return Number.isInteger(parsed) && parsed > 0 ? String(parsed) : "";
-}
-
-function normalizeFavoriteOnlyQuery(value: unknown): boolean {
-  if (Array.isArray(value)) {
-    return normalizeFavoriteOnlyQuery(value[0]);
-  }
-  if (typeof value !== "string") {
-    return false;
-  }
-  const normalized = value.trim().toLowerCase();
-  return normalized === "1" || normalized === "true" || normalized === "yes";
-}
-
-function normalizePageQuery(value: unknown): number {
-  if (Array.isArray(value)) {
-    return normalizePageQuery(value[0]);
-  }
-  if (typeof value !== "string") {
-    return 1;
-  }
-  const parsed = Number(value);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : 1;
-}
-
-function syncFiltersFromRoute(): boolean {
-  let changed = false;
-  const nextScholar = normalizeScholarFilterQuery(route.query.scholar);
-  const nextFavoriteOnly = normalizeFavoriteOnlyQuery(route.query.favorite);
-  const nextPage = normalizePageQuery(route.query.page);
-  if (selectedScholarFilter.value !== nextScholar) {
-    selectedScholarFilter.value = nextScholar;
-    changed = true;
-  }
-  if (favoriteOnly.value !== nextFavoriteOnly) {
-    favoriteOnly.value = nextFavoriteOnly;
-    changed = true;
-  }
-  if (currentPage.value !== nextPage) {
-    currentPage.value = nextPage;
-    changed = true;
-  }
-  return changed;
-}
-
-async function syncFiltersToRoute(): Promise<void> {
-  const nextScholar = selectedScholarFilter.value.trim();
-  const currentScholar = normalizeScholarFilterQuery(route.query.scholar);
-  const currentFavoriteOnly = normalizeFavoriteOnlyQuery(route.query.favorite);
-  const currentPageQuery = normalizePageQuery(route.query.page);
-
-  if (
-    nextScholar === currentScholar
-    && favoriteOnly.value === currentFavoriteOnly
-    && currentPage.value === currentPageQuery
-  ) {
-    return;
-  }
-
-  await router.replace({
-    query: {
-      ...route.query,
-      scholar: nextScholar || undefined,
-      favorite: favoriteOnly.value ? "1" : undefined,
-      page: currentPage.value > 1 ? String(currentPage.value) : undefined,
-    },
-  });
-}
-
-function formatDate(value: string): string {
-  const asDate = new Date(value);
-  if (Number.isNaN(asDate.getTime())) {
-    return value;
-  }
-  return asDate.toLocaleDateString();
-}
-
-function publicationKey(item: PublicationItem): string {
-  return `${item.scholar_profile_id}:${item.publication_id}`;
-}
-
-function scholarLabel(item: ScholarProfile): string {
-  return item.display_name || item.scholar_id;
-}
-
-function publicationPrimaryUrl(item: PublicationItem): string | null {
-  return item.pub_url || item.pdf_url;
-}
-
-function publicationIdentifierUrl(item: PublicationItem): string | null {
-  if (!item.display_identifier?.url) {
-    return null;
-  }
-  return item.display_identifier.url;
-}
-
-function publicationIdentifierLabel(item: PublicationItem): string | null {
-  return item.display_identifier?.label ?? null;
-}
-
 function startRunStatusSyncLoop(): void {
-  if (runStatusSyncTimer !== null) {
-    return;
-  }
+  if (runStatusSyncTimer !== null) return;
   runStatusSyncTimer = setInterval(() => {
-    if (runStatus.isRunActive) {
-      return;
-    }
+    if (runStatus.isRunActive) return;
     void runStatus.syncLatest();
   }, PUBLICATIONS_RUN_STATUS_SYNC_INTERVAL_MS);
 }
 
 function stopRunStatusSyncLoop(): void {
-  if (runStatusSyncTimer === null) {
-    return;
-  }
+  if (runStatusSyncTimer === null) return;
   clearInterval(runStatusSyncTimer);
   runStatusSyncTimer = null;
 }
 
-const selectedScholarName = computed(() => {
-  const selectedId = Number(selectedScholarFilter.value);
-  if (!Number.isInteger(selectedId) || selectedId <= 0) {
-    return "all scholars";
-  }
-  const profile = scholars.value.find((item) => item.id === selectedId);
-  return profile ? scholarLabel(profile) : "the selected scholar";
-});
-
-const filteredPublications = computed(() => {
-  let stream = [...runStatus.livePublications];
-  if (favoriteOnly.value) {
-    stream = stream.filter((p) => p.is_favorite);
-  }
-  if (mode.value === "unread") {
-    stream = stream.filter((p) => !p.is_read);
-  }
-  const selectedScholarId = Number(selectedScholarFilter.value);
-  if (Number.isInteger(selectedScholarId) && selectedScholarId > 0) {
-    stream = stream.filter((p) => p.scholar_profile_id === selectedScholarId);
-  }
-
-  const base = listState.value?.publications ?? [];
-  const merged = [...stream, ...base];
-  const seenKeys = new Set<string>();
-  const deduped: typeof base = [];
-  for (const item of merged) {
-    const key = publicationKey(item);
-    if (!seenKeys.has(key)) {
-      seenKeys.add(key);
-      deduped.push(item);
-    }
-  }
-
-  const normalized = searchQuery.value.trim().toLowerCase();
-  if (!normalized) {
-    return deduped;
-  }
-  // Client-side fallback: filter live-discovered publications that haven't been
-  // server-round-tripped yet. The main server query already filters by search.
-  return deduped;
-});
-
-function publicationSortValue(item: PublicationItem, key: PublicationSortKey): number | string {
-  if (key === "title") {
-    return item.title;
-  }
-  if (key === "scholar") {
-    return item.scholar_label;
-  }
-  if (key === "year") {
-    return item.year ?? -1;
-  }
-  if (key === "citations") {
-    return item.citation_count;
-  }
-  if (key === "pdf_status") {
-    if (item.pdf_url || item.pdf_status === "resolved") {
-      return 4;
-    }
-    if (item.pdf_status === "running") {
-      return 3;
-    }
-    if (item.pdf_status === "queued") {
-      return 2;
-    }
-    if (item.pdf_status === "failed") {
-      return 0;
-    }
-    return 1;
-  }
-  const timestamp = Date.parse(item.first_seen_at);
-  return Number.isNaN(timestamp) ? 0 : timestamp;
-}
-
-const sortedPublications = computed(() => {
-  const direction = sortDirection.value === "asc" ? 1 : -1;
-  return [...filteredPublications.value].sort((left, right) => {
-    const leftValue = publicationSortValue(left, sortKey.value);
-    const rightValue = publicationSortValue(right, sortKey.value);
-    let comparison = 0;
-    if (typeof leftValue === "string" && typeof rightValue === "string") {
-      comparison = textCollator.compare(leftValue, rightValue);
-    } else {
-      comparison = Number(leftValue) - Number(rightValue);
-    }
-    if (comparison !== 0) {
-      return comparison * direction;
-    }
-    return right.publication_id - left.publication_id;
-  });
-});
-
-const visibleUnreadKeys = computed(() => {
-  const keys = new Set<string>();
-  for (const item of sortedPublications.value) {
-    if (!item.is_read) {
-      keys.add(publicationKey(item));
-    }
-  }
-  return keys;
-});
-
-const pageSizeValue = computed(() => {
-  const parsed = Number(pageSize.value);
-  if (!Number.isInteger(parsed)) {
-    return 50;
-  }
-  return Math.max(10, Math.min(200, parsed));
-});
-const hasNextPage = computed(() => Boolean(listState.value?.has_next));
-const hasPrevPage = computed(() => Boolean(listState.value?.has_prev));
-const totalPages = computed(() => {
-  if (!listState.value) {
-    return 1;
-  }
-  return Math.max(1, Math.ceil(listState.value.total_count / Math.max(listState.value.page_size, 1)));
-});
+// --- Computed ---
 
 const selectedCount = computed(() => selectedPublicationKeys.value.size);
-const totalCount = computed(() => listState.value?.total_count ?? 0);
-const visibleCount = computed(() => sortedPublications.value.length);
-const visibleUnreadCount = computed(() => visibleUnreadKeys.value.size);
-const visibleFavoriteCount = computed(
-  () => sortedPublications.value.filter((item) => item.is_favorite).length,
-);
-const actionBusy = computed(() => loading.value || publishingAll.value || publishingSelected.value);
+const actionBusy = computed(() => pub.loading.value || publishingAll.value || publishingSelected.value);
 const startRunDisabledReason = computed(() => {
-  if (!userSettings.manualRunAllowed) {
-    return "Manual runs are disabled by policy.";
-  }
+  if (!userSettings.manualRunAllowed) return "Manual runs are disabled by policy.";
   if (runStatus.safetyState.cooldown_active) {
     return runStatus.safetyState.cooldown_reason_label || "Safety cooldown is active.";
   }
-  if (runStatus.isRunActive) {
-    return "A run is already in progress.";
-  }
+  if (runStatus.isRunActive) return "A run is already in progress.";
   return null;
 });
 const startRunButtonLabel = computed(() => {
-  if (runStatus.isSubmitting) {
-    return "Starting...";
-  }
-  if (!userSettings.manualRunAllowed) {
-    return "Manual runs disabled";
-  }
-  if (runStatus.safetyState.cooldown_active) {
-    return "Safety cooldown";
-  }
-  if (runStatus.isLikelyRunning) {
-    return "Run active";
-  }
+  if (runStatus.isSubmitting) return "Starting...";
+  if (!userSettings.manualRunAllowed) return "Manual runs disabled";
+  if (runStatus.safetyState.cooldown_active) return "Safety cooldown";
+  if (runStatus.isLikelyRunning) return "Run active";
   return "Start run";
 });
 const startRunDisabled = computed(() => Boolean(startRunDisabledReason.value) || runStatus.isSubmitting);
@@ -361,14 +78,8 @@ const hasSelection = computed(() => selectedCount.value > 0);
 const bulkActionOptions = computed<BulkActionOption[]>(() => {
   if (hasSelection.value) {
     return [
-      {
-        value: "mark_selected_read",
-        label: `Mark selected as read (${selectedCount.value})`,
-      },
-      {
-        value: "clear_selection",
-        label: `Clear selection (${selectedCount.value})`,
-      },
+      { value: "mark_selected_read", label: `Mark selected as read (${selectedCount.value})` },
+      { value: "clear_selection", label: `Clear selection (${selectedCount.value})` },
     ];
   }
   return [
@@ -377,346 +88,134 @@ const bulkActionOptions = computed<BulkActionOption[]>(() => {
   ];
 });
 const bulkApplyDisabled = computed(() => {
-  if (actionBusy.value) {
-    return true;
-  }
+  if (actionBusy.value) return true;
   if (bulkAction.value === "mark_selected_read" || bulkAction.value === "clear_selection") {
     return selectedCount.value === 0;
   }
   if (bulkAction.value === "mark_all_unread_read" || bulkAction.value === "select_all_visible_unread") {
-    return visibleUnreadCount.value === 0;
+    return pub.visibleUnreadCount.value === 0;
   }
   return false;
 });
 const bulkApplyLabel = computed(() => {
-  if (publishingSelected.value || publishingAll.value) {
-    return "Applying...";
-  }
-  if (bulkAction.value === "select_all_visible_unread") {
-    return "Select";
-  }
-  if (bulkAction.value === "clear_selection") {
-    return "Clear";
-  }
+  if (publishingSelected.value || publishingAll.value) return "Applying...";
+  if (bulkAction.value === "select_all_visible_unread") return "Select";
+  if (bulkAction.value === "clear_selection") return "Clear";
   return "Apply";
 });
-const showingEmptyList = computed(() => Boolean(listState.value) && sortedPublications.value.length === 0);
+const showingEmptyList = computed(() => Boolean(pub.listState.value) && pub.sortedPublications.value.length === 0);
 const scopeLabel = computed(() => {
-  if (mode.value === "latest" && favoriteOnly.value) {
-    return "New + Favorites";
-  }
-  if (mode.value === "latest") {
-    return "New";
-  }
-  if (mode.value === "unread" && favoriteOnly.value) {
-    return "Unread + Favorites";
-  }
-  if (mode.value === "unread") {
-    return "Unread";
-  }
-  if (favoriteOnly.value) {
-    return "All + Favorites";
-  }
+  if (pub.mode.value === "latest" && pub.favoriteOnly.value) return "New + Favorites";
+  if (pub.mode.value === "latest") return "New";
+  if (pub.mode.value === "unread" && pub.favoriteOnly.value) return "Unread + Favorites";
+  if (pub.mode.value === "unread") return "Unread";
+  if (pub.favoriteOnly.value) return "All + Favorites";
   return "All";
 });
-
 const emptyTitle = computed(() =>
-  searchQuery.value.trim().length > 0 ? "No publications match this search" : "No publications found",
+  pub.searchQuery.value.trim().length > 0 ? "No publications match this search" : "No publications found",
 );
-
 const emptyBody = computed(() => {
-  if (searchQuery.value.trim().length > 0) {
-    return "Try another title, scholar, venue, or year.";
-  }
-  if (favoriteOnly.value && mode.value === "latest") {
-    return `No new favorites for ${selectedScholarName.value}.`;
-  }
-  if (mode.value === "latest") {
-    return `No new publications in the latest run for ${selectedScholarName.value}.`;
-  }
-  if (favoriteOnly.value && mode.value === "unread") {
-    return `No unread favorites for ${selectedScholarName.value}.`;
-  }
-  if (favoriteOnly.value) {
-    return `No favorites for ${selectedScholarName.value}.`;
-  }
-  if (mode.value === "unread") {
-    return `No unread publications for ${selectedScholarName.value}.`;
-  }
-  return `No publication records for ${selectedScholarName.value}.`;
+  if (pub.searchQuery.value.trim().length > 0) return "Try another title, scholar, venue, or year.";
+  if (pub.favoriteOnly.value && pub.mode.value === "latest") return `No new favorites for ${pub.selectedScholarName.value}.`;
+  if (pub.mode.value === "latest") return `No new publications in the latest run for ${pub.selectedScholarName.value}.`;
+  if (pub.favoriteOnly.value && pub.mode.value === "unread") return `No unread favorites for ${pub.selectedScholarName.value}.`;
+  if (pub.favoriteOnly.value) return `No favorites for ${pub.selectedScholarName.value}.`;
+  if (pub.mode.value === "unread") return `No unread publications for ${pub.selectedScholarName.value}.`;
+  return `No publication records for ${pub.selectedScholarName.value}.`;
 });
-
 const allVisibleUnreadSelected = computed(() => {
-  if (visibleUnreadKeys.value.size === 0) {
-    return false;
-  }
-  for (const key of visibleUnreadKeys.value) {
-    if (!selectedPublicationKeys.value.has(key)) {
-      return false;
-    }
+  if (pub.visibleUnreadKeys.value.size === 0) return false;
+  for (const key of pub.visibleUnreadKeys.value) {
+    if (!selectedPublicationKeys.value.has(key)) return false;
   }
   return true;
 });
 
-watch(sortedPublications, (items) => {
+// --- Watchers ---
+
+watch(pub.sortedPublications, (items) => {
   const validKeys = new Set(items.filter((item) => !item.is_read).map((item) => publicationKey(item)));
   const next = new Set<string>();
   for (const key of selectedPublicationKeys.value) {
-    if (validKeys.has(key)) {
-      next.add(key);
-    }
-  }
-  if (next.size !== selectedPublicationKeys.value.size) {
-    selectedPublicationKeys.value = next;
+    if (validKeys.has(key)) next.add(key);
   }
+  if (next.size !== selectedPublicationKeys.value.size) selectedPublicationKeys.value = next;
 });
 
 watch(hasSelection, (nextHasSelection) => {
   const validValues = new Set(bulkActionOptions.value.map((item) => item.value));
-  if (validValues.has(bulkAction.value)) {
-    return;
-  }
+  if (validValues.has(bulkAction.value)) return;
   bulkAction.value = nextHasSelection ? "mark_selected_read" : "mark_all_unread_read";
 });
 
-async function toggleSort(nextKey: PublicationSortKey): Promise<void> {
-  if (sortKey.value === nextKey) {
-    sortDirection.value = sortDirection.value === "asc" ? "desc" : "asc";
-  } else {
-    sortKey.value = nextKey;
-    sortDirection.value = nextKey === "first_seen" || nextKey === "pdf_status" ? "desc" : "asc";
-  }
-  currentPage.value = 1;
-  publicationSnapshot.value = null;
-  await loadPublications();
-}
-
-function sortMarker(key: PublicationSortKey): string {
-  if (sortKey.value !== key) {
-    return "↕";
-  }
-  return sortDirection.value === "asc" ? "↑" : "↓";
-}
-
-async function loadScholarFilters(): Promise<void> {
-  try {
-    scholars.value = await listScholars();
-  } catch {
-    scholars.value = [];
-  }
-}
-
-function selectedScholarId(): number | undefined {
-  const parsed = Number(selectedScholarFilter.value);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
-}
-
-async function loadPublications(): Promise<void> {
-  loading.value = true;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-
-  try {
-    listState.value = await listPublications({
-      mode: mode.value,
-      favoriteOnly: favoriteOnly.value,
-      scholarProfileId: selectedScholarId(),
-      search: searchQuery.value.trim() || undefined,
-      sortBy: sortKey.value,
-      sortDir: sortDirection.value,
-      page: currentPage.value,
-      pageSize: pageSizeValue.value,
-      snapshot: publicationSnapshot.value ?? undefined,
-    });
-    publicationSnapshot.value = listState.value.snapshot;
-    currentPage.value = listState.value.page;
-    pageSize.value = String(listState.value.page_size);
-    selectedPublicationKeys.value = new Set();
-  } catch (error) {
-    listState.value = null;
-    selectedPublicationKeys.value = new Set();
-    if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
-    } else {
-      errorMessage.value = "Unable to load publications.";
-    }
-  } finally {
-    loading.value = false;
-  }
-}
+// --- Filter change handlers ---
 
 async function onModeChanged(): Promise<void> {
-  currentPage.value = 1;
-  publicationSnapshot.value = null;
-  await syncFiltersToRoute();
-  await loadPublications();
+  pub.resetPageAndSnapshot();
+  await pub.syncFiltersToRoute();
+  await pub.loadPublications();
 }
 
 async function onScholarFilterChanged(): Promise<void> {
-  currentPage.value = 1;
-  publicationSnapshot.value = null;
-  await syncFiltersToRoute();
-  await loadPublications();
+  pub.resetPageAndSnapshot();
+  await pub.syncFiltersToRoute();
+  await pub.loadPublications();
 }
 
 async function onFavoriteOnlyChanged(): Promise<void> {
-  favoriteOnly.value = !favoriteOnly.value;
-  currentPage.value = 1;
-  publicationSnapshot.value = null;
-  await syncFiltersToRoute();
-  await loadPublications();
+  pub.favoriteOnly.value = !pub.favoriteOnly.value;
+  pub.resetPageAndSnapshot();
+  await pub.syncFiltersToRoute();
+  await pub.loadPublications();
 }
 
 async function onPageSizeChanged(): Promise<void> {
-  currentPage.value = 1;
-  publicationSnapshot.value = null;
-  await syncFiltersToRoute();
-  await loadPublications();
+  pub.resetPageAndSnapshot();
+  await pub.syncFiltersToRoute();
+  await pub.loadPublications();
 }
 
 async function onPrevPage(): Promise<void> {
-  if (!hasPrevPage.value || currentPage.value <= 1) {
-    return;
-  }
-  currentPage.value -= 1;
-  await syncFiltersToRoute();
-  await loadPublications();
+  if (!pub.hasPrevPage.value || pub.currentPage.value <= 1) return;
+  pub.currentPage.value -= 1;
+  await pub.syncFiltersToRoute();
+  await pub.loadPublications();
 }
 
 async function onNextPage(): Promise<void> {
-  if (!hasNextPage.value) {
-    return;
-  }
-  currentPage.value += 1;
-  await syncFiltersToRoute();
-  await loadPublications();
+  if (!pub.hasNextPage.value) return;
+  pub.currentPage.value += 1;
+  await pub.syncFiltersToRoute();
+  await pub.loadPublications();
 }
 
-function selectAllVisibleUnread(): void {
-  selectedPublicationKeys.value = new Set(visibleUnreadKeys.value);
-}
-
-function clearSelection(): void {
-  selectedPublicationKeys.value = new Set();
-}
-
-async function onApplyBulkAction(): Promise<void> {
-  if (bulkApplyDisabled.value) {
-    return;
-  }
-  if (bulkAction.value === "select_all_visible_unread") {
-    selectAllVisibleUnread();
-    return;
-  }
-  if (bulkAction.value === "clear_selection") {
-    clearSelection();
-    return;
-  }
-  if (bulkAction.value === "mark_selected_read") {
-    await onMarkSelectedRead();
-    return;
-  }
-  await onMarkAllRead();
-}
-
-function onToggleAllVisible(event: Event): void {
-  const checked = (event.target as HTMLInputElement).checked;
-  const next = new Set(selectedPublicationKeys.value);
-  for (const key of visibleUnreadKeys.value) {
-    if (checked) {
-      next.add(key);
-    } else {
-      next.delete(key);
-    }
-  }
-  selectedPublicationKeys.value = next;
-}
-
-function onToggleRowSelection(item: PublicationItem, event: Event): void {
-  const checked = (event.target as HTMLInputElement).checked;
-  const key = publicationKey(item);
-  const next = new Set(selectedPublicationKeys.value);
-  if (checked) {
-    next.add(key);
-  } else {
-    next.delete(key);
-  }
-  selectedPublicationKeys.value = next;
-}
-
-function isRetryingPublication(item: PublicationItem): boolean {
-  return retryingPublicationKeys.value.has(publicationKey(item));
-}
-
-function isFavoriteUpdating(item: PublicationItem): boolean {
-  return favoriteUpdatingKeys.value.has(publicationKey(item));
-}
+// --- Row actions ---
 
 function canRetryPublicationPdf(item: PublicationItem): boolean {
   return !item.pdf_url && item.pdf_status === "failed" && item.pdf_attempt_count > 0;
 }
 
-function pdfPendingLabel(item: PublicationItem): string {
-  if (item.pdf_status === "queued") {
-    return "Queued";
-  }
-  if (item.pdf_status === "running") {
-    return "Resolving...";
-  }
-  if (item.pdf_status === "failed") {
-    return "Missing";
-  }
-  return "Untracked";
-}
-
-function replacePublication(updated: PublicationItem): void {
-  if (!listState.value) {
-    return;
-  }
-  listState.value.publications = listState.value.publications.map((item) => {
-    if (publicationKey(item) !== publicationKey(updated)) {
-      return item;
-    }
-    return updated;
-  });
-}
-
-function withFavorite(item: PublicationItem, isFavorite: boolean): PublicationItem {
-  return {
-    ...item,
-    is_favorite: isFavorite,
-  };
-}
-
 async function onToggleFavorite(item: PublicationItem): Promise<void> {
-  if (isFavoriteUpdating(item)) {
-    return;
-  }
   const key = publicationKey(item);
+  if (favoriteUpdatingKeys.value.has(key)) return;
   const nextFavorite = !item.is_favorite;
   const nextUpdating = new Set(favoriteUpdatingKeys.value);
   nextUpdating.add(key);
   favoriteUpdatingKeys.value = nextUpdating;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-
-  replacePublication(withFavorite(item, nextFavorite));
-
+  pub.errorMessage.value = null;
+  pub.errorRequestId.value = null;
+  pub.replacePublication({ ...item, is_favorite: nextFavorite });
   try {
-    const response = await togglePublicationFavorite(
-      item.publication_id,
-      item.scholar_profile_id,
-      nextFavorite,
-    );
-    replacePublication(response.publication);
+    const response = await togglePublicationFavorite(item.publication_id, item.scholar_profile_id, nextFavorite);
+    pub.replacePublication(response.publication);
   } catch (error) {
-    replacePublication(withFavorite(item, item.is_favorite));
+    pub.replacePublication({ ...item, is_favorite: item.is_favorite });
     if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
+      pub.errorMessage.value = error.message;
+      pub.errorRequestId.value = error.requestId;
     } else {
-      errorMessage.value = "Unable to update favorite state.";
+      pub.errorMessage.value = "Unable to update favorite state.";
     }
   } finally {
     const cleared = new Set(favoriteUpdatingKeys.value);
@@ -726,27 +225,24 @@ async function onToggleFavorite(item: PublicationItem): Promise<void> {
 }
 
 async function onRetryPdf(item: PublicationItem): Promise<void> {
-  if (item.pdf_url || !canRetryPublicationPdf(item)) {
-    return;
-  }
+  if (item.pdf_url || !canRetryPublicationPdf(item)) return;
   const key = publicationKey(item);
   const next = new Set(retryingPublicationKeys.value);
   next.add(key);
   retryingPublicationKeys.value = next;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-  successMessage.value = null;
-
+  pub.errorMessage.value = null;
+  pub.errorRequestId.value = null;
+  pub.successMessage.value = null;
   try {
     const response = await retryPublicationPdf(item.publication_id, item.scholar_profile_id);
-    replacePublication(response.publication);
-    successMessage.value = response.message;
+    pub.replacePublication(response.publication);
+    pub.successMessage.value = response.message;
   } catch (error) {
     if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
+      pub.errorMessage.value = error.message;
+      pub.errorRequestId.value = error.requestId;
     } else {
-      errorMessage.value = "Unable to retry PDF lookup for this publication.";
+      pub.errorMessage.value = "Unable to retry PDF lookup for this publication.";
     }
   } finally {
     const cleared = new Set(retryingPublicationKeys.value);
@@ -755,34 +251,57 @@ async function onRetryPdf(item: PublicationItem): Promise<void> {
   }
 }
 
-async function onMarkSelectedRead(): Promise<void> {
-  if (selectedPublicationKeys.value.size === 0 || !listState.value) {
+// --- Bulk actions ---
+
+function onToggleAllVisible(event: Event): void {
+  const checked = (event.target as HTMLInputElement).checked;
+  const next = new Set(selectedPublicationKeys.value);
+  for (const key of pub.visibleUnreadKeys.value) {
+    if (checked) { next.add(key); } else { next.delete(key); }
+  }
+  selectedPublicationKeys.value = next;
+}
+
+function onToggleRowSelection(item: PublicationItem, event: Event): void {
+  const checked = (event.target as HTMLInputElement).checked;
+  const key = publicationKey(item);
+  const next = new Set(selectedPublicationKeys.value);
+  if (checked) { next.add(key); } else { next.delete(key); }
+  selectedPublicationKeys.value = next;
+}
+
+async function onApplyBulkAction(): Promise<void> {
+  if (bulkApplyDisabled.value) return;
+  if (bulkAction.value === "select_all_visible_unread") {
+    selectedPublicationKeys.value = new Set(pub.visibleUnreadKeys.value);
     return;
   }
+  if (bulkAction.value === "clear_selection") { selectedPublicationKeys.value = new Set(); return; }
+  if (bulkAction.value === "mark_selected_read") { await onMarkSelectedRead(); return; }
+  await onMarkAllRead();
+}
 
+async function onMarkSelectedRead(): Promise<void> {
+  if (selectedPublicationKeys.value.size === 0 || !pub.listState.value) return;
   const selectedLookup = new Set(selectedPublicationKeys.value);
-  const selections = listState.value.publications
+  const selections = pub.listState.value.publications
     .filter((item) => selectedLookup.has(publicationKey(item)))
-    .map((item) => ({
-      scholar_profile_id: item.scholar_profile_id,
-      publication_id: item.publication_id,
-    }));
-
+    .map((item) => ({ scholar_profile_id: item.scholar_profile_id, publication_id: item.publication_id }));
   publishingSelected.value = true;
-  successMessage.value = null;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-
+  pub.successMessage.value = null;
+  pub.errorMessage.value = null;
+  pub.errorRequestId.value = null;
   try {
     const response = await markSelectedRead(selections);
-    successMessage.value = `${response.updated_count} publication${response.updated_count === 1 ? "" : "s"} marked as read.`;
-    await loadPublications();
+    pub.successMessage.value = `${response.updated_count} publication${response.updated_count === 1 ? "" : "s"} marked as read.`;
+    selectedPublicationKeys.value = new Set();
+    await pub.loadPublications();
   } catch (error) {
     if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
+      pub.errorMessage.value = error.message;
+      pub.errorRequestId.value = error.requestId;
     } else {
-      errorMessage.value = "Unable to mark selected publications as read.";
+      pub.errorMessage.value = "Unable to mark selected publications as read.";
     }
   } finally {
     publishingSelected.value = false;
@@ -791,20 +310,20 @@ async function onMarkSelectedRead(): Promise<void> {
 
 async function onMarkAllRead(): Promise<void> {
   publishingAll.value = true;
-  successMessage.value = null;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-
+  pub.successMessage.value = null;
+  pub.errorMessage.value = null;
+  pub.errorRequestId.value = null;
   try {
     const response = await markAllRead();
-    successMessage.value = `${response.updated_count} publication${response.updated_count === 1 ? "" : "s"} marked as read.`;
-    await loadPublications();
+    pub.successMessage.value = `${response.updated_count} publication${response.updated_count === 1 ? "" : "s"} marked as read.`;
+    selectedPublicationKeys.value = new Set();
+    await pub.loadPublications();
   } catch (error) {
     if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
+      pub.errorMessage.value = error.message;
+      pub.errorRequestId.value = error.requestId;
     } else {
-      errorMessage.value = "Unable to mark publications as read.";
+      pub.errorMessage.value = "Unable to mark publications as read.";
     }
   } finally {
     publishingAll.value = false;
@@ -812,90 +331,31 @@ async function onMarkAllRead(): Promise<void> {
 }
 
 async function onStartRun(): Promise<void> {
-  if (startRunDisabled.value) {
-    return;
-  }
-  successMessage.value = null;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-
+  if (startRunDisabled.value) return;
+  pub.successMessage.value = null;
+  pub.errorMessage.value = null;
+  pub.errorRequestId.value = null;
   const result = await runStatus.startManualCheck();
-  if (result.kind === "started") {
-    successMessage.value = `Run #${result.runId} started.`;
-    return;
-  }
+  if (result.kind === "started") { pub.successMessage.value = `Run #${result.runId} started.`; return; }
   if (result.kind === "already_running") {
-    successMessage.value = result.runId
-      ? `Run #${result.runId} is already in progress.`
-      : "A run is already in progress.";
+    pub.successMessage.value = result.runId ? `Run #${result.runId} is already in progress.` : "A run is already in progress.";
     return;
   }
-  errorMessage.value = result.message;
-  errorRequestId.value = result.requestId;
+  pub.errorMessage.value = result.message;
+  pub.errorRequestId.value = result.requestId;
 }
 
-function resetSearchQuery(): void {
-  searchQuery.value = "";
-}
-
-let searchDebounceTimer: ReturnType<typeof setTimeout> | null = null;
-watch(searchQuery, () => {
-  if (searchDebounceTimer !== null) {
-    clearTimeout(searchDebounceTimer);
-  }
-  searchDebounceTimer = setTimeout(() => {
-    currentPage.value = 1;
-    publicationSnapshot.value = null;
-    void loadPublications();
-  }, 300);
-});
+// --- Lifecycle ---
 
 onMounted(() => {
-  syncFiltersFromRoute();
+  pub.syncFiltersFromRoute();
   startRunStatusSyncLoop();
-  void Promise.all([loadScholarFilters(), loadPublications(), runStatus.syncLatest()]);
+  void Promise.all([pub.loadScholarFilters(), pub.loadPublications(), runStatus.syncLatest()]);
 });
 
 onUnmounted(() => {
   stopRunStatusSyncLoop();
 });
-
-watch(
-  () => runStatus.latestRun,
-  async (nextRun, previousRun) => {
-    const nextRunId = nextRun && (nextRun.status === "running" || nextRun.status === "resolving")
-      ? nextRun.id
-      : null;
-    const previousRunId = previousRun && (previousRun.status === "running" || previousRun.status === "resolving")
-      ? previousRun.id
-      : null;
-    if (nextRunId === null || nextRunId === previousRunId) {
-      return;
-    }
-    publicationSnapshot.value = null;
-    currentPage.value = 1;
-    await loadPublications();
-  },
-);
-
-watch(
-  () => [route.query.scholar, route.query.favorite, route.query.page],
-  async () => {
-    const previousScholar = selectedScholarFilter.value;
-    const previousFavorite = favoriteOnly.value;
-    const changed = syncFiltersFromRoute();
-    if (!changed) {
-      return;
-    }
-    if (
-      selectedScholarFilter.value !== previousScholar
-      || favoriteOnly.value !== previousFavorite
-    ) {
-      publicationSnapshot.value = null;
-    }
-    await loadPublications();
-  },
-);
 </script>
 
 <template>
@@ -906,117 +366,50 @@ watch(
   >
     <div class="flex min-h-0 flex-1 flex-col gap-4 xl:overflow-hidden">
       <AppCard class="flex min-h-0 flex-1 flex-col gap-4">
-      <div class="grid gap-3 xl:grid-cols-[minmax(0,13rem)_minmax(0,18rem)_minmax(0,1fr)_auto] xl:items-end">
-        <div class="grid gap-1 text-xs text-secondary">
-          <div class="flex items-center gap-1">
-            <span>Status</span>
-            <AppHelpHint text="All shows full history. Unread and New narrow the dataset before search." />
-          </div>
-          <AppSelect v-model="mode" :disabled="actionBusy" @change="onModeChanged">
-            <option value="all">All records</option>
-            <option value="unread">Unread</option>
-            <option value="latest">New (latest run)</option>
-          </AppSelect>
-        </div>
-
-        <label class="grid gap-1 text-xs text-secondary" for="publications-scholar-filter">
-          <span class="inline-flex items-center gap-1">
-            Scholar
-            <AppHelpHint text="Filter to one tracked scholar profile. Filter is synced to URL query." />
-          </span>
-          <AppSelect
-            id="publications-scholar-filter"
-            v-model="selectedScholarFilter"
-            :disabled="actionBusy"
-            @change="onScholarFilterChanged"
-          >
-            <option value="">All scholars</option>
-            <option v-for="scholar in scholars" :key="scholar.id" :value="String(scholar.id)">
-              {{ scholarLabel(scholar) }}
-            </option>
-          </AppSelect>
-        </label>
-
-        <label class="grid gap-1 text-xs text-secondary" for="publications-search-input">
-          <span class="inline-flex items-center gap-1">
-            Search
-            <AppHelpHint text="Searches title, scholar name, and venue." />
-          </span>
-          <div class="flex min-w-0 items-center gap-2">
-            <AppInput
-              id="publications-search-input"
-              v-model="searchQuery"
-              placeholder="Search title, scholar, venue, year"
-              :disabled="loading"
-            />
-            <AppButton
-              v-if="searchQuery.trim().length > 0"
-              variant="secondary"
-              class="shrink-0"
-              :disabled="loading"
-              @click="resetSearchQuery"
-            >
-              Clear
-            </AppButton>
-          </div>
-        </label>
-
-        <div class="flex flex-wrap items-end justify-end gap-2">
-          <button
-            type="button"
-            class="favorite-filter-button"
-            :class="favoriteOnly ? 'favorite-filter-on' : 'favorite-filter-off'"
-            :disabled="actionBusy"
-            :title="favoriteOnly ? 'Favorites-only filter is active' : 'Show only favorites'"
-            :aria-pressed="favoriteOnly"
-            :aria-label="favoriteOnly ? 'Disable favorites-only filter' : 'Enable favorites-only filter'"
-            @click="onFavoriteOnlyChanged"
-          >
-            <span aria-hidden="true">{{ favoriteOnly ? "★" : "☆" }}</span>
-          </button>
-          <AppButton
-            variant="secondary"
-            :disabled="startRunDisabled"
-            :title="startRunDisabledReason || undefined"
-            @click="onStartRun"
-          >
-            {{ startRunButtonLabel }}
-          </AppButton>
-          <AppRefreshButton
-            variant="ghost"
-            :disabled="loading"
-            :loading="loading"
-            title="Refresh publications"
-            loading-title="Refreshing publications"
-            @click="loadPublications"
-          />
-        </div>
-      </div>
+      <PublicationToolbar
+        :mode="pub.mode.value"
+        :selected-scholar-filter="pub.selectedScholarFilter.value"
+        :search-query="pub.searchQuery.value"
+        :favorite-only="pub.favoriteOnly.value"
+        :action-busy="actionBusy"
+        :loading="pub.loading.value"
+        :scholars="pub.scholars.value"
+        :start-run-disabled="startRunDisabled"
+        :start-run-disabled-reason="startRunDisabledReason"
+        :start-run-button-label="startRunButtonLabel"
+        @update:mode="pub.mode.value = $event"
+        @update:selected-scholar-filter="pub.selectedScholarFilter.value = $event"
+        @update:search-query="pub.searchQuery.value = $event"
+        @mode-changed="onModeChanged"
+        @scholar-filter-changed="onScholarFilterChanged"
+        @favorite-only-changed="onFavoriteOnlyChanged"
+        @reset-search="pub.searchQuery.value = ''"
+        @start-run="onStartRun"
+        @refresh="pub.loadPublications"
+      />
 
       <RequestStateAlerts
-        :success-message="successMessage"
+        :success-message="pub.successMessage.value"
         success-title="Publication update complete"
-        :error-message="errorMessage"
-        :error-request-id="errorRequestId"
+        :error-message="pub.errorMessage.value"
+        :error-request-id="pub.errorRequestId.value"
         error-title="Publication request failed"
-        @dismiss-success="successMessage = null"
+        @dismiss-success="pub.successMessage.value = null"
       />
 
       <div class="flex flex-wrap items-center justify-between gap-2 border-t border-stroke-default pt-3">
         <div class="flex items-center gap-1">
           <h3 class="text-base font-semibold text-ink-primary">Results</h3>
-          <AppHelpHint
-            text="Star to favorite, open PDF when available, and retry only after failed PDF lookup attempts."
-          />
+          <AppHelpHint text="Star to favorite, open PDF when available, and retry only after failed PDF lookup attempts." />
         </div>
         <div class="flex flex-wrap items-center justify-end gap-2 text-[11px] text-secondary">
-          <span>Scope: {{ scopeLabel }} | Showing {{ selectedScholarName }}</span>
+          <span>Scope: {{ scopeLabel }} | Showing {{ pub.selectedScholarName.value }}</span>
           <div class="flex items-center gap-1">
             <label for="publications-page-size" class="sr-only">Page size</label>
             <AppSelect
               id="publications-page-size"
-              v-model="pageSize"
-              :disabled="loading"
+              v-model="pub.pageSize.value"
+              :disabled="pub.loading.value"
               class="max-w-[8rem] !py-1.5 !text-xs"
               @change="onPageSizeChanged"
             >
@@ -1025,9 +418,7 @@ watch(
               <option value="100">100 / page</option>
               <option value="200">200 / page</option>
             </AppSelect>
-            <AppHelpHint
-              text="When no rows are selected, actions target all unread results. After selecting rows, the menu switches to selected-row actions."
-            />
+            <AppHelpHint text="When no rows are selected, actions target all unread results. After selecting rows, the menu switches to selected-row actions." />
             <label for="publications-bulk-action" class="sr-only">Bulk task</label>
             <AppSelect
               id="publications-bulk-action"
@@ -1052,14 +443,14 @@ watch(
       </div>
 
       <AsyncStateGate
-        :loading="loading"
+        :loading="pub.loading.value"
         :loading-lines="8"
         :empty="showingEmptyList"
         :empty-title="emptyTitle"
         :empty-body="emptyBody"
-        :show-empty="!errorMessage"
+        :show-empty="!pub.errorMessage.value"
       >
-        <AppTable v-if="listState" label="Publication list table">
+        <AppTable v-if="pub.listState.value" label="Publication list table">
           <thead>
             <tr>
               <th scope="col" class="w-10">
@@ -1067,162 +458,74 @@ watch(
                   type="checkbox"
                   class="h-4 w-4 rounded border-stroke-interactive bg-surface-input text-brand-600 focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset"
                   :checked="allVisibleUnreadSelected"
-                  :disabled="visibleUnreadKeys.size === 0"
+                  :disabled="pub.visibleUnreadKeys.value.size === 0"
                   aria-label="Select all visible unread publications"
                   @change="onToggleAllVisible"
                 />
               </th>
               <th scope="col" class="w-12 text-left font-semibold text-ink-primary">★</th>
               <th scope="col" class="w-[44%] min-w-[24rem]">
-                <button type="button" class="table-sort" @click="toggleSort('title')">
-                  Title <span aria-hidden="true" class="sort-marker">{{ sortMarker('title') }}</span>
+                <button type="button" class="table-sort" @click="pub.toggleSort('title')">
+                  Title <span aria-hidden="true" class="sort-marker">{{ pub.sortMarker('title') }}</span>
                 </button>
               </th>
               <th scope="col" class="w-[16%] min-w-[12rem]">
-                <button type="button" class="table-sort" @click="toggleSort('scholar')">
-                  Scholar <span aria-hidden="true" class="sort-marker">{{ sortMarker('scholar') }}</span>
+                <button type="button" class="table-sort" @click="pub.toggleSort('scholar')">
+                  Scholar <span aria-hidden="true" class="sort-marker">{{ pub.sortMarker('scholar') }}</span>
                 </button>
               </th>
               <th scope="col" class="w-[8.5rem] whitespace-nowrap">
-                <button type="button" class="table-sort" @click="toggleSort('pdf_status')">
-                  PDF <span aria-hidden="true" class="sort-marker">{{ sortMarker('pdf_status') }}</span>
+                <button type="button" class="table-sort" @click="pub.toggleSort('pdf_status')">
+                  PDF <span aria-hidden="true" class="sort-marker">{{ pub.sortMarker('pdf_status') }}</span>
                 </button>
               </th>
               <th scope="col" class="w-16 whitespace-nowrap">
-                <button type="button" class="table-sort" @click="toggleSort('year')">
-                  Year <span aria-hidden="true" class="sort-marker">{{ sortMarker('year') }}</span>
+                <button type="button" class="table-sort" @click="pub.toggleSort('year')">
+                  Year <span aria-hidden="true" class="sort-marker">{{ pub.sortMarker('year') }}</span>
                 </button>
               </th>
               <th scope="col" class="w-24 whitespace-nowrap">
-                <button type="button" class="table-sort" @click="toggleSort('citations')">
-                  Citations <span aria-hidden="true" class="sort-marker">{{ sortMarker('citations') }}</span>
+                <button type="button" class="table-sort" @click="pub.toggleSort('citations')">
+                  Citations <span aria-hidden="true" class="sort-marker">{{ pub.sortMarker('citations') }}</span>
                 </button>
               </th>
               <th scope="col" class="w-44 whitespace-nowrap text-left font-semibold text-ink-primary">Read status</th>
               <th scope="col" class="w-32 whitespace-nowrap">
-                <button type="button" class="table-sort" @click="toggleSort('first_seen')">
-                  First seen <span aria-hidden="true" class="sort-marker">{{ sortMarker('first_seen') }}</span>
+                <button type="button" class="table-sort" @click="pub.toggleSort('first_seen')">
+                  First seen <span aria-hidden="true" class="sort-marker">{{ pub.sortMarker('first_seen') }}</span>
                 </button>
               </th>
             </tr>
           </thead>
           <tbody>
-            <tr v-for="item in sortedPublications" :key="publicationKey(item)">
-              <td>
-                <input
-                  type="checkbox"
-                  class="h-4 w-4 rounded border-stroke-interactive bg-surface-input text-brand-600 focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset"
-                  :checked="selectedPublicationKeys.has(publicationKey(item))"
-                  :disabled="item.is_read"
-                  :aria-label="`Select publication ${item.title}`"
-                  @change="onToggleRowSelection(item, $event)"
-                />
-              </td>
-              <td>
-                <button
-                  type="button"
-                  class="favorite-star-button"
-                  :class="item.is_favorite ? 'favorite-star-on' : 'favorite-star-off'"
-                  :aria-label="item.is_favorite ? `Remove ${item.title} from favorites` : `Add ${item.title} to favorites`"
-                  :aria-pressed="item.is_favorite"
-                  :disabled="isFavoriteUpdating(item)"
-                  @click="onToggleFavorite(item)"
-                >
-                  {{ item.is_favorite ? "★" : "☆" }}
-                </button>
-              </td>
-              <td class="max-w-0">
-                <div class="grid min-w-0 gap-1">
-                  <a
-                    v-if="publicationPrimaryUrl(item)"
-                    :href="publicationPrimaryUrl(item) || ''"
-                    target="_blank"
-                    rel="noreferrer"
-                    class="link-inline block truncate font-medium"
-                    :title="item.title"
-                  >
-                    {{ item.title }}
-                  </a>
-                  <span v-else class="block truncate font-medium" :title="item.title">{{ item.title }}</span>
-                  <a
-                    v-if="publicationIdentifierUrl(item)"
-                    :href="publicationIdentifierUrl(item) || ''"
-                    target="_blank"
-                    rel="noreferrer"
-                    class="link-inline block truncate text-xs"
-                    :title="publicationIdentifierLabel(item) || ''"
-                  >
-                    {{ publicationIdentifierLabel(item) }}
-                  </a>
-                </div>
-              </td>
-              <td>
-                <span class="block truncate" :title="item.scholar_label">{{ item.scholar_label }}</span>
-              </td>
-              <td class="whitespace-nowrap">
-                <a
-                  v-if="item.pdf_url"
-                  :href="item.pdf_url"
-                  target="_blank"
-                  rel="noreferrer"
-                  class="pdf-link-button"
-                  title="Open PDF"
-                >
-                  <svg class="mr-1 h-3 w-3" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14" />
-                  </svg>
-                  Available
-                </a>
-                <button
-                  v-else-if="canRetryPublicationPdf(item)"
-                  type="button"
-                  class="pdf-retry-button"
-                  :disabled="isRetryingPublication(item)"
-                  @click="onRetryPdf(item)"
-                >
-                  <svg v-if="isRetryingPublication(item)" class="mr-1 h-3 w-3 animate-spin" viewBox="0 0 24 24" fill="none">
-                    <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
-                    <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
-                  </svg>
-                  {{ isRetryingPublication(item) ? "Retrying..." : "Missing (Retry)" }}
-                </button>
-                <span v-else class="pdf-state-label" :class="{ 'bg-surface-accent-muted border-accent-300 text-accent-700': item.pdf_status === 'running' || item.pdf_status === 'queued' }">
-                  <svg v-if="item.pdf_status === 'running'" class="mr-1 h-3 w-3 animate-spin text-accent-600" viewBox="0 0 24 24" fill="none">
-                    <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
-                    <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
-                  </svg>
-                  {{ pdfPendingLabel(item) }}
-                </span>
-              </td>
-              <td class="whitespace-nowrap">{{ item.year ?? "n/a" }}</td>
-              <td class="whitespace-nowrap">{{ item.citation_count }}</td>
-              <td>
-                <div class="status-badges-row">
-                  <AppBadge :tone="item.is_new_in_latest_run ? 'info' : 'neutral'">
-                    {{ item.is_new_in_latest_run ? "New" : "Seen" }}
-                  </AppBadge>
-                  <AppBadge :tone="item.is_read ? 'success' : 'warning'">
-                    {{ item.is_read ? "Read" : "Unread" }}
-                  </AppBadge>
-                </div>
-              </td>
-              <td class="whitespace-nowrap">{{ formatDate(item.first_seen_at) }}</td>
-            </tr>
+            <PublicationTableRow
+              v-for="item in pub.sortedPublications.value"
+              :key="publicationKey(item)"
+              :item="item"
+              :item-key="publicationKey(item)"
+              :selected="selectedPublicationKeys.has(publicationKey(item))"
+              :favorite-updating="favoriteUpdatingKeys.has(publicationKey(item))"
+              :retrying="retryingPublicationKeys.has(publicationKey(item))"
+              :can-retry="canRetryPublicationPdf(item)"
+              @toggle-selection="onToggleRowSelection(item, $event)"
+              @toggle-favorite="onToggleFavorite(item)"
+              @retry-pdf="onRetryPdf(item)"
+            />
           </tbody>
         </AppTable>
       </AsyncStateGate>
 
       <div class="flex flex-wrap items-center justify-between gap-2 border-t border-stroke-default pt-2 text-xs text-secondary">
         <span>
-          total {{ totalCount }} · visible {{ visibleCount }} · unread {{ visibleUnreadCount }} · favorites {{ visibleFavoriteCount }}
+          total {{ pub.totalCount.value }} · visible {{ pub.visibleCount.value }} · unread {{ pub.visibleUnreadCount.value }} · favorites {{ pub.visibleFavoriteCount.value }}
           · selected {{ selectedCount }}
         </span>
         <div class="flex items-center gap-2">
-          <span>page {{ currentPage }} / {{ totalPages }}</span>
-          <AppButton variant="ghost" class="h-8 min-h-8 px-2" :disabled="!hasPrevPage || loading" @click="onPrevPage">
+          <span>page {{ pub.currentPage.value }} / {{ pub.totalPages.value }}</span>
+          <AppButton variant="ghost" class="h-8 min-h-8 px-2" :disabled="!pub.hasPrevPage.value || pub.loading.value" @click="onPrevPage">
             Prev
           </AppButton>
-          <AppButton variant="ghost" class="h-8 min-h-8 px-2" :disabled="!hasNextPage || loading" @click="onNextPage">
+          <AppButton variant="ghost" class="h-8 min-h-8 px-2" :disabled="!pub.hasNextPage.value || pub.loading.value" @click="onNextPage">
             Next
           </AppButton>
         </div>
@@ -1240,44 +543,4 @@ watch(
 .sort-marker {
   @apply text-[11px] leading-none text-ink-muted;
 }
-
-.favorite-filter-button {
-  @apply inline-flex min-h-10 h-10 w-10 items-center justify-center rounded-full border text-base leading-none transition focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset disabled:cursor-not-allowed disabled:opacity-50;
-}
-
-.favorite-filter-on {
-  @apply border-warning-300 bg-warning-100 text-warning-700 hover:bg-warning-200;
-}
-
-.favorite-filter-off {
-  @apply border-stroke-default bg-surface-card-muted text-ink-muted hover:border-stroke-interactive hover:text-ink-secondary;
-}
-
-.favorite-star-button {
-  @apply inline-flex h-7 w-7 items-center justify-center rounded-full border text-sm leading-none transition focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset disabled:cursor-not-allowed disabled:opacity-50;
-}
-
-.favorite-star-on {
-  @apply border-warning-300 bg-warning-100 text-warning-700 hover:bg-warning-200;
-}
-
-.favorite-star-off {
-  @apply border-stroke-default bg-surface-card-muted text-ink-muted hover:border-stroke-interactive hover:text-ink-secondary;
-}
-
-.pdf-link-button {
-  @apply inline-flex items-center rounded-full border px-2 py-0.5 text-xs font-medium border-state-success-border bg-state-success-bg text-state-success-text shadow-sm transition hover:brightness-95 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset;
-}
-
-.pdf-retry-button {
-  @apply inline-flex items-center rounded-full border px-2 py-0.5 text-xs font-medium border-state-warning-border bg-state-warning-bg text-state-warning-text transition hover:brightness-95 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset disabled:cursor-not-allowed disabled:opacity-50;
-}
-
-.pdf-state-label {
-  @apply inline-flex items-center rounded-full border px-2 py-0.5 text-xs font-medium border-stroke-default bg-surface-card-muted text-secondary;
-}
-
-.status-badges-row {
-  @apply inline-flex items-center gap-1 whitespace-nowrap;
-}
 </style>
diff --git a/frontend/src/pages/ScholarsPage.vue b/frontend/src/pages/ScholarsPage.vue
index 1620128..df2143e 100644
--- a/frontend/src/pages/ScholarsPage.vue
+++ b/frontend/src/pages/ScholarsPage.vue
@@ -4,14 +4,11 @@ import { computed, onMounted, onUnmounted, ref, watch } from "vue";
 import AppPage from "@/components/layout/AppPage.vue";
 import AsyncStateGate from "@/components/patterns/AsyncStateGate.vue";
 import RequestStateAlerts from "@/components/patterns/RequestStateAlerts.vue";
-import AppAlert from "@/components/ui/AppAlert.vue";
-import AppBadge from "@/components/ui/AppBadge.vue";
 import AppButton from "@/components/ui/AppButton.vue";
 import AppCard from "@/components/ui/AppCard.vue";
 import AppEmptyState from "@/components/ui/AppEmptyState.vue";
 import AppHelpHint from "@/components/ui/AppHelpHint.vue";
 import AppInput from "@/components/ui/AppInput.vue";
-import AppModal from "@/components/ui/AppModal.vue";
 import AppRefreshButton from "@/components/ui/AppRefreshButton.vue";
 import AppSelect from "@/components/ui/AppSelect.vue";
 import AppTable from "@/components/ui/AppTable.vue";
@@ -22,7 +19,6 @@ import {
   exportScholarData,
   importScholarData,
   listScholars,
-  searchScholarsByName,
   setScholarImageUrl,
   toggleScholar,
   uploadScholarImage,
@@ -30,15 +26,16 @@ import {
   type DataImportResult,
   type ScholarProfile,
   type ScholarSearchCandidate,
-  type ScholarSearchResult,
 } from "@/features/scholars";
 import ScholarAvatar from "@/features/scholars/components/ScholarAvatar.vue";
+import ScholarBatchAdd from "@/features/scholars/components/ScholarBatchAdd.vue";
+import ScholarNameSearch from "@/features/scholars/components/ScholarNameSearch.vue";
+import ScholarSettingsModal from "@/features/scholars/components/ScholarSettingsModal.vue";
 import { ApiRequestError } from "@/lib/api/errors";
 import { useRunStatusStore } from "@/stores/run_status";
 
 const loading = ref(true);
 const saving = ref(false);
-const searchingByName = ref(false);
 const activeScholarId = ref<number | null>(null);
 const imageSavingScholarId = ref<number | null>(null);
 const imageUploadingScholarId = ref<number | null>(null);
@@ -50,170 +47,306 @@ const importFileInput = ref<HTMLInputElement | null>(null);
 
 const scholars = ref<ScholarProfile[]>([]);
 const imageUrlDraftByScholarId = ref<Record<number, string>>({});
-
-const scholarBatchInput = ref("");
-const searchQuery = ref("");
 const trackedFilterQuery = ref("");
 type TrackedScholarSort = "recent" | "name_asc" | "name_desc" | "enabled_first";
 const trackedSort = ref<TrackedScholarSort>("recent");
-const searchResult = ref<ScholarSearchResult | null>(null);
-const searchErrorMessage = ref<string | null>(null);
-const searchErrorRequestId = ref<string | null>(null);
 
 const errorMessage = ref<string | null>(null);
 const errorRequestId = ref<string | null>(null);
 const successMessage = ref<string | null>(null);
 
-const SCHOLAR_ID_PATTERN = /^[a-zA-Z0-9_-]{12}$/;
-const URL_USER_PARAM_PATTERN = /(?:\?|&)user=([a-zA-Z0-9_-]{12})(?:&|#|$)/i;
-const nameSearchWip = true;
 const SCHOLARS_LIVE_SYNC_INTERVAL_MS = 4000;
 let scholarsLiveSyncTimer: ReturnType<typeof setInterval> | null = null;
-
 const runStatus = useRunStatusStore();
 
-const trackedScholarIds = computed(() => new Set(scholars.value.map((item) => item.scholar_id)));
-const activeScholarSettings = computed(
-  () => scholars.value.find((item) => item.id === activeScholarSettingsId.value) ?? null,
-);
-const hasTrackedScholars = computed(() => scholars.value.length > 0);
-const parsedBatchCount = computed(() => parseScholarIds(scholarBatchInput.value).length);
-const searchHasRun = computed(() => searchResult.value !== null);
-const searchIsDegraded = computed(() => {
-  if (!searchResult.value) {
-    return false;
-  }
-  return searchResult.value.state === "blocked_or_captcha" || searchResult.value.state === "network_error";
-});
-const searchStateTone = computed(() => {
-  const result = searchResult.value;
-  if (!result) {
-    return "neutral" as const;
-  }
-  if (result.state === "ok") {
-    return "success" as const;
-  }
-  if (result.state === "blocked_or_captcha" || result.state === "network_error") {
-    return "warning" as const;
-  }
-  return "neutral" as const;
-});
-const emptySearchCandidates = computed(() => {
-  const result = searchResult.value;
-  if (!result) {
-    return false;
-  }
-  return result.candidates.length === 0;
-});
-const normalizedTrackedFilter = computed(() => trackedFilterQuery.value.trim().toLocaleLowerCase());
-const visibleScholars = computed(() => {
-  const filter = normalizedTrackedFilter.value;
-  const filtered = scholars.value.filter((item) => {
-    if (!filter) {
-      return true;
-    }
-    const label = scholarLabel(item).toLocaleLowerCase();
-    const scholarId = item.scholar_id.toLocaleLowerCase();
-    return label.includes(filter) || scholarId.includes(filter);
-  });
+// --- Helpers ---
 
-  const byName = (a: ScholarProfile, b: ScholarProfile) =>
-    scholarLabel(a).localeCompare(scholarLabel(b), undefined, { sensitivity: "base" });
-
-  const sorted = [...filtered];
-  if (trackedSort.value === "name_asc") {
-    sorted.sort(byName);
-    return sorted;
-  }
-  if (trackedSort.value === "name_desc") {
-    sorted.sort((a, b) => byName(b, a));
-    return sorted;
-  }
-  if (trackedSort.value === "enabled_first") {
-    sorted.sort((a, b) => {
-      if (a.is_enabled !== b.is_enabled) {
-        return a.is_enabled ? -1 : 1;
-      }
-      return byName(a, b);
-    });
-    return sorted;
-  }
-
-  sorted.sort((a, b) => b.id - a.id);
-  return sorted;
-});
-const hasVisibleScholars = computed(() => visibleScholars.value.length > 0);
-const trackedCountLabel = computed(() => {
-  if (!normalizedTrackedFilter.value) {
-    return `${scholars.value.length} tracked`;
-  }
-  return `${visibleScholars.value.length} of ${scholars.value.length}`;
-});
+function scholarLabel(profile: ScholarProfile): string {
+  return profile.display_name || profile.scholar_id;
+}
 
 function scholarProfileUrl(scholarId: string): string {
   return `https://scholar.google.com/citations?hl=en&user=${encodeURIComponent(scholarId)}`;
 }
 
 function scholarPublicationsRoute(profile: ScholarProfile): { name: string; query: { scholar: string } } {
-  return {
-    name: "publications",
-    query: { scholar: String(profile.id) },
-  };
+  return { name: "publications", query: { scholar: String(profile.id) } };
 }
 
-function parseScholarIds(raw: string): string[] {
-  const ordered: string[] = [];
-  const seen = new Set<string>();
+function isImageBusy(scholarProfileId: number): boolean {
+  return imageSavingScholarId.value === scholarProfileId
+    || imageUploadingScholarId.value === scholarProfileId
+    || activeScholarId.value === scholarProfileId;
+}
 
-  const tokens = raw
-    .split(/[\s,;]+/)
-    .map((value) => value.trim())
-    .filter((value) => value.length > 0);
+// --- Scholar list management ---
 
-  for (const token of tokens) {
-    let candidate: string | null = null;
+const trackedScholarIds = computed(() => new Set(scholars.value.map((item) => item.scholar_id)));
+const activeScholarSettings = computed(
+  () => scholars.value.find((item) => item.id === activeScholarSettingsId.value) ?? null,
+);
+const hasTrackedScholars = computed(() => scholars.value.length > 0);
 
-    if (SCHOLAR_ID_PATTERN.test(token)) {
-      candidate = token;
-    }
-
-    if (!candidate) {
-      const directParamMatch = token.match(URL_USER_PARAM_PATTERN);
-      if (directParamMatch) {
-        candidate = directParamMatch[1];
-      }
-    }
-
-    if (!candidate && token.includes("scholar.google")) {
-      try {
-        const parsed = new URL(token);
-        const userParam = parsed.searchParams.get("user");
-        if (userParam && SCHOLAR_ID_PATTERN.test(userParam)) {
-          candidate = userParam;
-        }
-      } catch (_error) {
-        // Ignore non-URL tokens.
-      }
-    }
-
-    if (!candidate || seen.has(candidate)) {
-      continue;
-    }
-
-    seen.add(candidate);
-    ordered.push(candidate);
+const normalizedTrackedFilter = computed(() => trackedFilterQuery.value.trim().toLocaleLowerCase());
+const visibleScholars = computed(() => {
+  const filter = normalizedTrackedFilter.value;
+  const filtered = scholars.value.filter((item) => {
+    if (!filter) return true;
+    return scholarLabel(item).toLocaleLowerCase().includes(filter)
+      || item.scholar_id.toLocaleLowerCase().includes(filter);
+  });
+  const byName = (a: ScholarProfile, b: ScholarProfile) =>
+    scholarLabel(a).localeCompare(scholarLabel(b), undefined, { sensitivity: "base" });
+  const sorted = [...filtered];
+  if (trackedSort.value === "name_asc") { sorted.sort(byName); return sorted; }
+  if (trackedSort.value === "name_desc") { sorted.sort((a, b) => byName(b, a)); return sorted; }
+  if (trackedSort.value === "enabled_first") {
+    sorted.sort((a, b) => {
+      if (a.is_enabled !== b.is_enabled) return a.is_enabled ? -1 : 1;
+      return byName(a, b);
+    });
+    return sorted;
   }
+  sorted.sort((a, b) => b.id - a.id);
+  return sorted;
+});
+const hasVisibleScholars = computed(() => visibleScholars.value.length > 0);
+const trackedCountLabel = computed(() => {
+  if (!normalizedTrackedFilter.value) return `${scholars.value.length} tracked`;
+  return `${visibleScholars.value.length} of ${scholars.value.length}`;
+});
 
-  return ordered;
+// --- Image draft sync ---
+
+function syncImageDrafts(): void {
+  const next: Record<number, string> = {};
+  for (const item of scholars.value) {
+    const existing = imageUrlDraftByScholarId.value[item.id];
+    if (typeof existing === "string" && existing.length > 0) { next[item.id] = existing; continue; }
+    next[item.id] = item.profile_image_source === "override" ? (item.profile_image_url ?? "") : "";
+  }
+  imageUrlDraftByScholarId.value = next;
 }
 
-function scholarLabel(profile: ScholarProfile): string {
-  return profile.display_name || profile.scholar_id;
+function applyScholarList(nextScholars: ScholarProfile[]): void {
+  scholars.value = nextScholars;
+  syncImageDrafts();
 }
 
+function upsertScholar(profile: ScholarProfile): void {
+  const existingIndex = scholars.value.findIndex((item) => item.id === profile.id);
+  if (existingIndex < 0) { applyScholarList([profile, ...scholars.value]); return; }
+  const next = [...scholars.value];
+  next[existingIndex] = profile;
+  applyScholarList(next);
+}
+
+// --- Live sync ---
+
+function stopScholarLiveSync(): void {
+  if (scholarsLiveSyncTimer === null) return;
+  clearInterval(scholarsLiveSyncTimer);
+  scholarsLiveSyncTimer = null;
+}
+
+function startScholarLiveSync(): void {
+  if (scholarsLiveSyncTimer !== null) return;
+  scholarsLiveSyncTimer = setInterval(() => { void refreshScholarsSilently(); }, SCHOLARS_LIVE_SYNC_INTERVAL_MS);
+}
+
+async function refreshScholarsSilently(): Promise<void> {
+  try { applyScholarList(await listScholars()); } catch { /* Keep existing list. */ }
+}
+
+// --- Data loading ---
+
+async function loadScholars(): Promise<void> {
+  loading.value = true;
+  try {
+    applyScholarList(await listScholars());
+  } catch (error) {
+    applyScholarList([]);
+    if (error instanceof ApiRequestError) {
+      errorMessage.value = error.message;
+      errorRequestId.value = error.requestId;
+    } else {
+      errorMessage.value = "Unable to load scholars.";
+    }
+  } finally {
+    loading.value = false;
+  }
+}
+
+// --- Actions ---
+
+function assignError(error: unknown, fallback: string): void {
+  if (error instanceof ApiRequestError) {
+    errorMessage.value = error.message;
+    errorRequestId.value = error.requestId;
+  } else if (error instanceof Error) {
+    errorMessage.value = error.message;
+  } else {
+    errorMessage.value = fallback;
+  }
+}
+
+function clearMessages(): void {
+  errorMessage.value = null;
+  errorRequestId.value = null;
+  successMessage.value = null;
+}
+
+async function onAddScholars(scholarIds: string[]): Promise<void> {
+  saving.value = true;
+  clearMessages();
+  try {
+    const settled = await Promise.allSettled(
+      scholarIds.map(async (scholarId) => {
+        const created = await createScholar({ scholar_id: scholarId });
+        upsertScholar(created);
+        return created;
+      }),
+    );
+    const failures: string[] = [];
+    let requestIdFromFailures: string | null = null;
+    let createdCount = 0;
+    settled.forEach((result, index) => {
+      if (result.status === "fulfilled") { createdCount += 1; return; }
+      const scholarId = scholarIds[index];
+      if (result.reason instanceof ApiRequestError) {
+        failures.push(`${scholarId}: ${result.reason.message}`);
+        if (!requestIdFromFailures && result.reason.requestId) requestIdFromFailures = result.reason.requestId;
+      } else if (result.reason instanceof Error) {
+        failures.push(`${scholarId}: ${result.reason.message}`);
+      } else {
+        failures.push(`${scholarId}: Unable to create scholar.`);
+      }
+    });
+    if (createdCount > 0) {
+      const total = scholarIds.length;
+      successMessage.value = `Added ${createdCount} of ${total} scholar${total === 1 ? "" : "s"}.`;
+    }
+    if (failures.length > 0) {
+      const preview = failures.slice(0, 3).join(" | ");
+      const remainder = failures.length > 3 ? ` (+${failures.length - 3} more)` : "";
+      errorMessage.value = `Failed to add ${failures.length} scholar${failures.length === 1 ? "" : "s"}: ${preview}${remainder}`;
+      errorRequestId.value = requestIdFromFailures;
+    }
+    await refreshScholarsSilently();
+  } catch (error) {
+    assignError(error, "Unable to create scholar records.");
+  } finally {
+    saving.value = false;
+  }
+}
+
+async function onAddCandidate(candidate: ScholarSearchCandidate): Promise<void> {
+  addingCandidateScholarId.value = candidate.scholar_id;
+  clearMessages();
+  try {
+    const created = await createScholar({ scholar_id: candidate.scholar_id, profile_image_url: candidate.profile_image_url ?? undefined });
+    upsertScholar(created);
+    successMessage.value = `${candidate.display_name} added.`;
+  } catch (error) {
+    assignError(error, "Unable to add scholar from search result.");
+  } finally {
+    addingCandidateScholarId.value = null;
+  }
+}
+
+async function onToggleScholar(): Promise<void> {
+  const profile = activeScholarSettings.value;
+  if (!profile) return;
+  activeScholarId.value = profile.id;
+  clearMessages();
+  try {
+    await toggleScholar(profile.id);
+    successMessage.value = `${scholarLabel(profile)} ${profile.is_enabled ? "disabled" : "enabled"}.`;
+    await loadScholars();
+  } catch (error) {
+    assignError(error, "Unable to update scholar status.");
+  } finally {
+    activeScholarId.value = null;
+  }
+}
+
+async function onDeleteScholar(): Promise<void> {
+  const profile = activeScholarSettings.value;
+  if (!profile) return;
+  const label = scholarLabel(profile);
+  if (!window.confirm(`Delete scholar ${label}? This removes all linked publications and queue data.`)) return;
+  activeScholarId.value = profile.id;
+  clearMessages();
+  try {
+    await deleteScholar(profile.id);
+    successMessage.value = `${label} deleted.`;
+    activeScholarSettingsId.value = null;
+    await loadScholars();
+  } catch (error) {
+    assignError(error, "Unable to delete scholar.");
+  } finally {
+    activeScholarId.value = null;
+  }
+}
+
+async function onSaveImageUrl(): Promise<void> {
+  const profile = activeScholarSettings.value;
+  if (!profile) return;
+  const candidate = (imageUrlDraftByScholarId.value[profile.id] || "").trim();
+  if (!candidate) { errorMessage.value = "Enter an image URL before saving, or use Reset image."; return; }
+  imageSavingScholarId.value = profile.id;
+  clearMessages();
+  try {
+    await setScholarImageUrl(profile.id, candidate);
+    successMessage.value = `Image URL updated for ${scholarLabel(profile)}.`;
+    await loadScholars();
+  } catch (error) {
+    assignError(error, "Unable to update scholar image URL.");
+  } finally {
+    imageSavingScholarId.value = null;
+  }
+}
+
+async function onUploadImage(event: Event): Promise<void> {
+  const profile = activeScholarSettings.value;
+  if (!profile) return;
+  const input = event.target as HTMLInputElement | null;
+  const file = input?.files?.[0] ?? null;
+  if (!file) return;
+  imageUploadingScholarId.value = profile.id;
+  clearMessages();
+  try {
+    await uploadScholarImage(profile.id, file);
+    successMessage.value = `Uploaded image for ${scholarLabel(profile)}.`;
+    await loadScholars();
+  } catch (error) {
+    assignError(error, "Unable to upload scholar image.");
+  } finally {
+    imageUploadingScholarId.value = null;
+    if (input) input.value = "";
+  }
+}
+
+async function onResetImage(): Promise<void> {
+  const profile = activeScholarSettings.value;
+  if (!profile) return;
+  imageSavingScholarId.value = profile.id;
+  clearMessages();
+  try {
+    await clearScholarImage(profile.id);
+    successMessage.value = `Image reset for ${scholarLabel(profile)}.`;
+    await loadScholars();
+  } catch (error) {
+    assignError(error, "Unable to reset scholar image.");
+  } finally {
+    imageSavingScholarId.value = null;
+  }
+}
+
+// --- Import/export ---
+
 function suggestExportFilename(exportedAt: string): string {
-  const date = exportedAt.slice(0, 10) || "unknown-date";
-  return `scholarr-export-${date}.json`;
+  return `scholarr-export-${exportedAt.slice(0, 10) || "unknown-date"}.json`;
 }
 
 function downloadJsonFile(filename: string, payload: unknown): void {
@@ -235,112 +368,15 @@ function importSummary(result: DataImportResult): string {
   );
 }
 
-function isImageBusy(scholarProfileId: number): boolean {
-  return (
-    imageSavingScholarId.value === scholarProfileId ||
-    imageUploadingScholarId.value === scholarProfileId ||
-    activeScholarId.value === scholarProfileId
-  );
-}
-
-function openScholarSettings(profile: ScholarProfile): void {
-  activeScholarSettingsId.value = profile.id;
-}
-
-function closeScholarSettings(): void {
-  activeScholarSettingsId.value = null;
-}
-
-function syncImageDrafts(): void {
-  const next: Record<number, string> = {};
-  for (const item of scholars.value) {
-    const existing = imageUrlDraftByScholarId.value[item.id];
-    if (typeof existing === "string" && existing.length > 0) {
-      next[item.id] = existing;
-      continue;
-    }
-
-    next[item.id] = item.profile_image_source === "override" ? (item.profile_image_url ?? "") : "";
-  }
-  imageUrlDraftByScholarId.value = next;
-}
-
-function applyScholarList(nextScholars: ScholarProfile[]): void {
-  scholars.value = nextScholars;
-  syncImageDrafts();
-}
-
-function upsertScholar(profile: ScholarProfile): void {
-  const existingIndex = scholars.value.findIndex((item) => item.id === profile.id);
-  if (existingIndex < 0) {
-    applyScholarList([profile, ...scholars.value]);
-    return;
-  }
-  const next = [...scholars.value];
-  next[existingIndex] = profile;
-  applyScholarList(next);
-}
-
-function stopScholarLiveSync(): void {
-  if (scholarsLiveSyncTimer === null) {
-    return;
-  }
-  clearInterval(scholarsLiveSyncTimer);
-  scholarsLiveSyncTimer = null;
-}
-
-function startScholarLiveSync(): void {
-  if (scholarsLiveSyncTimer !== null) {
-    return;
-  }
-  scholarsLiveSyncTimer = setInterval(() => {
-    void refreshScholarsSilently();
-  }, SCHOLARS_LIVE_SYNC_INTERVAL_MS);
-}
-
-async function refreshScholarsSilently(): Promise<void> {
-  try {
-    applyScholarList(await listScholars());
-  } catch (_error) {
-    // Keep existing list when transient refresh fails.
-  }
-}
-
-async function loadScholars(): Promise<void> {
-  loading.value = true;
-
-  try {
-    applyScholarList(await listScholars());
-  } catch (error) {
-    applyScholarList([]);
-    if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
-    } else {
-      errorMessage.value = "Unable to load scholars.";
-    }
-  } finally {
-    loading.value = false;
-  }
-}
-
 async function onExportData(): Promise<void> {
   exportingData.value = true;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-  successMessage.value = null;
-
+  clearMessages();
   try {
     const payload = await exportScholarData();
     downloadJsonFile(suggestExportFilename(payload.exported_at), payload);
     successMessage.value = "Export complete.";
   } catch (error) {
-    if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
-    } else {
-      errorMessage.value = "Unable to export scholars and publications.";
-    }
+    assignError(error, "Unable to export scholars and publications.");
   } finally {
     exportingData.value = false;
   }
@@ -350,327 +386,37 @@ function onOpenImportPicker(): void {
   importFileInput.value?.click();
 }
 
-function parseImportedJson(raw: string): DataImportPayload {
-  const parsed = JSON.parse(raw) as DataImportPayload;
-  if (!parsed || !Array.isArray(parsed.scholars) || !Array.isArray(parsed.publications)) {
-    throw new Error("Invalid import file: expected scholars[] and publications[] arrays.");
-  }
-  return parsed;
-}
-
 async function onImportFileSelected(event: Event): Promise<void> {
   const input = event.target as HTMLInputElement | null;
   const file = input?.files?.[0] ?? null;
-  if (!file) {
-    return;
-  }
-
+  if (!file) return;
   importingData.value = true;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-  successMessage.value = null;
-
+  clearMessages();
   try {
-    const payload = parseImportedJson(await file.text());
-    const result = await importScholarData(payload);
+    const raw = await file.text();
+    const parsed = JSON.parse(raw) as DataImportPayload;
+    if (!parsed || !Array.isArray(parsed.scholars) || !Array.isArray(parsed.publications)) {
+      throw new Error("Invalid import file: expected scholars[] and publications[] arrays.");
+    }
+    const result = await importScholarData(parsed);
     successMessage.value = importSummary(result);
     await loadScholars();
   } catch (error) {
-    if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
-    } else if (error instanceof Error) {
-      errorMessage.value = error.message;
-    } else {
-      errorMessage.value = "Unable to import scholars and publications.";
-    }
+    assignError(error, "Unable to import scholars and publications.");
   } finally {
     importingData.value = false;
-    if (input) {
-      input.value = "";
-    }
+    if (input) input.value = "";
   }
 }
 
-async function onAddScholars(): Promise<void> {
-  saving.value = true;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-  successMessage.value = null;
+// --- Lifecycle ---
 
-  try {
-    const scholarIds = parseScholarIds(scholarBatchInput.value);
-    if (scholarIds.length === 0) {
-      throw new Error("Provide at least one valid Scholar ID or profile URL.");
-    }
-
-    const settled = await Promise.allSettled(
-      scholarIds.map(async (scholarId) => {
-        const created = await createScholar({ scholar_id: scholarId });
-        upsertScholar(created);
-        return created;
-      }),
-    );
-
-    const failures: string[] = [];
-    let requestIdFromFailures: string | null = null;
-    let createdCount = 0;
-
-    settled.forEach((result, index) => {
-      if (result.status === "fulfilled") {
-        createdCount += 1;
-        return;
-      }
-
-      const scholarId = scholarIds[index];
-      if (result.reason instanceof ApiRequestError) {
-        failures.push(`${scholarId}: ${result.reason.message}`);
-        if (!requestIdFromFailures && result.reason.requestId) {
-          requestIdFromFailures = result.reason.requestId;
-        }
-      } else if (result.reason instanceof Error) {
-        failures.push(`${scholarId}: ${result.reason.message}`);
-      } else {
-        failures.push(`${scholarId}: Unable to create scholar.`);
-      }
-    });
-
-    if (createdCount > 0) {
-      const total = scholarIds.length;
-      successMessage.value = `Added ${createdCount} of ${total} scholar${total === 1 ? "" : "s"}.`;
-      scholarBatchInput.value = "";
-    }
-
-    if (failures.length > 0) {
-      const preview = failures.slice(0, 3).join(" | ");
-      const remainder = failures.length > 3 ? ` (+${failures.length - 3} more)` : "";
-      errorMessage.value = `Failed to add ${failures.length} scholar${failures.length === 1 ? "" : "s"}: ${preview}${remainder}`;
-      errorRequestId.value = requestIdFromFailures;
-    }
-
-    await refreshScholarsSilently();
-  } catch (error) {
-    if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
-    } else if (error instanceof Error) {
-      errorMessage.value = error.message;
-    } else {
-      errorMessage.value = "Unable to create scholar records.";
-    }
-  } finally {
-    saving.value = false;
-  }
-}
-
-async function onSearchByName(): Promise<void> {
-  if (nameSearchWip) {
-    searchErrorMessage.value = "Search by name is temporarily disabled while reliability hardening is in progress.";
-    searchErrorRequestId.value = null;
-    return;
-  }
-  searchingByName.value = true;
-  searchErrorMessage.value = null;
-  searchErrorRequestId.value = null;
-
-  try {
-    const normalized = searchQuery.value.trim();
-    if (normalized.length < 2) {
-      throw new Error("Enter at least 2 characters to search.");
-    }
-
-    searchResult.value = await searchScholarsByName(normalized, 12);
-  } catch (error) {
-    searchResult.value = null;
-    if (error instanceof ApiRequestError) {
-      searchErrorMessage.value = error.message;
-      searchErrorRequestId.value = error.requestId;
-    } else if (error instanceof Error) {
-      searchErrorMessage.value = error.message;
-    } else {
-      searchErrorMessage.value = "Unable to search scholars by name.";
-    }
-  } finally {
-    searchingByName.value = false;
-  }
-}
-
-async function onAddCandidate(candidate: ScholarSearchCandidate): Promise<void> {
-  addingCandidateScholarId.value = candidate.scholar_id;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-  successMessage.value = null;
-
-  try {
-    const created = await createScholar({
-      scholar_id: candidate.scholar_id,
-      profile_image_url: candidate.profile_image_url ?? undefined,
-    });
-    upsertScholar(created);
-    successMessage.value = `${candidate.display_name} added.`;
-  } catch (error) {
-    if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
-    } else {
-      errorMessage.value = "Unable to add scholar from search result.";
-    }
-  } finally {
-    addingCandidateScholarId.value = null;
-  }
-}
-
-async function onToggleScholar(profile: ScholarProfile): Promise<void> {
-  activeScholarId.value = profile.id;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-  successMessage.value = null;
-
-  try {
-    await toggleScholar(profile.id);
-    successMessage.value = `${scholarLabel(profile)} ${profile.is_enabled ? "disabled" : "enabled"}.`;
-    await loadScholars();
-  } catch (error) {
-    if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
-    } else {
-      errorMessage.value = "Unable to update scholar status.";
-    }
-  } finally {
-    activeScholarId.value = null;
-  }
-}
-
-async function onDeleteScholar(profile: ScholarProfile): Promise<void> {
-  const label = scholarLabel(profile);
-  const shouldDelete = window.confirm(`Delete scholar ${label}? This removes all linked publications and queue data.`);
-  if (!shouldDelete) {
-    return;
-  }
-
-  activeScholarId.value = profile.id;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-  successMessage.value = null;
-
-  try {
-    await deleteScholar(profile.id);
-    successMessage.value = `${label} deleted.`;
-    if (activeScholarSettingsId.value === profile.id) {
-      closeScholarSettings();
-    }
-    await loadScholars();
-  } catch (error) {
-    if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
-    } else {
-      errorMessage.value = "Unable to delete scholar.";
-    }
-  } finally {
-    activeScholarId.value = null;
-  }
-}
-
-async function onSaveImageUrl(profile: ScholarProfile): Promise<void> {
-  const candidate = (imageUrlDraftByScholarId.value[profile.id] || "").trim();
-  if (!candidate) {
-    errorMessage.value = "Enter an image URL before saving, or use Reset image.";
-    return;
-  }
-
-  imageSavingScholarId.value = profile.id;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-  successMessage.value = null;
-
-  try {
-    await setScholarImageUrl(profile.id, candidate);
-    successMessage.value = `Image URL updated for ${scholarLabel(profile)}.`;
-    await loadScholars();
-  } catch (error) {
-    if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
-    } else {
-      errorMessage.value = "Unable to update scholar image URL.";
-    }
-  } finally {
-    imageSavingScholarId.value = null;
-  }
-}
-
-async function onUploadImage(profile: ScholarProfile, event: Event): Promise<void> {
-  const input = event.target as HTMLInputElement | null;
-  const file = input?.files?.[0] ?? null;
-  if (!file) {
-    return;
-  }
-
-  imageUploadingScholarId.value = profile.id;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-  successMessage.value = null;
-
-  try {
-    await uploadScholarImage(profile.id, file);
-    successMessage.value = `Uploaded image for ${scholarLabel(profile)}.`;
-    await loadScholars();
-  } catch (error) {
-    if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
-    } else {
-      errorMessage.value = "Unable to upload scholar image.";
-    }
-  } finally {
-    imageUploadingScholarId.value = null;
-    if (input) {
-      input.value = "";
-    }
-  }
-}
-
-async function onResetImage(profile: ScholarProfile): Promise<void> {
-  imageSavingScholarId.value = profile.id;
-  errorMessage.value = null;
-  errorRequestId.value = null;
-  successMessage.value = null;
-
-  try {
-    await clearScholarImage(profile.id);
-    successMessage.value = `Image reset for ${scholarLabel(profile)}.`;
-    await loadScholars();
-  } catch (error) {
-    if (error instanceof ApiRequestError) {
-      errorMessage.value = error.message;
-      errorRequestId.value = error.requestId;
-    } else {
-      errorMessage.value = "Unable to reset scholar image.";
-    }
-  } finally {
-    imageSavingScholarId.value = null;
-  }
-}
-
-onMounted(() => {
-  void loadScholars();
-});
-
-onUnmounted(() => {
-  stopScholarLiveSync();
-});
+onMounted(() => { void loadScholars(); });
+onUnmounted(() => { stopScholarLiveSync(); });
 
 watch(
   () => runStatus.isLikelyRunning,
-  (isRunning) => {
-    if (isRunning) {
-      startScholarLiveSync();
-      return;
-    }
-    stopScholarLiveSync();
-  },
+  (isRunning) => { if (isRunning) { startScholarLiveSync(); } else { stopScholarLiveSync(); } },
   { immediate: true },
 );
 </script>
@@ -693,163 +439,12 @@ watch(
 
       <section class="grid min-h-0 flex-1 gap-4 xl:h-full xl:grid-cols-2 xl:grid-rows-[minmax(0,1fr)] xl:overflow-hidden">
         <div class="grid content-start gap-4 xl:order-2 xl:h-full xl:min-h-0 xl:grid-rows-[minmax(0,1fr)_minmax(0,1fr)] xl:overflow-hidden">
-          <AppCard class="space-y-4 xl:flex xl:min-h-0 xl:flex-col">
-            <div class="space-y-1">
-              <div class="flex items-center gap-1">
-                <h2 class="text-lg font-semibold text-ink-primary">Add Scholar Profiles</h2>
-                <AppHelpHint
-                  text="A scholar profile is a Google Scholar author page that Scholarr will monitor for publication changes."
-                />
-              </div>
-              <p class="text-sm text-secondary">Paste one or more Scholar IDs or profile URLs and add them in one action.</p>
-            </div>
-
-            <form class="grid gap-3" @submit.prevent="onAddScholars">
-              <label class="grid gap-2 text-sm font-medium text-ink-secondary" for="scholar-batch-input">
-                <span>Scholar IDs or profile URLs</span>
-                <textarea
-                  id="scholar-batch-input"
-                  v-model="scholarBatchInput"
-                  rows="5"
-                  placeholder="A-UbBTPM15wL\nhttps://scholar.google.com/citations?hl=en&user=A-UbBTPM15wL"
-                  class="w-full rounded-lg border border-stroke-interactive bg-surface-input px-3 py-2 text-sm text-ink-primary outline-none ring-focus-ring transition placeholder:text-ink-muted focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:ring-offset-focus-offset disabled:cursor-not-allowed disabled:opacity-60"
-                />
-              </label>
-
-              <div class="flex flex-wrap items-center justify-between gap-2">
-                <p class="text-xs text-secondary">
-                  Parsed IDs: <strong class="text-ink-primary">{{ parsedBatchCount }}</strong>
-                </p>
-                <AppButton type="submit" :disabled="saving || loading">
-                  {{ saving ? "Adding..." : "Add scholars" }}
-                </AppButton>
-              </div>
-            </form>
-          </AppCard>
-
-          <AppCard class="relative space-y-4 select-none xl:flex xl:min-h-0 xl:flex-col xl:overflow-hidden">
-            <div class="flex flex-wrap items-start justify-between gap-2">
-              <div class="space-y-1">
-                <div class="flex items-center gap-1">
-                  <h2 class="text-lg font-semibold text-ink-primary">Search by Name</h2>
-                  <AppHelpHint text="Google Scholar now challenges this endpoint with account login and anti-bot checks, so this workflow stays disabled." />
-                </div>
-                <p class="text-sm text-secondary">
-                  This helper remains paused because Google Scholar currently requires account login for reliable name search access.
-                </p>
-              </div>
-              <AppHelpHint text="Name search is kept as WIP. Use direct Scholar ID or profile URL adds for production tracking.">
-                <template #trigger>
-                  <AppBadge tone="warning">WIP</AppBadge>
-                </template>
-              </AppHelpHint>
-            </div>
-
-            <form class="pointer-events-none flex flex-wrap items-center gap-2 opacity-60">
-              <div class="min-w-0 flex-1">
-                <AppInput
-                  id="scholar-search-name"
-                  v-model="searchQuery"
-                  placeholder="e.g. Geoffrey Hinton"
-                  :disabled="nameSearchWip"
-                />
-              </div>
-              <AppButton type="button" :disabled="nameSearchWip">
-                Search
-              </AppButton>
-            </form>
-            <p class="text-xs text-secondary">
-              Direct Scholar ID/URL adds above are the supported path until name search can run without login challenges.
-            </p>
-
-            <div class="min-h-0 xl:flex-1 xl:overflow-y-auto xl:pr-1">
-              <RequestStateAlerts
-                :error-message="searchErrorMessage"
-                :error-request-id="searchErrorRequestId"
-                error-title="Search request failed"
-              />
-
-              <AsyncStateGate :loading="searchingByName" :loading-lines="4" :show-empty="false">
-                <template v-if="searchResult">
-                  <div class="flex flex-wrap items-center justify-between gap-2">
-                    <p class="text-sm text-secondary">
-                      {{ searchResult.candidates.length }} candidate{{ searchResult.candidates.length === 1 ? "" : "s" }}
-                      for <strong class="text-ink-primary">{{ searchResult.query }}</strong>
-                    </p>
-                    <AppBadge :tone="searchStateTone">{{ searchResult.state }}</AppBadge>
-                  </div>
-
-                  <p v-if="searchResult.state !== 'ok' || searchResult.warnings.length > 0" class="text-xs text-secondary">
-                    <span>State reason: <code>{{ searchResult.state_reason }}</code></span>
-                    <span v-if="searchResult.action_hint">. {{ searchResult.action_hint }}</span>
-                    <span v-if="searchResult.warnings.length > 0">. Warnings: {{ searchResult.warnings.join(", ") }}</span>
-                  </p>
-
-                  <AppAlert v-if="searchIsDegraded" tone="warning">
-                    <template #title>Name search is degraded</template>
-                    <p>
-                      This endpoint throttles aggressively to avoid blocks. Use Scholar URL/ID adds for dependable tracking.
-                    </p>
-                  </AppAlert>
-
-                  <AsyncStateGate
-                    :loading="false"
-                    :show-empty="true"
-                    :empty="emptySearchCandidates"
-                    empty-title="No scholar matches returned"
-                    empty-body="Try another query later or add directly by Scholar URL/ID."
-                  >
-                    <ul class="grid gap-3">
-                      <li
-                        v-for="candidate in searchResult.candidates"
-                        :key="candidate.scholar_id"
-                        class="rounded-xl border border-stroke-default bg-surface-card-muted/70 p-3"
-                      >
-                        <div class="flex items-start gap-3">
-                          <ScholarAvatar
-                            size="sm"
-                            :label="candidate.display_name"
-                            :scholar-id="candidate.scholar_id"
-                            :image-url="candidate.profile_image_url"
-                          />
-
-                          <div class="min-w-0 flex-1 space-y-1">
-                            <div class="flex flex-wrap items-center gap-2">
-                              <strong class="text-sm text-ink-primary">{{ candidate.display_name }}</strong>
-                              <code class="text-xs text-secondary">{{ candidate.scholar_id }}</code>
-                              <AppBadge v-if="trackedScholarIds.has(candidate.scholar_id)" tone="success">Tracked</AppBadge>
-                            </div>
-
-                            <p class="truncate text-xs text-secondary">{{ candidate.affiliation || "No affiliation provided" }}</p>
-
-                            <div class="flex flex-wrap items-center gap-2 text-xs text-secondary">
-                              <span v-if="candidate.email_domain">Email: {{ candidate.email_domain }}</span>
-                              <span v-if="candidate.cited_by_count !== null">Cited by: {{ candidate.cited_by_count }}</span>
-                            </div>
-                          </div>
-
-                          <div class="grid shrink-0 gap-2">
-                            <AppButton
-                              :disabled="trackedScholarIds.has(candidate.scholar_id) || addingCandidateScholarId === candidate.scholar_id"
-                              @click="onAddCandidate(candidate)"
-                            >
-                              {{ addingCandidateScholarId === candidate.scholar_id ? "Adding..." : "Add" }}
-                            </AppButton>
-                            <a :href="candidate.profile_url" target="_blank" rel="noreferrer" class="link-inline text-xs text-center">
-                              Open profile
-                            </a>
-                          </div>
-                        </div>
-                      </li>
-                    </ul>
-                  </AsyncStateGate>
-                </template>
-                <p v-else-if="!searchErrorMessage && !searchHasRun" class="text-sm text-secondary">
-                  Name search remains disabled while login-gated responses are unresolved.
-                </p>
-              </AsyncStateGate>
-            </div>
-          </AppCard>
+          <ScholarBatchAdd :saving="saving" :loading="loading" @add-scholars="onAddScholars" />
+          <ScholarNameSearch
+            :tracked-scholar-ids="trackedScholarIds"
+            :adding-candidate-scholar-id="addingCandidateScholarId"
+            @add-candidate="onAddCandidate"
+          />
         </div>
 
         <AppCard class="flex min-h-0 flex-col gap-4 xl:order-1 xl:h-full xl:overflow-hidden">
@@ -857,9 +452,7 @@ watch(
             <div class="space-y-1">
               <div class="flex items-center gap-1">
                 <h2 class="text-lg font-semibold text-ink-primary">Tracked Scholars</h2>
-                <AppHelpHint
-                  text="Tracked scholars are active profile sources. Open Manage to control status, image overrides, and removal."
-                />
+                <AppHelpHint text="Tracked scholars are active profile sources. Open Manage to control status, image overrides, and removal." />
               </div>
               <p class="text-sm text-secondary">Review tracked profiles, filter quickly, and open per-scholar settings when needed.</p>
             </div>
@@ -867,9 +460,7 @@ watch(
               <div class="flex flex-wrap items-center justify-between gap-3">
                 <p class="text-xs font-medium uppercase tracking-wide text-secondary">Tracking status</p>
                 <div class="flex flex-wrap items-center gap-2">
-                  <span
-                    class="inline-flex min-h-10 items-center rounded-lg border border-state-info-border bg-state-info-bg px-3 text-sm font-semibold text-state-info-text"
-                  >
+                  <span class="inline-flex min-h-10 items-center rounded-lg border border-state-info-border bg-state-info-bg px-3 text-sm font-semibold text-state-info-text">
                     {{ trackedCountLabel }}
                   </span>
                   <AppButton variant="secondary" :disabled="loading || exportingData" @click="onExportData">
@@ -878,32 +469,14 @@ watch(
                   <AppButton variant="secondary" :disabled="loading || importingData" @click="onOpenImportPicker">
                     {{ importingData ? "Importing..." : "Import" }}
                   </AppButton>
-                  <AppRefreshButton
-                    variant="secondary"
-                    :disabled="saving"
-                    :loading="loading"
-                    title="Refresh scholars"
-                    loading-title="Refreshing scholars"
-                    @click="loadScholars"
-                  />
+                  <AppRefreshButton variant="secondary" :disabled="saving" :loading="loading" title="Refresh scholars" loading-title="Refreshing scholars" @click="loadScholars" />
                 </div>
               </div>
-              <input
-                ref="importFileInput"
-                type="file"
-                class="sr-only"
-                accept=".json,application/json"
-                @change="onImportFileSelected"
-              />
-
+              <input ref="importFileInput" type="file" class="sr-only" accept=".json,application/json" @change="onImportFileSelected" />
               <div class="grid gap-2 sm:grid-cols-[minmax(0,1fr)_12rem]">
                 <label class="grid gap-1 text-xs font-medium uppercase tracking-wide text-secondary" for="tracked-scholar-filter">
                   <span>Filter tracked scholars</span>
-                  <AppInput
-                    id="tracked-scholar-filter"
-                    v-model="trackedFilterQuery"
-                    placeholder="Filter by name or scholar ID"
-                  />
+                  <AppInput id="tracked-scholar-filter" v-model="trackedFilterQuery" placeholder="Filter by name or scholar ID" />
                 </label>
                 <label class="grid gap-1 text-xs font-medium uppercase tracking-wide text-secondary" for="tracked-scholar-sort">
                   <span>Sort</span>
@@ -919,47 +492,24 @@ watch(
           </div>
 
           <div class="min-h-0 flex-1 xl:overflow-hidden">
-            <AsyncStateGate
-              :loading="loading"
-              :loading-lines="6"
-              :empty="!hasTrackedScholars"
-              :show-empty="!errorMessage"
-              empty-title="No scholars tracked"
-              empty-body="Add a Scholar ID or URL to start ingestion tracking."
-            >
-              <AppEmptyState
-                v-if="!hasVisibleScholars"
-                title="No scholars match this filter"
-                body="Clear or adjust the filter to see tracked scholars."
-              />
-
+            <AsyncStateGate :loading="loading" :loading-lines="6" :empty="!hasTrackedScholars" :show-empty="!errorMessage" empty-title="No scholars tracked" empty-body="Add a Scholar ID or URL to start ingestion tracking.">
+              <AppEmptyState v-if="!hasVisibleScholars" title="No scholars match this filter" body="Clear or adjust the filter to see tracked scholars." />
               <div v-else class="space-y-3 xl:flex xl:h-full xl:min-h-0 xl:flex-col xl:space-y-0 xl:overflow-hidden">
                 <ul class="flex gap-3 overflow-x-auto p-1 lg:hidden">
-                  <li
-                    v-for="item in visibleScholars"
-                    :key="item.id"
-                    class="rounded-xl border border-stroke-default bg-surface-card-muted/70 p-3"
-                  >
+                  <li v-for="item in visibleScholars" :key="item.id" class="rounded-xl border border-stroke-default bg-surface-card-muted/70 p-3">
                     <div class="flex items-start gap-3">
                       <ScholarAvatar :label="item.display_name" :scholar-id="item.scholar_id" :image-url="item.profile_image_url" />
-
                       <div class="min-w-0 flex-1 space-y-1">
                         <p class="truncate text-sm font-semibold text-ink-primary">{{ scholarLabel(item) }}</p>
                         <div class="flex flex-wrap items-center gap-3">
-                          <RouterLink :to="scholarPublicationsRoute(item)" class="link-inline text-xs">
-                            Publications
-                          </RouterLink>
-                          <a :href="scholarProfileUrl(item.scholar_id)" target="_blank" rel="noreferrer" class="link-inline text-xs">
-                            Open profile
-                          </a>
+                          <RouterLink :to="scholarPublicationsRoute(item)" class="link-inline text-xs">Publications</RouterLink>
+                          <a :href="scholarProfileUrl(item.scholar_id)" target="_blank" rel="noreferrer" class="link-inline text-xs">Open profile</a>
                         </div>
                       </div>
-
-                      <AppButton variant="secondary" :disabled="saving" @click="openScholarSettings(item)">Manage</AppButton>
+                      <AppButton variant="secondary" :disabled="saving" @click="activeScholarSettingsId = item.id">Manage</AppButton>
                     </div>
                   </li>
                 </ul>
-
                 <div class="hidden min-h-0 flex-1 overflow-hidden lg:block">
                   <AppTable class="h-full overflow-y-scroll overscroll-contain" label="Tracked scholars table">
                     <thead>
@@ -973,22 +523,17 @@ watch(
                         <td>
                           <div class="flex items-start gap-3">
                             <ScholarAvatar :label="item.display_name" :scholar-id="item.scholar_id" :image-url="item.profile_image_url" />
-
                             <div class="grid min-w-0 gap-1">
                               <strong class="truncate text-ink-primary">{{ scholarLabel(item) }}</strong>
                               <div class="flex flex-wrap items-center gap-3">
-                                <RouterLink :to="scholarPublicationsRoute(item)" class="link-inline text-xs">
-                                  Publications
-                                </RouterLink>
-                                <a :href="scholarProfileUrl(item.scholar_id)" target="_blank" rel="noreferrer" class="link-inline text-xs">
-                                  Open profile
-                                </a>
+                                <RouterLink :to="scholarPublicationsRoute(item)" class="link-inline text-xs">Publications</RouterLink>
+                                <a :href="scholarProfileUrl(item.scholar_id)" target="_blank" rel="noreferrer" class="link-inline text-xs">Open profile</a>
                               </div>
                             </div>
                           </div>
                         </td>
                         <td>
-                          <AppButton variant="secondary" :disabled="saving" @click="openScholarSettings(item)">Manage</AppButton>
+                          <AppButton variant="secondary" :disabled="saving" @click="activeScholarSettingsId = item.id">Manage</AppButton>
                         </td>
                       </tr>
                     </tbody>
@@ -1001,98 +546,20 @@ watch(
       </section>
     </div>
 
-    <AppModal :open="activeScholarSettings !== null" title="Scholar settings" @close="closeScholarSettings">
-      <div v-if="activeScholarSettings" class="grid gap-4">
-        <div class="flex items-start gap-3">
-          <ScholarAvatar
-            :label="activeScholarSettings.display_name"
-            :scholar-id="activeScholarSettings.scholar_id"
-            :image-url="activeScholarSettings.profile_image_url"
-          />
-
-          <div class="min-w-0 space-y-1">
-            <p class="truncate text-sm font-semibold text-ink-primary">
-              {{ scholarLabel(activeScholarSettings) }}
-            </p>
-            <p class="text-xs text-secondary">
-              ID: <code>{{ activeScholarSettings.scholar_id }}</code>
-            </p>
-            <div class="flex flex-wrap items-center gap-3">
-              <RouterLink :to="scholarPublicationsRoute(activeScholarSettings)" class="link-inline text-xs">
-                View publications
-              </RouterLink>
-              <a
-                :href="scholarProfileUrl(activeScholarSettings.scholar_id)"
-                target="_blank"
-                rel="noreferrer"
-                class="link-inline text-xs"
-              >
-                Open Google Scholar profile
-              </a>
-            </div>
-          </div>
-        </div>
-
-        <div class="grid gap-2">
-          <label class="text-sm font-medium text-ink-secondary" :for="`scholar-image-url-${activeScholarSettings.id}`">
-            Profile image URL override
-          </label>
-          <div class="flex flex-wrap items-center gap-2">
-            <div class="min-w-0 flex-1">
-              <AppInput
-                :id="`scholar-image-url-${activeScholarSettings.id}`"
-                v-model="imageUrlDraftByScholarId[activeScholarSettings.id]"
-                placeholder="https://example.com/avatar.jpg"
-                :disabled="isImageBusy(activeScholarSettings.id)"
-              />
-            </div>
-            <AppButton
-              variant="secondary"
-              :disabled="isImageBusy(activeScholarSettings.id)"
-              @click="onSaveImageUrl(activeScholarSettings)"
-            >
-              {{ imageSavingScholarId === activeScholarSettings.id ? "Saving..." : "Save URL" }}
-            </AppButton>
-          </div>
-          <div class="flex flex-wrap items-center gap-2">
-            <label
-              :for="`scholar-image-upload-${activeScholarSettings.id}`"
-              class="inline-flex min-h-10 cursor-pointer items-center justify-center rounded-lg border border-stroke-strong bg-action-secondary-bg px-3 py-2 text-sm font-semibold text-action-secondary-text transition hover:bg-action-secondary-hover-bg focus-within:outline-none focus-within:ring-2 focus-within:ring-focus-ring focus-within:ring-offset-2 focus-within:ring-offset-focus-offset"
-              :class="{ 'pointer-events-none opacity-60': isImageBusy(activeScholarSettings.id) }"
-            >
-              {{ imageUploadingScholarId === activeScholarSettings.id ? "Uploading..." : "Upload image" }}
-            </label>
-            <input
-              :id="`scholar-image-upload-${activeScholarSettings.id}`"
-              type="file"
-              class="sr-only"
-              accept="image/jpeg,image/png,image/webp,image/gif"
-              :disabled="isImageBusy(activeScholarSettings.id)"
-              @change="onUploadImage(activeScholarSettings, $event)"
-            />
-            <AppButton variant="ghost" :disabled="isImageBusy(activeScholarSettings.id)" @click="onResetImage(activeScholarSettings)">
-              Reset image
-            </AppButton>
-          </div>
-        </div>
-
-        <div class="flex flex-wrap items-center justify-between gap-2 border-t border-stroke-default pt-3">
-          <AppButton
-            variant="secondary"
-            :disabled="isImageBusy(activeScholarSettings.id) || saving"
-            @click="onToggleScholar(activeScholarSettings)"
-          >
-            {{ activeScholarSettings.is_enabled ? "Disable scholar" : "Enable scholar" }}
-          </AppButton>
-          <AppButton
-            variant="danger"
-            :disabled="isImageBusy(activeScholarSettings.id) || saving"
-            @click="onDeleteScholar(activeScholarSettings)"
-          >
-            Delete scholar
-          </AppButton>
-        </div>
-      </div>
-    </AppModal>
+    <ScholarSettingsModal
+      :scholar="activeScholarSettings"
+      :image-url-draft="activeScholarSettings ? (imageUrlDraftByScholarId[activeScholarSettings.id] ?? '') : ''"
+      :image-busy="activeScholarSettings ? isImageBusy(activeScholarSettings.id) : false"
+      :image-saving="activeScholarSettings ? imageSavingScholarId === activeScholarSettings.id : false"
+      :image-uploading="activeScholarSettings ? imageUploadingScholarId === activeScholarSettings.id : false"
+      :saving="saving"
+      @close="activeScholarSettingsId = null"
+      @update:image-url-draft="v => { if (activeScholarSettings) imageUrlDraftByScholarId[activeScholarSettings.id] = v; }"
+      @save-image-url="onSaveImageUrl"
+      @upload-image="onUploadImage"
+      @reset-image="onResetImage"
+      @toggle="onToggleScholar"
+      @delete="onDeleteScholar"
+    />
   </AppPage>
 </template>
diff --git a/tests/integration/helpers.py b/tests/integration/helpers.py
index 135f271..ce5ed3f 100644
--- a/tests/integration/helpers.py
+++ b/tests/integration/helpers.py
@@ -1,11 +1,35 @@
 from __future__ import annotations
 
+import asyncio
+from pathlib import Path
+
 from fastapi.testclient import TestClient
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.auth.security import PasswordService
 
+REGRESSION_FIXTURE_DIR = Path("tests/fixtures/scholar/regression")
+SAFETY_STATE_KEYS = {
+    "cooldown_active",
+    "cooldown_reason",
+    "cooldown_reason_label",
+    "cooldown_until",
+    "cooldown_remaining_seconds",
+    "recommended_action",
+    "counters",
+}
+SAFETY_COUNTER_KEYS = {
+    "consecutive_blocked_runs",
+    "consecutive_network_runs",
+    "cooldown_entry_count",
+    "blocked_start_count",
+    "last_blocked_failure_count",
+    "last_network_failure_count",
+    "last_evaluated_run_id",
+}
+ACTIVE_RUN_STATUSES = {"running", "resolving"}
+
 
 def login_user(client: TestClient, *, email: str, password: str) -> None:
     bootstrap_response = client.get("/api/v1/auth/csrf")
@@ -54,3 +78,93 @@ async def insert_user(
     user_id = int(result.scalar_one())
     await db_session.commit()
     return user_id
+
+
+def api_bootstrap_csrf_headers(client: TestClient) -> dict[str, str]:
+    bootstrap_response = client.get("/api/v1/auth/csrf")
+    assert bootstrap_response.status_code == 200
+    payload = bootstrap_response.json()["data"]
+    token = payload["csrf_token"]
+    assert isinstance(token, str) and token
+    return {"X-CSRF-Token": token}
+
+
+def api_csrf_headers(client: TestClient) -> dict[str, str]:
+    me_response = client.get("/api/v1/auth/me")
+    assert me_response.status_code == 200
+    body = me_response.json()
+    token = body["data"]["csrf_token"]
+    assert isinstance(token, str) and token
+    return {"X-CSRF-Token": token}
+
+
+def regression_fixture(name: str) -> str:
+    return (REGRESSION_FIXTURE_DIR / name).read_text(encoding="utf-8")
+
+
+def assert_safety_state_contract(payload: dict[str, object]) -> None:
+    assert set(payload.keys()) == SAFETY_STATE_KEYS
+    counters = payload["counters"]
+    assert isinstance(counters, dict)
+    assert set(counters.keys()) == SAFETY_COUNTER_KEYS
+
+
+async def wait_for_run_complete(
+    client: TestClient,
+    run_id: int,
+    *,
+    max_retries: int = 300,
+    poll_interval: float = 0.2,
+) -> dict:
+    for _ in range(max_retries):
+        await asyncio.sleep(poll_interval)
+        r = client.get(f"/api/v1/runs/{run_id}")
+        assert r.status_code == 200
+        data = r.json()["data"]
+        if data["run"]["status"] not in ACTIVE_RUN_STATUSES:
+            return data
+    r = client.get(f"/api/v1/runs/{run_id}")
+    return r.json()["data"]
+
+
+async def seed_publication_link_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    scholar_id: str,
+    title: str,
+    fingerprint: str,
+) -> tuple[int, int]:
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {"user_id": user_id, "scholar_id": scholar_id, "display_name": scholar_id},
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    publication_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 4)
+            RETURNING id
+            """
+        ),
+        {"fingerprint": fingerprint, "title_raw": title, "title_normalized": title.lower()},
+    )
+    publication_id = int(publication_result.scalar_one())
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
+            VALUES (:scholar_profile_id, :publication_id, false)
+            """
+        ),
+        {"scholar_profile_id": scholar_profile_id, "publication_id": publication_id},
+    )
+    await db_session.commit()
+    return scholar_profile_id, publication_id
diff --git a/tests/integration/test_api_admin.py b/tests/integration/test_api_admin.py
new file mode 100644
index 0000000..fb63f34
--- /dev/null
+++ b/tests/integration/test_api_admin.py
@@ -0,0 +1,576 @@
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.main import app
+from app.settings import settings
+from tests.integration.helpers import (
+    api_bootstrap_csrf_headers,
+    api_csrf_headers,
+    insert_user,
+    login_user,
+    seed_publication_link_for_user,
+)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_admin_user_management_endpoints(db_session: AsyncSession) -> None:
+    admin_user_id = await insert_user(
+        db_session,
+        email="api-admin@example.com",
+        password="admin-password",
+        is_admin=True,
+    )
+    target_user_id = await insert_user(
+        db_session,
+        email="api-target@example.com",
+        password="target-password",
+        is_admin=False,
+    )
+    await insert_user(
+        db_session,
+        email="api-member@example.com",
+        password="member-password",
+        is_admin=False,
+    )
+
+    client = TestClient(app)
+    login_user(client, email="api-admin@example.com", password="admin-password")
+    headers = api_csrf_headers(client)
+
+    list_response = client.get("/api/v1/admin/users")
+    assert list_response.status_code == 200
+    users = list_response.json()["data"]["users"]
+    assert any(item["email"] == "api-target@example.com" for item in users)
+
+    create_response = client.post(
+        "/api/v1/admin/users",
+        json={
+            "email": "api-created@example.com",
+            "password": "created-password",
+            "is_admin": True,
+        },
+        headers=headers,
+    )
+    assert create_response.status_code == 201
+    created_user = create_response.json()["data"]
+    assert created_user["email"] == "api-created@example.com"
+    created_user_id = int(created_user["id"])
+
+    deactivate_response = client.patch(
+        f"/api/v1/admin/users/{target_user_id}/active",
+        json={"is_active": False},
+        headers=headers,
+    )
+    assert deactivate_response.status_code == 200
+    assert deactivate_response.json()["data"]["is_active"] is False
+
+    reactivate_response = client.patch(
+        f"/api/v1/admin/users/{target_user_id}/active",
+        json={"is_active": True},
+        headers=headers,
+    )
+    assert reactivate_response.status_code == 200
+    assert reactivate_response.json()["data"]["is_active"] is True
+
+    reset_response = client.post(
+        f"/api/v1/admin/users/{target_user_id}/reset-password",
+        json={"new_password": "target-password-updated"},
+        headers=headers,
+    )
+    assert reset_response.status_code == 200
+    assert "Password reset" in reset_response.json()["data"]["message"]
+
+    self_deactivate = client.patch(
+        f"/api/v1/admin/users/{admin_user_id}/active",
+        json={"is_active": False},
+        headers=headers,
+    )
+    assert self_deactivate.status_code == 400
+    assert self_deactivate.json()["error"]["code"] == "cannot_deactivate_self"
+
+    logout_response = client.post("/api/v1/auth/logout", headers=headers)
+    assert logout_response.status_code == 200
+
+    target_headers = api_bootstrap_csrf_headers(client)
+    target_login = client.post(
+        "/api/v1/auth/login",
+        json={"email": "api-target@example.com", "password": "target-password-updated"},
+        headers=target_headers,
+    )
+    assert target_login.status_code == 200
+
+    non_admin_headers = {"X-CSRF-Token": target_login.json()["data"]["csrf_token"]}
+    forbidden_response = client.get("/api/v1/admin/users")
+    assert forbidden_response.status_code == 403
+    assert forbidden_response.json()["error"]["code"] == "forbidden"
+
+    forbidden_create = client.post(
+        "/api/v1/admin/users",
+        json={
+            "email": "should-not-work@example.com",
+            "password": "password-123",
+            "is_admin": False,
+        },
+        headers=non_admin_headers,
+    )
+    assert forbidden_create.status_code == 403
+
+    created_exists = await db_session.execute(
+        text("SELECT COUNT(*) FROM users WHERE id = :user_id"),
+        {"user_id": created_user_id},
+    )
+    assert created_exists.scalar_one() == 1
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_admin_scholar_http_settings_endpoints(db_session: AsyncSession) -> None:
+    await insert_user(
+        db_session,
+        email="api-admin-http@example.com",
+        password="admin-password",
+        is_admin=True,
+    )
+    await insert_user(
+        db_session,
+        email="api-member-http@example.com",
+        password="member-password",
+        is_admin=False,
+    )
+    previous_user_agent = settings.scholar_http_user_agent
+    previous_rotate = settings.scholar_http_rotate_user_agent
+    previous_accept_language = settings.scholar_http_accept_language
+    previous_cookie = settings.scholar_http_cookie
+    try:
+        client = TestClient(app)
+        login_user(client, email="api-admin-http@example.com", password="admin-password")
+        headers = api_csrf_headers(client)
+
+        read_response = client.get("/api/v1/admin/settings/scholar-http")
+        assert read_response.status_code == 200
+
+        update_response = client.put(
+            "/api/v1/admin/settings/scholar-http",
+            json={
+                "user_agent": "Mozilla/5.0 Test Runner",
+                "rotate_user_agent": False,
+                "accept_language": "en-US,en;q=0.8",
+                "cookie": "SID=test-cookie",
+            },
+            headers=headers,
+        )
+        assert update_response.status_code == 200
+        payload = update_response.json()["data"]
+        assert payload["user_agent"] == "Mozilla/5.0 Test Runner"
+        assert payload["cookie"] == "SID=test-cookie"
+        assert settings.scholar_http_user_agent == "Mozilla/5.0 Test Runner"
+
+        client.post("/api/v1/auth/logout", headers=headers)
+        login_user(client, email="api-member-http@example.com", password="member-password")
+        forbidden_response = client.get("/api/v1/admin/settings/scholar-http")
+        assert forbidden_response.status_code == 403
+    finally:
+        object.__setattr__(settings, "scholar_http_user_agent", previous_user_agent)
+        object.__setattr__(settings, "scholar_http_rotate_user_agent", previous_rotate)
+        object.__setattr__(settings, "scholar_http_accept_language", previous_accept_language)
+        object.__setattr__(settings, "scholar_http_cookie", previous_cookie)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_admin_dbops_integrity_and_repair_flow(db_session: AsyncSession) -> None:
+    await insert_user(db_session, email="api-admin-dbops@example.com", password="admin-password", is_admin=True)
+    target_user_id = await insert_user(db_session, email="api-dbops-target@example.com", password="target-password")
+    _scholar_id, publication_id = await seed_publication_link_for_user(
+        db_session,
+        user_id=target_user_id,
+        scholar_id="dbopsTarget01",
+        title="DB Ops Target Paper",
+        fingerprint=f"{(target_user_id + 31):064x}",
+    )
+    client = TestClient(app)
+    login_user(client, email="api-admin-dbops@example.com", password="admin-password")
+    headers = api_csrf_headers(client)
+
+    integrity_response = client.get("/api/v1/admin/db/integrity")
+    assert integrity_response.status_code == 200
+    integrity_payload = integrity_response.json()["data"]
+    assert integrity_payload["status"] in {"ok", "warning", "failed"}
+    assert any(check["name"] == "missing_pdf_url" for check in integrity_payload["checks"])
+
+    repair_response = client.post(
+        "/api/v1/admin/db/repairs/publication-links",
+        json={"user_id": target_user_id, "dry_run": True},
+        headers=headers,
+    )
+    assert repair_response.status_code == 200
+    repair_data = repair_response.json()["data"]
+    assert repair_data["status"] == "completed"
+    assert bool(repair_data["summary"]["dry_run"]) is True
+    job_id = int(repair_data["job_id"])
+
+    jobs_response = client.get("/api/v1/admin/db/repair-jobs?limit=10")
+    assert jobs_response.status_code == 200
+    jobs = jobs_response.json()["data"]["jobs"]
+    assert any(int(job["id"]) == job_id for job in jobs)
+
+    pdf_queue_response = client.get("/api/v1/admin/db/pdf-queue?limit=20")
+    assert pdf_queue_response.status_code == 200
+    pdf_queue_payload = pdf_queue_response.json()["data"]
+    assert isinstance(pdf_queue_payload["items"], list)
+    assert int(pdf_queue_payload["page"]) == 1
+    assert int(pdf_queue_payload["page_size"]) == 20
+    assert int(pdf_queue_payload["total_count"]) >= 0
+    assert isinstance(pdf_queue_payload["has_next"], bool)
+    assert isinstance(pdf_queue_payload["has_prev"], bool)
+    page_two_response = client.get("/api/v1/admin/db/pdf-queue?page=2&page_size=1")
+    assert page_two_response.status_code == 200
+    page_two_payload = page_two_response.json()["data"]
+    assert int(page_two_payload["page"]) == 2
+    assert int(page_two_payload["page_size"]) == 1
+    assert page_two_payload["has_prev"] is True
+    untracked_response = client.get("/api/v1/admin/db/pdf-queue?limit=20&status=untracked")
+    assert untracked_response.status_code == 200
+    assert any(item["status"] == "untracked" for item in untracked_response.json()["data"]["items"])
+
+    link_count_result = await db_session.execute(
+        text("SELECT count(*) FROM scholar_publications WHERE publication_id = :publication_id"),
+        {"publication_id": publication_id},
+    )
+    assert int(link_count_result.scalar_one()) == 1
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_admin_dbops_pdf_queue_requeue_endpoint(
+    db_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    await insert_user(db_session, email="api-admin-pdf@example.com", password="admin-password", is_admin=True)
+    target_user_id = await insert_user(db_session, email="api-pdf-target@example.com", password="target-password")
+    _scholar_id, publication_id = await seed_publication_link_for_user(
+        db_session,
+        user_id=target_user_id,
+        scholar_id="dbopsPdf01",
+        title="PDF Queue Target",
+        fingerprint=f"{(target_user_id + 73):064x}",
+    )
+    monkeypatch.setattr(
+        "app.services.publications.pdf_queue.schedule_rows",
+        lambda **_kwargs: None,
+    )
+    client = TestClient(app)
+    login_user(client, email="api-admin-pdf@example.com", password="admin-password")
+    headers = api_csrf_headers(client)
+
+    first_response = client.post(
+        f"/api/v1/admin/db/pdf-queue/{publication_id}/requeue",
+        headers=headers,
+    )
+    assert first_response.status_code == 200
+    first_data = first_response.json()["data"]
+    assert first_data["publication_id"] == publication_id
+    assert first_data["queued"] is True
+    assert first_data["status"] == "queued"
+
+    second_response = client.post(
+        f"/api/v1/admin/db/pdf-queue/{publication_id}/requeue",
+        headers=headers,
+    )
+    assert second_response.status_code == 200
+    second_data = second_response.json()["data"]
+    assert second_data["queued"] is False
+    assert second_data["status"] == "blocked"
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_admin_dbops_pdf_queue_requeue_all_endpoint(
+    db_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    await insert_user(db_session, email="api-admin-pdf-all@example.com", password="admin-password", is_admin=True)
+    target_user_id = await insert_user(db_session, email="api-pdf-all-target@example.com", password="target-password")
+    _scholar_id, _publication_id = await seed_publication_link_for_user(
+        db_session,
+        user_id=target_user_id,
+        scholar_id="dbopsPdfAll01",
+        title="PDF Queue All Target",
+        fingerprint=f"{(target_user_id + 83):064x}",
+    )
+    monkeypatch.setattr(
+        "app.services.publications.pdf_queue.schedule_rows",
+        lambda **_kwargs: None,
+    )
+    client = TestClient(app)
+    login_user(client, email="api-admin-pdf-all@example.com", password="admin-password")
+    headers = api_csrf_headers(client)
+
+    response = client.post(
+        "/api/v1/admin/db/pdf-queue/requeue-all?limit=500",
+        headers=headers,
+    )
+    assert response.status_code == 200
+    payload = response.json()["data"]
+    assert int(payload["requested_count"]) >= 1
+    assert int(payload["queued_count"]) >= 1
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_admin_dbops_forbidden_for_non_admin_and_validates_scope(db_session: AsyncSession) -> None:
+    await insert_user(db_session, email="api-admin-dbops2@example.com", password="admin-password", is_admin=True)
+    member_user_id = await insert_user(db_session, email="api-dbops-member@example.com", password="member-password")
+    client = TestClient(app)
+    login_user(client, email="api-dbops-member@example.com", password="member-password")
+    headers = api_csrf_headers(client)
+
+    forbidden_integrity = client.get("/api/v1/admin/db/integrity")
+    assert forbidden_integrity.status_code == 403
+    assert forbidden_integrity.json()["error"]["code"] == "forbidden"
+
+    forbidden_pdf_queue = client.get("/api/v1/admin/db/pdf-queue")
+    assert forbidden_pdf_queue.status_code == 403
+    assert forbidden_pdf_queue.json()["error"]["code"] == "forbidden"
+
+    forbidden_requeue = client.post(
+        "/api/v1/admin/db/pdf-queue/1/requeue",
+        headers=headers,
+    )
+    assert forbidden_requeue.status_code == 403
+    assert forbidden_requeue.json()["error"]["code"] == "forbidden"
+
+    forbidden_requeue_all = client.post(
+        "/api/v1/admin/db/pdf-queue/requeue-all?limit=100",
+        headers=headers,
+    )
+    assert forbidden_requeue_all.status_code == 403
+    assert forbidden_requeue_all.json()["error"]["code"] == "forbidden"
+
+    forbidden_repair = client.post(
+        "/api/v1/admin/db/repairs/publication-links",
+        json={"user_id": member_user_id, "dry_run": True},
+        headers=headers,
+    )
+    assert forbidden_repair.status_code == 403
+    assert forbidden_repair.json()["error"]["code"] == "forbidden"
+
+    forbidden_near_duplicate = client.post(
+        "/api/v1/admin/db/repairs/publication-near-duplicates",
+        json={"dry_run": True},
+        headers=headers,
+    )
+    assert forbidden_near_duplicate.status_code == 403
+    assert forbidden_near_duplicate.json()["error"]["code"] == "forbidden"
+
+    admin_headers = api_bootstrap_csrf_headers(client)
+    admin_login = client.post(
+        "/api/v1/auth/login",
+        json={"email": "api-admin-dbops2@example.com", "password": "admin-password"},
+        headers=admin_headers,
+    )
+    assert admin_login.status_code == 200
+    post_login_headers = {"X-CSRF-Token": admin_login.json()["data"]["csrf_token"]}
+    invalid_scope = client.post(
+        "/api/v1/admin/db/repairs/publication-links",
+        json={"user_id": member_user_id, "dry_run": True},
+        headers=post_login_headers,
+    )
+    assert invalid_scope.status_code == 400
+    assert invalid_scope.json()["error"]["code"] == "invalid_repair_scope"
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_admin_dbops_all_users_apply_requires_confirmation(db_session: AsyncSession) -> None:
+    await insert_user(db_session, email="api-admin-dbops3@example.com", password="admin-password", is_admin=True)
+    first_user_id = await insert_user(db_session, email="api-dbops-a@example.com", password="user-password")
+    second_user_id = await insert_user(db_session, email="api-dbops-b@example.com", password="user-password")
+    await seed_publication_link_for_user(
+        db_session,
+        user_id=first_user_id,
+        scholar_id="dbopsAll01",
+        title="DB Ops All User Paper One",
+        fingerprint=f"{(first_user_id + 61):064x}",
+    )
+    await seed_publication_link_for_user(
+        db_session,
+        user_id=second_user_id,
+        scholar_id="dbopsAll02",
+        title="DB Ops All User Paper Two",
+        fingerprint=f"{(second_user_id + 71):064x}",
+    )
+
+    client = TestClient(app)
+    login_user(client, email="api-admin-dbops3@example.com", password="admin-password")
+    headers = api_csrf_headers(client)
+
+    missing_confirmation = client.post(
+        "/api/v1/admin/db/repairs/publication-links",
+        json={"scope_mode": "all_users", "dry_run": False},
+        headers=headers,
+    )
+    assert missing_confirmation.status_code == 422
+    assert "confirmation_text" in str(missing_confirmation.json())
+
+    apply_response = client.post(
+        "/api/v1/admin/db/repairs/publication-links",
+        json={
+            "scope_mode": "all_users",
+            "dry_run": False,
+            "confirmation_text": "REPAIR ALL USERS",
+        },
+        headers=headers,
+    )
+    assert apply_response.status_code == 200
+    apply_data = apply_response.json()["data"]
+    assert apply_data["status"] == "completed"
+    assert apply_data["scope"]["scope_mode"] == "all_users"
+    assert int(apply_data["summary"]["links_deleted"]) >= 2
+
+    remaining_links = await db_session.execute(text("SELECT count(*) FROM scholar_publications"))
+    assert int(remaining_links.scalar_one()) == 0
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_admin_dbops_near_duplicate_repair_scan_and_apply(
+    db_session: AsyncSession,
+) -> None:
+    await insert_user(
+        db_session,
+        email="api-admin-near-dup@example.com",
+        password="admin-password",
+        is_admin=True,
+    )
+    user_id = await insert_user(
+        db_session,
+        email="api-near-dup-target@example.com",
+        password="user-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "nearDupScholar01",
+            "display_name": "Near Dup Target",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    first_pub = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, year, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 2014, 100)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 1201):064x}",
+            "title_raw": "Adam: A method for stochastic optimization",
+            "title_normalized": "adam a method for stochastic optimization",
+        },
+    )
+    first_publication_id = int(first_pub.scalar_one())
+    second_pub = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, year, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 2015, 10)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 1202):064x}",
+            "title_raw": "†œAdam: A method for stochastic optimization, †3rd Int. Conf. Learn. Represent.",
+            "title_normalized": "adam method for stochastic optimization",
+        },
+    )
+    second_publication_id = int(second_pub.scalar_one())
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
+            VALUES (:scholar_profile_id, :first_publication_id, false),
+                   (:scholar_profile_id, :second_publication_id, false)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "first_publication_id": first_publication_id,
+            "second_publication_id": second_publication_id,
+        },
+    )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-admin-near-dup@example.com", password="admin-password")
+    headers = api_csrf_headers(client)
+
+    scan_response = client.post(
+        "/api/v1/admin/db/repairs/publication-near-duplicates",
+        json={"dry_run": True, "max_clusters": 20},
+        headers=headers,
+    )
+    assert scan_response.status_code == 200
+    scan_data = scan_response.json()["data"]
+    assert scan_data["status"] == "completed"
+    assert int(scan_data["summary"]["candidate_cluster_count"]) >= 1
+    assert len(scan_data["clusters"]) >= 1
+    selected_key = str(scan_data["clusters"][0]["cluster_key"])
+
+    missing_confirmation = client.post(
+        "/api/v1/admin/db/repairs/publication-near-duplicates",
+        json={"dry_run": False, "selected_cluster_keys": [selected_key]},
+        headers=headers,
+    )
+    assert missing_confirmation.status_code == 422
+    assert "confirmation_text" in str(missing_confirmation.json())
+
+    apply_response = client.post(
+        "/api/v1/admin/db/repairs/publication-near-duplicates",
+        json={
+            "dry_run": False,
+            "selected_cluster_keys": [selected_key],
+            "confirmation_text": "MERGE SELECTED DUPLICATES",
+        },
+        headers=headers,
+    )
+    assert apply_response.status_code == 200
+    apply_data = apply_response.json()["data"]
+    assert apply_data["status"] == "completed"
+    assert int(apply_data["summary"]["merged_publications"]) >= 1
+
+    remaining = await db_session.execute(
+        text(
+            """
+            SELECT count(*)
+            FROM publications
+            WHERE id IN (:first_publication_id, :second_publication_id)
+            """
+        ),
+        {
+            "first_publication_id": first_publication_id,
+            "second_publication_id": second_publication_id,
+        },
+    )
+    assert int(remaining.scalar_one()) == 1
diff --git a/tests/integration/test_api_auth.py b/tests/integration/test_api_auth.py
new file mode 100644
index 0000000..6d4a0a6
--- /dev/null
+++ b/tests/integration/test_api_auth.py
@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.main import app
+from tests.integration.helpers import (
+    api_bootstrap_csrf_headers,
+    insert_user,
+    login_user,
+)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_me_requires_authentication() -> None:
+    client = TestClient(app)
+
+    response = client.get("/api/v1/auth/me")
+
+    assert response.status_code == 401
+    payload = response.json()
+    assert payload["error"]["code"] == "auth_required"
+    assert payload["error"]["message"] == "Authentication required."
+    assert "request_id" in payload["meta"]
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_envelope_contract_for_success_and_csrf_error() -> None:
+    client = TestClient(app)
+
+    success_response = client.get("/api/v1/auth/csrf")
+    assert success_response.status_code == 200
+    success_payload = success_response.json()
+    assert set(success_payload.keys()) == {"data", "meta"}
+    assert isinstance(success_payload["data"]["csrf_token"], str)
+    assert set(success_payload["meta"].keys()) == {"request_id"}
+
+    error_response = client.post(
+        "/api/v1/auth/login",
+        json={"email": "missing-csrf@example.com", "password": "irrelevant"},
+    )
+    assert error_response.status_code == 403
+    error_payload = error_response.json()
+    assert set(error_payload.keys()) == {"error", "meta"}
+    assert set(error_payload["error"].keys()) == {"code", "message", "details"}
+    assert error_payload["error"]["code"] == "csrf_invalid"
+    assert error_payload["error"]["details"] is None
+    assert set(error_payload["meta"].keys()) == {"request_id"}
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_csrf_bootstrap_returns_token_for_anonymous_and_authenticated(
+    db_session: AsyncSession,
+) -> None:
+    await insert_user(
+        db_session,
+        email="api-bootstrap@example.com",
+        password="api-password",
+    )
+    client = TestClient(app)
+
+    anonymous_response = client.get("/api/v1/auth/csrf")
+    assert anonymous_response.status_code == 200
+    anonymous_payload = anonymous_response.json()["data"]
+    assert isinstance(anonymous_payload["csrf_token"], str)
+    assert anonymous_payload["authenticated"] is False
+
+    login_user(client, email="api-bootstrap@example.com", password="api-password")
+    authenticated_response = client.get("/api/v1/auth/csrf")
+    assert authenticated_response.status_code == 200
+    authenticated_payload = authenticated_response.json()["data"]
+    assert isinstance(authenticated_payload["csrf_token"], str)
+    assert authenticated_payload["authenticated"] is True
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_me_returns_user_and_csrf_token(db_session: AsyncSession) -> None:
+    await insert_user(
+        db_session,
+        email="api-me@example.com",
+        password="api-password",
+    )
+
+    client = TestClient(app)
+    login_user(client, email="api-me@example.com", password="api-password")
+
+    response = client.get("/api/v1/auth/me")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["data"]["authenticated"] is True
+    assert payload["data"]["user"]["email"] == "api-me@example.com"
+    assert isinstance(payload["data"]["csrf_token"], str)
+    assert payload["meta"]["request_id"]
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_login_and_change_password_flow(db_session: AsyncSession) -> None:
+    await insert_user(
+        db_session,
+        email="api-login@example.com",
+        password="old-password",
+    )
+    client = TestClient(app)
+
+    missing_csrf = client.post(
+        "/api/v1/auth/login",
+        json={"email": "api-login@example.com", "password": "old-password"},
+    )
+    assert missing_csrf.status_code == 403
+    assert missing_csrf.json()["error"]["code"] == "csrf_missing"
+
+    login_headers = api_bootstrap_csrf_headers(client)
+    login_response = client.post(
+        "/api/v1/auth/login",
+        json={"email": "api-login@example.com", "password": "old-password"},
+        headers=login_headers,
+    )
+    assert login_response.status_code == 200
+    login_payload = login_response.json()["data"]
+    assert login_payload["authenticated"] is True
+    assert login_payload["user"]["email"] == "api-login@example.com"
+    assert isinstance(login_payload["csrf_token"], str)
+
+    bad_change_response = client.post(
+        "/api/v1/auth/change-password",
+        json={
+            "current_password": "not-correct",
+            "new_password": "new-password",
+            "confirm_password": "new-password",
+        },
+        headers={"X-CSRF-Token": login_payload["csrf_token"]},
+    )
+    assert bad_change_response.status_code == 400
+    assert bad_change_response.json()["error"]["code"] == "invalid_current_password"
+
+    change_response = client.post(
+        "/api/v1/auth/change-password",
+        json={
+            "current_password": "old-password",
+            "new_password": "new-password",
+            "confirm_password": "new-password",
+        },
+        headers={"X-CSRF-Token": login_payload["csrf_token"]},
+    )
+    assert change_response.status_code == 200
+    assert change_response.json()["data"]["message"] == "Password updated successfully."
+
+    logout_response = client.post(
+        "/api/v1/auth/logout",
+        headers={"X-CSRF-Token": login_payload["csrf_token"]},
+    )
+    assert logout_response.status_code == 200
+
+    relogin_headers = api_bootstrap_csrf_headers(client)
+    old_password_login = client.post(
+        "/api/v1/auth/login",
+        json={"email": "api-login@example.com", "password": "old-password"},
+        headers=relogin_headers,
+    )
+    assert old_password_login.status_code == 401
+    assert old_password_login.json()["error"]["code"] == "invalid_credentials"
+
+    fresh_headers = api_bootstrap_csrf_headers(client)
+    new_password_login = client.post(
+        "/api/v1/auth/login",
+        json={"email": "api-login@example.com", "password": "new-password"},
+        headers=fresh_headers,
+    )
+    assert new_password_login.status_code == 200
+    assert new_password_login.json()["data"]["authenticated"] is True
diff --git a/tests/integration/test_api_publications.py b/tests/integration/test_api_publications.py
new file mode 100644
index 0000000..96d3fc5
--- /dev/null
+++ b/tests/integration/test_api_publications.py
@@ -0,0 +1,573 @@
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.main import app
+from tests.integration.helpers import (
+    api_csrf_headers,
+    insert_user,
+    login_user,
+)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_publications_list_and_mark_read(db_session: AsyncSession) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-pubs@example.com",
+        password="api-password",
+    )
+
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "abcDEF123456",
+            "display_name": "Publication Owner",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+
+    publication_a = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (
+                fingerprint_sha256,
+                title_raw,
+                title_normalized,
+                citation_count,
+                pdf_url
+            )
+            VALUES (:fingerprint, :title_raw, :title_normalized, 10, :pdf_url)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{user_id:064x}",
+            "title_raw": "Paper A",
+            "title_normalized": "paper a",
+            "pdf_url": "https://example.org/paper-a.pdf",
+        },
+    )
+    publication_a_id = int(publication_a.scalar_one())
+
+    publication_b = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 4)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 1):064x}",
+            "title_raw": "Paper B",
+            "title_normalized": "paper b",
+        },
+    )
+    publication_b_id = int(publication_b.scalar_one())
+
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
+            VALUES
+              (:scholar_profile_id, :publication_a_id, false),
+              (:scholar_profile_id, :publication_b_id, false)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "publication_a_id": publication_a_id,
+            "publication_b_id": publication_b_id,
+        },
+    )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-pubs@example.com", password="api-password")
+    headers = api_csrf_headers(client)
+
+    list_response = client.get("/api/v1/publications?mode=all")
+    assert list_response.status_code == 200
+    data = list_response.json()["data"]
+    assert data["mode"] == "all"
+    assert data["favorite_only"] is False
+    assert data["total_count"] == 2
+    assert data["unread_count"] == 2
+    assert data["favorites_count"] == 0
+    assert data["latest_count"] == 0
+    assert data["new_count"] == data["latest_count"]
+    assert data["page"] == 1
+    assert data["page_size"] == 100
+    assert data["has_prev"] is False
+    assert data["has_next"] is False
+    assert isinstance(data["publications"], list)
+    assert len(data["publications"]) == 2
+    assert all(bool(item["is_favorite"]) is False for item in data["publications"])
+    pdf_urls = {item["title"]: item["pdf_url"] for item in data["publications"]}
+    assert pdf_urls["Paper A"] == "https://example.org/paper-a.pdf"
+    assert pdf_urls["Paper B"] is None
+
+    latest_response = client.get("/api/v1/publications?mode=latest")
+    assert latest_response.status_code == 200
+    latest_data = latest_response.json()["data"]
+    assert latest_data["mode"] == "latest"
+    assert latest_data["latest_count"] == 0
+
+    unread_response = client.get("/api/v1/publications?mode=unread")
+    assert unread_response.status_code == 200
+    unread_data = unread_response.json()["data"]
+    assert unread_data["mode"] == "unread"
+    assert unread_data["unread_count"] == 2
+
+    alias_response = client.get("/api/v1/publications?mode=new")
+    assert alias_response.status_code == 200
+    alias_data = alias_response.json()["data"]
+    assert alias_data["mode"] == "latest"
+    assert alias_data["latest_count"] == latest_data["latest_count"]
+    assert alias_data["publications"] == latest_data["publications"]
+
+    mark_selected_response = client.post(
+        "/api/v1/publications/mark-read",
+        json={
+            "selections": [
+                {
+                    "scholar_profile_id": scholar_profile_id,
+                    "publication_id": publication_a_id,
+                }
+            ]
+        },
+        headers=headers,
+    )
+    assert mark_selected_response.status_code == 200
+    assert mark_selected_response.json()["data"]["requested_count"] == 1
+    assert mark_selected_response.json()["data"]["updated_count"] == 1
+
+    read_state = await db_session.execute(
+        text(
+            """
+            SELECT publication_id, is_read
+            FROM scholar_publications
+            WHERE scholar_profile_id = :scholar_profile_id
+            ORDER BY publication_id
+            """
+        ),
+        {"scholar_profile_id": scholar_profile_id},
+    )
+    states = {int(row[0]): bool(row[1]) for row in read_state.all()}
+    assert states[publication_a_id] is True
+    assert states[publication_b_id] is False
+
+    mark_response = client.post("/api/v1/publications/mark-all-read", headers=headers)
+    assert mark_response.status_code == 200
+    assert mark_response.json()["data"]["updated_count"] == 1
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_publications_list_supports_pagination(db_session: AsyncSession) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-pubs-paging@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "pagingScholar01",
+            "display_name": "Paging Scholar",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+
+    publication_ids: list[int] = []
+    for index in range(3):
+        created = await db_session.execute(
+            text(
+                """
+                INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+                VALUES (:fingerprint, :title_raw, :title_normalized, 1)
+                RETURNING id
+                """
+            ),
+            {
+                "fingerprint": f"{(user_id + 500 + index):064x}",
+                "title_raw": f"Paged Paper {index}",
+                "title_normalized": f"paged paper {index}",
+            },
+        )
+        publication_ids.append(int(created.scalar_one()))
+
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
+            VALUES
+              (:scholar_profile_id, :publication_1, false, false),
+              (:scholar_profile_id, :publication_2, false, false),
+              (:scholar_profile_id, :publication_3, false, false)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "publication_1": publication_ids[0],
+            "publication_2": publication_ids[1],
+            "publication_3": publication_ids[2],
+        },
+    )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-pubs-paging@example.com", password="api-password")
+
+    first_page = client.get("/api/v1/publications?mode=all&page=1&page_size=2")
+    assert first_page.status_code == 200
+    first_data = first_page.json()["data"]
+    assert first_data["total_count"] == 3
+    assert first_data["page"] == 1
+    assert first_data["page_size"] == 2
+    assert first_data["has_prev"] is False
+    assert first_data["has_next"] is True
+    assert len(first_data["publications"]) == 2
+
+    second_page = client.get("/api/v1/publications?mode=all&page=2&page_size=2")
+    assert second_page.status_code == 200
+    second_data = second_page.json()["data"]
+    assert second_data["total_count"] == 3
+    assert second_data["page"] == 2
+    assert second_data["page_size"] == 2
+    assert second_data["has_prev"] is True
+    assert second_data["has_next"] is False
+    assert len(second_data["publications"]) == 1
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_publications_search_pagination_uses_filtered_total_count(
+    db_session: AsyncSession,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-pubs-search-page@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "searchPagingScholar01",
+            "display_name": "Search Paging Scholar",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    titles = ["Alpha Optimization", "Alpha Learning", "Beta Methods"]
+    publication_ids: list[int] = []
+    for index, title in enumerate(titles):
+        created = await db_session.execute(
+            text(
+                """
+                INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+                VALUES (:fingerprint, :title_raw, :title_normalized, 1)
+                RETURNING id
+                """
+            ),
+            {
+                "fingerprint": f"{(user_id + 900 + index):064x}",
+                "title_raw": title,
+                "title_normalized": title.lower(),
+            },
+        )
+        publication_ids.append(int(created.scalar_one()))
+    for publication_id in publication_ids:
+        await db_session.execute(
+            text(
+                """
+                INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
+                VALUES (:scholar_profile_id, :publication_id, false, false)
+                """
+            ),
+            {"scholar_profile_id": scholar_profile_id, "publication_id": publication_id},
+        )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-pubs-search-page@example.com", password="api-password")
+
+    response = client.get("/api/v1/publications?mode=all&page=1&page_size=2&search=alpha")
+    assert response.status_code == 200
+    data = response.json()["data"]
+    assert int(data["total_count"]) == 2
+    assert data["has_next"] is False
+    assert len(data["publications"]) == 2
+    assert all("alpha" in str(item["title"]).lower() for item in data["publications"])
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_publications_supports_sort_by_pdf_status(
+    db_session: AsyncSession,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-pubs-pdf-sort@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "pdfSortScholar01",
+            "display_name": "PDF Sort Scholar",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+
+    resolved_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count, pdf_url)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 1, :pdf_url)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 1300):064x}",
+            "title_raw": "Resolved PDF",
+            "title_normalized": "resolved pdf",
+            "pdf_url": "https://example.org/resolved.pdf",
+        },
+    )
+    resolved_publication_id = int(resolved_result.scalar_one())
+    queued_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 1)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 1301):064x}",
+            "title_raw": "Queued PDF",
+            "title_normalized": "queued pdf",
+        },
+    )
+    queued_publication_id = int(queued_result.scalar_one())
+    failed_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 1)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 1302):064x}",
+            "title_raw": "Failed PDF",
+            "title_normalized": "failed pdf",
+        },
+    )
+    failed_publication_id = int(failed_result.scalar_one())
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
+            VALUES
+              (:scholar_profile_id, :resolved_publication_id, false, false),
+              (:scholar_profile_id, :queued_publication_id, false, false),
+              (:scholar_profile_id, :failed_publication_id, false, false)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "resolved_publication_id": resolved_publication_id,
+            "queued_publication_id": queued_publication_id,
+            "failed_publication_id": failed_publication_id,
+        },
+    )
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO publication_pdf_jobs (publication_id, status, attempt_count)
+            VALUES (:queued_publication_id, 'queued', 1),
+                   (:failed_publication_id, 'failed', 2)
+            """
+        ),
+        {
+            "queued_publication_id": queued_publication_id,
+            "failed_publication_id": failed_publication_id,
+        },
+    )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-pubs-pdf-sort@example.com", password="api-password")
+
+    response = client.get("/api/v1/publications?mode=all&sort_by=pdf_status&sort_dir=desc")
+    assert response.status_code == 200
+    publications = response.json()["data"]["publications"]
+    publication_ids = [int(item["publication_id"]) for item in publications]
+    assert publication_ids[0] == resolved_publication_id
+    assert publication_ids[-1] == failed_publication_id
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_publications_favorite_toggle_and_filter(db_session: AsyncSession) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-pubs-favorites@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "favoriteScholar01",
+            "display_name": "Favorite Scholar",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    publication_a_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 9)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 101):064x}",
+            "title_raw": "Favorite Target",
+            "title_normalized": "favorite target",
+        },
+    )
+    publication_a_id = int(publication_a_result.scalar_one())
+    publication_b_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 2)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 102):064x}",
+            "title_raw": "Not Favorite",
+            "title_normalized": "not favorite",
+        },
+    )
+    publication_b_id = int(publication_b_result.scalar_one())
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
+            VALUES
+              (:scholar_profile_id, :publication_a_id, false, false),
+              (:scholar_profile_id, :publication_b_id, false, false)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "publication_a_id": publication_a_id,
+            "publication_b_id": publication_b_id,
+        },
+    )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-pubs-favorites@example.com", password="api-password")
+    headers = api_csrf_headers(client)
+
+    set_response = client.post(
+        f"/api/v1/publications/{publication_a_id}/favorite",
+        json={"scholar_profile_id": scholar_profile_id, "is_favorite": True},
+        headers=headers,
+    )
+    assert set_response.status_code == 200
+    set_data = set_response.json()["data"]
+    assert set_data["publication"]["publication_id"] == publication_a_id
+    assert set_data["publication"]["is_favorite"] is True
+
+    favorite_only_response = client.get("/api/v1/publications?mode=all&favorite_only=true")
+    assert favorite_only_response.status_code == 200
+    favorite_only_data = favorite_only_response.json()["data"]
+    assert favorite_only_data["favorite_only"] is True
+    assert favorite_only_data["favorites_count"] == 1
+    assert favorite_only_data["total_count"] == 1
+    assert len(favorite_only_data["publications"]) == 1
+    assert int(favorite_only_data["publications"][0]["publication_id"]) == publication_a_id
+
+    clear_response = client.post(
+        f"/api/v1/publications/{publication_a_id}/favorite",
+        json={"scholar_profile_id": scholar_profile_id, "is_favorite": False},
+        headers=headers,
+    )
+    assert clear_response.status_code == 200
+    clear_data = clear_response.json()["data"]
+    assert clear_data["publication"]["publication_id"] == publication_a_id
+    assert clear_data["publication"]["is_favorite"] is False
+
+    favorite_only_after_clear_response = client.get("/api/v1/publications?mode=all&favorite_only=true")
+    assert favorite_only_after_clear_response.status_code == 200
+    favorite_only_after_clear_data = favorite_only_after_clear_response.json()["data"]
+    assert favorite_only_after_clear_data["favorites_count"] == 0
+    assert favorite_only_after_clear_data["total_count"] == 0
+    assert favorite_only_after_clear_data["publications"] == []
+
+    favorite_state_result = await db_session.execute(
+        text(
+            """
+            SELECT is_favorite
+            FROM scholar_publications
+            WHERE scholar_profile_id = :scholar_profile_id
+              AND publication_id = :publication_id
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "publication_id": publication_a_id,
+        },
+    )
+    assert bool(favorite_state_result.scalar_one()) is False
diff --git a/tests/integration/test_api_publications_advanced.py b/tests/integration/test_api_publications_advanced.py
new file mode 100644
index 0000000..ce39cab
--- /dev/null
+++ b/tests/integration/test_api_publications_advanced.py
@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.main import app
+from app.services.publications.types import PublicationListItem
+from tests.integration.helpers import (
+    api_csrf_headers,
+    insert_user,
+    login_user,
+)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_publications_list_schedules_background_enrichment(
+    db_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-pubs-bg@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "background111",
+            "display_name": "Background Scholar",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    publication_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 3)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 17):064x}",
+            "title_raw": "Background Target",
+            "title_normalized": "background target",
+        },
+    )
+    publication_id = int(publication_result.scalar_one())
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
+            VALUES (:scholar_profile_id, :publication_id, false)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "publication_id": publication_id,
+        },
+    )
+    await db_session.commit()
+
+    async def _fake_schedule(db_session, *, user_id: int, request_email: str | None, items, max_items: int):
+        assert db_session is not None
+        assert user_id > 0
+        assert request_email == "api-pubs-bg@example.com"
+        assert int(max_items) > 0
+        assert any(int(item.publication_id) == publication_id for item in items)
+        return 1
+
+    monkeypatch.setattr(
+        "app.services.publications.application.schedule_missing_pdf_enrichment_for_user",
+        _fake_schedule,
+    )
+
+    client = TestClient(app)
+    login_user(client, email="api-pubs-bg@example.com", password="api-password")
+
+    response = client.get("/api/v1/publications?mode=all")
+    assert response.status_code == 200
+    data = response.json()["data"]
+    assert len(data["publications"]) == 1
+    assert int(data["publications"][0]["publication_id"]) == publication_id
+    assert data["publications"][0]["pdf_url"] is None
+    assert data["publications"][0]["pdf_status"] in {"untracked", "queued", "running", "failed"}
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_publication_retry_pdf_queues_resolution_job(
+    db_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-pubs-retry@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "retryScholar01",
+            "display_name": "Retry Scholar",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    publication_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 7)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 9):064x}",
+            "title_raw": "Retry Target",
+            "title_normalized": "retry target",
+        },
+    )
+    publication_id = int(publication_result.scalar_one())
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
+            VALUES (:scholar_profile_id, :publication_id, false)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "publication_id": publication_id,
+        },
+    )
+    await db_session.commit()
+
+    async def _fake_retry_scheduler(db_session, *, user_id: int, request_email: str | None, item: PublicationListItem):
+        assert db_session is not None
+        assert user_id > 0
+        assert request_email == "api-pubs-retry@example.com"
+        assert int(item.publication_id) == publication_id
+        return True
+
+    monkeypatch.setattr(
+        "app.services.publications.application.schedule_retry_pdf_enrichment_for_row",
+        _fake_retry_scheduler,
+    )
+
+    async def _fake_hydrate(db_session, *, items: list[PublicationListItem]):
+        assert db_session is not None
+        assert len(items) == 1
+        item = items[0]
+        return [
+            PublicationListItem(
+                publication_id=item.publication_id,
+                scholar_profile_id=item.scholar_profile_id,
+                scholar_label=item.scholar_label,
+                title=item.title,
+                year=item.year,
+                citation_count=item.citation_count,
+                venue_text=item.venue_text,
+                pub_url=item.pub_url,
+                pdf_url=item.pdf_url,
+                is_read=item.is_read,
+                first_seen_at=item.first_seen_at,
+                is_new_in_latest_run=item.is_new_in_latest_run,
+                pdf_status="queued",
+                pdf_attempt_count=1,
+                pdf_failure_reason="no_pdf_found",
+                pdf_failure_detail="no_pdf_found",
+            )
+        ]
+
+    monkeypatch.setattr(
+        "app.services.publications.application.hydrate_pdf_enrichment_state",
+        _fake_hydrate,
+    )
+
+    client = TestClient(app)
+    login_user(client, email="api-pubs-retry@example.com", password="api-password")
+    headers = api_csrf_headers(client)
+
+    response = client.post(
+        f"/api/v1/publications/{publication_id}/retry-pdf",
+        json={"scholar_profile_id": scholar_profile_id},
+        headers=headers,
+    )
+    assert response.status_code == 200
+    payload = response.json()["data"]
+    assert payload["queued"] is True
+    assert payload["resolved_pdf"] is False
+    assert payload["publication"]["publication_id"] == publication_id
+    assert payload["publication"]["pdf_url"] is None
+    assert payload["publication"]["pdf_status"] == "queued"
+    assert payload["publication"]["pdf_attempt_count"] == 1
+    assert payload["publication"]["pdf_failure_reason"] == "no_pdf_found"
+
+    stored = await db_session.execute(
+        text("SELECT pdf_url FROM publications WHERE id = :publication_id"),
+        {"publication_id": publication_id},
+    )
+    stored_pdf_url = stored.scalar_one()
+    assert stored_pdf_url is None
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_publications_unread_and_latest_modes_can_diverge(
+    db_session: AsyncSession,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-pubs-mismatch@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "mismatchScholar01",
+            "display_name": "Mismatch Scholar",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+
+    older_run_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO crawl_runs (user_id, trigger_type, status, scholar_count, new_pub_count)
+            VALUES (:user_id, 'manual', 'success', 1, 1)
+            RETURNING id
+            """
+        ),
+        {"user_id": user_id},
+    )
+    older_run_id = int(older_run_result.scalar_one())
+
+    latest_run_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO crawl_runs (user_id, trigger_type, status, scholar_count, new_pub_count)
+            VALUES (:user_id, 'scheduled', 'success', 1, 0)
+            RETURNING id
+            """
+        ),
+        {"user_id": user_id},
+    )
+    latest_run_id = int(latest_run_result.scalar_one())
+    assert latest_run_id > older_run_id
+
+    publication_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 12)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 99):064x}",
+            "title_raw": "Unread But Not Latest",
+            "title_normalized": "unread but not latest",
+        },
+    )
+    publication_id = int(publication_result.scalar_one())
+
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (
+                scholar_profile_id,
+                publication_id,
+                is_read,
+                first_seen_run_id
+            )
+            VALUES (:scholar_profile_id, :publication_id, false, :first_seen_run_id)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "publication_id": publication_id,
+            "first_seen_run_id": older_run_id,
+        },
+    )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-pubs-mismatch@example.com", password="api-password")
+
+    unread_response = client.get("/api/v1/publications?mode=unread")
+    assert unread_response.status_code == 200
+    unread_data = unread_response.json()["data"]
+    assert unread_data["mode"] == "unread"
+    assert unread_data["unread_count"] == 1
+    assert unread_data["latest_count"] == 0
+    assert unread_data["new_count"] == 0
+    assert len(unread_data["publications"]) == 1
+    assert int(unread_data["publications"][0]["publication_id"]) == publication_id
+    assert unread_data["publications"][0]["is_new_in_latest_run"] is False
+
+    latest_response = client.get("/api/v1/publications?mode=latest")
+    assert latest_response.status_code == 200
+    latest_data = latest_response.json()["data"]
+    assert latest_data["mode"] == "latest"
+    assert latest_data["latest_count"] == 0
+    assert len(latest_data["publications"]) == 0
+
+    alias_response = client.get("/api/v1/publications?mode=new")
+    assert alias_response.status_code == 200
+    alias_data = alias_response.json()["data"]
+    assert alias_data["mode"] == "latest"
+    assert alias_data["latest_count"] == latest_data["latest_count"]
+    assert alias_data["publications"] == latest_data["publications"]
diff --git a/tests/integration/test_api_runs.py b/tests/integration/test_api_runs.py
new file mode 100644
index 0000000..e8f2f1a
--- /dev/null
+++ b/tests/integration/test_api_runs.py
@@ -0,0 +1,499 @@
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.runtime_deps import get_scholar_source
+from app.main import app
+from app.services.scholar.source import FetchResult
+from app.settings import settings
+from tests.integration.helpers import (
+    api_csrf_headers,
+    assert_safety_state_contract,
+    insert_user,
+    login_user,
+    regression_fixture,
+    wait_for_run_complete,
+)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_manual_run_skips_unchanged_initial_page_for_scholar(
+    db_session: AsyncSession,
+) -> None:
+    await insert_user(
+        db_session,
+        email="api-skip-unchanged@example.com",
+        password="api-password",
+    )
+
+    profile_html = """
+    <html>
+      <head>
+        <meta property="og:image" content="https://images.example.com/skip.png" />
+      </head>
+      <body>
+        <div id="gsc_prf_in">Skip Candidate</div>
+        <span id="gsc_a_nn">Articles 1-1</span>
+        <table>
+          <tbody id="gsc_a_b">
+            <tr class="gsc_a_tr">
+              <td class="gsc_a_t">
+                <a class="gsc_a_at" href="/citations?view_op=view_citation&citation_for_view=abcDEF123456:xyz123">Stable Paper</a>
+                <div class="gs_gray">A Author</div>
+                <div class="gs_gray">Stable Venue</div>
+              </td>
+              <td class="gsc_a_c"><a class="gsc_a_ac">5</a></td>
+              <td class="gsc_a_y"><span class="gsc_a_h">2024</span></td>
+            </tr>
+          </tbody>
+        </table>
+      </body>
+    </html>
+    """
+
+    class StubScholarSource:
+        async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
+            assert scholar_id == "abcDEF123456"
+            return FetchResult(
+                requested_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
+                status_code=200,
+                final_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
+                body=profile_html,
+                error=None,
+            )
+
+        async def fetch_profile_page_html(
+            self,
+            scholar_id: str,
+            *,
+            cstart: int,
+            pagesize: int,
+        ) -> FetchResult:
+            assert scholar_id == "abcDEF123456"
+            assert cstart == 0
+            assert pagesize == settings.ingestion_page_size
+            return FetchResult(
+                requested_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
+                status_code=200,
+                final_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
+                body=profile_html,
+                error=None,
+            )
+
+    app.dependency_overrides[get_scholar_source] = lambda: StubScholarSource()
+    try:
+        with TestClient(app) as client:
+            login_user(client, email="api-skip-unchanged@example.com", password="api-password")
+            headers = api_csrf_headers(client)
+
+            create_response = client.post(
+                "/api/v1/scholars",
+                json={"scholar_id": "abcDEF123456"},
+                headers=headers,
+            )
+            assert create_response.status_code == 201
+
+            first_run_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "skip-unchanged-run-001"},
+            )
+            assert first_run_response.status_code == 200
+            first_run_id = int(first_run_response.json()["data"]["run_id"])
+
+            first_detail_data = await wait_for_run_complete(client, first_run_id)
+            first_results = first_detail_data["scholar_results"]
+            assert len(first_results) == 1
+            assert first_results[0]["state_reason"] != "no_change_initial_page_signature"
+
+            second_run_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "skip-unchanged-run-002"},
+            )
+            assert second_run_response.status_code == 200
+            second_run_id = int(second_run_response.json()["data"]["run_id"])
+
+            second_detail_data = await wait_for_run_complete(client, second_run_id)
+            second_results = second_detail_data["scholar_results"]
+            assert len(second_results) == 1
+            assert second_results[0]["state_reason"] == "no_change_initial_page_signature"
+            assert second_results[0]["publication_count"] == 0
+            assert second_results[0]["outcome"] == "success"
+    finally:
+        app.dependency_overrides.pop(get_scholar_source, None)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_runs_manual_and_queue_actions(db_session: AsyncSession) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-runs@example.com",
+        password="api-password",
+    )
+
+    client = TestClient(app)
+    login_user(client, email="api-runs@example.com", password="api-password")
+    headers = api_csrf_headers(client)
+
+    run_response = client.post(
+        "/api/v1/runs/manual",
+        headers={**headers, "Idempotency-Key": "manual-run-0001"},
+    )
+    assert run_response.status_code == 200
+    run_payload = run_response.json()["data"]
+    assert "run_id" in run_payload
+    assert run_payload["status"] in {"running", "resolving", "success", "partial_failure", "failed"}
+    assert run_payload["reused_existing_run"] is False
+    assert run_payload["idempotency_key"] == "manual-run-0001"
+    assert_safety_state_contract(run_payload["safety_state"])
+    run_id = int(run_payload["run_id"])
+
+    stored_key = await db_session.execute(
+        text("SELECT idempotency_key FROM crawl_runs WHERE id = :run_id"),
+        {"run_id": run_id},
+    )
+    assert stored_key.scalar_one() == "manual-run-0001"
+
+    replay_response = client.post(
+        "/api/v1/runs/manual",
+        headers={**headers, "Idempotency-Key": "manual-run-0001"},
+    )
+    assert replay_response.status_code in {200, 409}
+    if replay_response.status_code == 200:
+        replay_payload = replay_response.json()["data"]
+        assert replay_payload["run_id"] == run_payload["run_id"]
+        assert replay_payload["reused_existing_run"] is True
+        assert_safety_state_contract(replay_payload["safety_state"])
+    else:
+        replay_error = replay_response.json()["error"]
+        assert replay_error["code"] == "run_in_progress"
+
+    runs_response = client.get("/api/v1/runs")
+    assert runs_response.status_code == 200
+    assert len(runs_response.json()["data"]["runs"]) >= 1
+    assert_safety_state_contract(runs_response.json()["data"]["safety_state"])
+
+    run_detail_response = client.get(f"/api/v1/runs/{run_id}")
+    assert run_detail_response.status_code == 200
+    detail_payload = run_detail_response.json()["data"]
+    assert "summary" in detail_payload
+    assert isinstance(detail_payload["scholar_results"], list)
+    assert_safety_state_contract(detail_payload["safety_state"])
+
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "abcDEF123456",
+            "display_name": "Queue Scholar",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    queue_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO ingestion_queue_items (
+                user_id,
+                scholar_profile_id,
+                resume_cstart,
+                reason,
+                status,
+                attempt_count,
+                next_attempt_dt,
+                dropped_reason,
+                dropped_at
+            )
+            VALUES (
+                :user_id,
+                :scholar_profile_id,
+                7,
+                'dropped',
+                'dropped',
+                2,
+                NOW(),
+                'manual_drop',
+                NOW()
+            )
+            RETURNING id
+            """
+        ),
+        {"user_id": user_id, "scholar_profile_id": scholar_profile_id},
+    )
+    queue_item_id = int(queue_result.scalar_one())
+    await db_session.commit()
+
+    queue_list_response = client.get("/api/v1/runs/queue/items")
+    assert queue_list_response.status_code == 200
+    assert any(int(item["id"]) == queue_item_id for item in queue_list_response.json()["data"]["queue_items"])
+
+    retry_response = client.post(f"/api/v1/runs/queue/{queue_item_id}/retry", headers=headers)
+    assert retry_response.status_code == 200
+    assert retry_response.json()["data"]["status"] == "queued"
+
+    retry_again_response = client.post(
+        f"/api/v1/runs/queue/{queue_item_id}/retry",
+        headers=headers,
+    )
+    assert retry_again_response.status_code == 409
+    assert retry_again_response.json()["error"]["code"] == "queue_item_already_queued"
+
+    drop_response = client.post(f"/api/v1/runs/queue/{queue_item_id}/drop", headers=headers)
+    assert drop_response.status_code == 200
+    assert drop_response.json()["data"]["status"] == "dropped"
+
+    clear_response = client.request(
+        "DELETE",
+        f"/api/v1/runs/queue/{queue_item_id}",
+        headers=headers,
+    )
+    assert clear_response.status_code == 200
+    assert clear_response.json()["data"]["status"] == "cleared"
+    assert clear_response.json()["data"]["message"] == "Queue item cleared."
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_manual_run_can_be_disabled_by_policy(db_session: AsyncSession) -> None:
+    await insert_user(
+        db_session,
+        email="api-runs-policy@example.com",
+        password="api-password",
+    )
+    client = TestClient(app)
+    login_user(client, email="api-runs-policy@example.com", password="api-password")
+    headers = api_csrf_headers(client)
+
+    previous_manual_allowed = settings.ingestion_manual_run_allowed
+    object.__setattr__(settings, "ingestion_manual_run_allowed", False)
+    try:
+        response = client.post("/api/v1/runs/manual", headers=headers)
+        assert response.status_code == 403
+        payload = response.json()
+        assert payload["error"]["code"] == "manual_runs_disabled"
+        assert payload["error"]["details"]["policy"]["manual_run_allowed"] is False
+        assert payload["error"]["details"]["safety_state"]["cooldown_active"] is False
+    finally:
+        object.__setattr__(settings, "ingestion_manual_run_allowed", previous_manual_allowed)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_manual_run_enforces_scrape_safety_cooldown(db_session: AsyncSession) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-runs-safety@example.com",
+        password="api-password",
+    )
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "A1B2C3D4E5F6",
+            "display_name": "Safety Probe",
+        },
+    )
+    await db_session.commit()
+
+    blocked_fixture = regression_fixture("profile_AAAAAAAAAAAA.html")
+
+    class BlockedScholarSource:
+        async def fetch_profile_page_html(
+            self,
+            scholar_id: str,
+            *,
+            cstart: int,
+            pagesize: int,
+        ) -> FetchResult:
+            _ = (scholar_id, cstart, pagesize)
+            return FetchResult(
+                requested_url="https://scholar.google.com/citations?hl=en&user=A1B2C3D4E5F6",
+                status_code=200,
+                final_url=(
+                    "https://accounts.google.com/v3/signin/identifier"
+                    "?continue=https%3A%2F%2Fscholar.google.com%2Fcitations"
+                ),
+                body=blocked_fixture,
+                error=None,
+            )
+
+        async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
+            _ = scholar_id
+            return await self.fetch_profile_page_html(
+                "A1B2C3D4E5F6",
+                cstart=0,
+                pagesize=settings.ingestion_page_size,
+            )
+
+    app.dependency_overrides[get_scholar_source] = lambda: BlockedScholarSource()
+
+    previous_blocked_cooldown_seconds = settings.ingestion_safety_cooldown_blocked_seconds
+    object.__setattr__(settings, "ingestion_safety_cooldown_blocked_seconds", 600)
+
+    try:
+        with TestClient(app) as client:
+            login_user(client, email="api-runs-safety@example.com", password="api-password")
+            headers = api_csrf_headers(client)
+
+            preflight_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "safety-cooldown-run-1"},
+            )
+            assert preflight_response.status_code == 429
+            preflight_payload = preflight_response.json()
+            assert preflight_payload["error"]["code"] == "scrape_cooldown_active"
+            preflight_state = preflight_payload["error"]["details"]["safety_state"]
+            assert_safety_state_contract(preflight_state)
+            assert preflight_state["cooldown_active"] is True
+
+            settings_response = client.get("/api/v1/settings")
+            assert settings_response.status_code == 200
+            safety_state = settings_response.json()["data"]["safety_state"]
+            assert_safety_state_contract(safety_state)
+            assert safety_state["cooldown_active"] is True
+            assert safety_state["cooldown_reason"] == "blocked_failure_threshold_exceeded"
+            assert int(safety_state["cooldown_remaining_seconds"]) > 0
+            assert int(safety_state["counters"]["cooldown_entry_count"]) >= 1
+
+            blocked_start_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "safety-cooldown-run-2"},
+            )
+            assert blocked_start_response.status_code == 429
+            blocked_payload = blocked_start_response.json()
+            assert blocked_payload["error"]["code"] == "scrape_cooldown_active"
+            blocked_state = blocked_payload["error"]["details"]["safety_state"]
+            assert_safety_state_contract(blocked_state)
+            assert blocked_state["cooldown_active"] is True
+            assert blocked_state["cooldown_reason"] == "blocked_failure_threshold_exceeded"
+            assert int(blocked_state["counters"]["blocked_start_count"]) >= 1
+
+            runs_response = client.get("/api/v1/runs")
+            assert runs_response.status_code == 200
+            assert_safety_state_contract(runs_response.json()["data"]["safety_state"])
+            assert runs_response.json()["data"]["safety_state"]["cooldown_active"] is True
+    finally:
+        object.__setattr__(settings, "ingestion_safety_cooldown_blocked_seconds", previous_blocked_cooldown_seconds)
+        app.dependency_overrides.pop(get_scholar_source, None)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_manual_run_enforces_network_failure_safety_cooldown(
+    db_session: AsyncSession,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-runs-safety-network@example.com",
+        password="api-password",
+    )
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "NNN111NNN111",
+            "display_name": "Network Safety Probe",
+        },
+    )
+    await db_session.commit()
+
+    class NetworkFailureScholarSource:
+        async def fetch_profile_page_html(
+            self,
+            scholar_id: str,
+            *,
+            cstart: int,
+            pagesize: int,
+        ) -> FetchResult:
+            _ = (scholar_id, cstart, pagesize)
+            return FetchResult(
+                requested_url="https://scholar.google.com/citations?hl=en&user=NNN111NNN111",
+                status_code=None,
+                final_url=None,
+                body="",
+                error="timed out",
+            )
+
+        async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
+            _ = scholar_id
+            return await self.fetch_profile_page_html(
+                "NNN111NNN111",
+                cstart=0,
+                pagesize=settings.ingestion_page_size,
+            )
+
+    app.dependency_overrides[get_scholar_source] = lambda: NetworkFailureScholarSource()
+
+    previous_network_threshold = settings.ingestion_alert_network_failure_threshold
+    previous_network_cooldown_seconds = settings.ingestion_safety_cooldown_network_seconds
+    previous_network_retries = settings.ingestion_network_error_retries
+    previous_retry_backoff = settings.ingestion_retry_backoff_seconds
+    object.__setattr__(settings, "ingestion_alert_network_failure_threshold", 1)
+    object.__setattr__(settings, "ingestion_safety_cooldown_network_seconds", 600)
+    object.__setattr__(settings, "ingestion_network_error_retries", 0)
+    object.__setattr__(settings, "ingestion_retry_backoff_seconds", 0.0)
+
+    try:
+        with TestClient(app) as client:
+            login_user(client, email="api-runs-safety-network@example.com", password="api-password")
+            headers = api_csrf_headers(client)
+
+            first_run_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "safety-network-cooldown-run-1"},
+            )
+            assert first_run_response.status_code == 200
+            first_run_id = int(first_run_response.json()["data"]["run_id"])
+            await wait_for_run_complete(client, first_run_id)
+
+            settings_response = client.get("/api/v1/settings")
+            assert settings_response.status_code == 200
+            safety_state = settings_response.json()["data"]["safety_state"]
+            assert_safety_state_contract(safety_state)
+            assert safety_state["cooldown_active"] is True
+            assert safety_state["cooldown_reason"] == "network_failure_threshold_exceeded"
+            assert int(safety_state["cooldown_remaining_seconds"]) > 0
+            assert int(safety_state["counters"]["last_network_failure_count"]) >= 1
+
+            blocked_start_response = client.post(
+                "/api/v1/runs/manual",
+                headers={**headers, "Idempotency-Key": "safety-network-cooldown-run-2"},
+            )
+            assert blocked_start_response.status_code == 429
+            blocked_payload = blocked_start_response.json()
+            assert blocked_payload["error"]["code"] == "scrape_cooldown_active"
+            blocked_state = blocked_payload["error"]["details"]["safety_state"]
+            assert_safety_state_contract(blocked_state)
+            assert blocked_state["cooldown_active"] is True
+            assert blocked_state["cooldown_reason"] == "network_failure_threshold_exceeded"
+            assert int(blocked_state["counters"]["blocked_start_count"]) >= 1
+    finally:
+        object.__setattr__(settings, "ingestion_alert_network_failure_threshold", previous_network_threshold)
+        object.__setattr__(settings, "ingestion_safety_cooldown_network_seconds", previous_network_cooldown_seconds)
+        object.__setattr__(settings, "ingestion_network_error_retries", previous_network_retries)
+        object.__setattr__(settings, "ingestion_retry_backoff_seconds", previous_retry_backoff)
+        app.dependency_overrides.pop(get_scholar_source, None)
diff --git a/tests/integration/test_api_scholars.py b/tests/integration/test_api_scholars.py
new file mode 100644
index 0000000..7d912fd
--- /dev/null
+++ b/tests/integration/test_api_scholars.py
@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.runtime_deps import get_scholar_source
+from app.main import app
+from app.services.scholar.source import FetchResult
+from app.settings import settings
+from tests.integration.helpers import (
+    api_csrf_headers,
+    insert_user,
+    login_user,
+)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_scholars_crud_flow(db_session: AsyncSession) -> None:
+    await insert_user(
+        db_session,
+        email="api-scholars@example.com",
+        password="api-password",
+    )
+
+    client = TestClient(app)
+    login_user(client, email="api-scholars@example.com", password="api-password")
+    headers = api_csrf_headers(client)
+
+    missing_csrf = client.post(
+        "/api/v1/scholars",
+        json={"scholar_id": "abcDEF123456"},
+    )
+    assert missing_csrf.status_code == 403
+    assert missing_csrf.json()["error"]["code"] == "csrf_invalid"
+
+    create_response = client.post(
+        "/api/v1/scholars",
+        json={"scholar_id": "abcDEF123456"},
+        headers=headers,
+    )
+    assert create_response.status_code == 201
+    created = create_response.json()["data"]
+    assert created["scholar_id"] == "abcDEF123456"
+    scholar_profile_id = int(created["id"])
+
+    list_response = client.get("/api/v1/scholars")
+    assert list_response.status_code == 200
+    scholars = list_response.json()["data"]["scholars"]
+    assert any(int(item["id"]) == scholar_profile_id for item in scholars)
+
+    toggle_response = client.patch(
+        f"/api/v1/scholars/{scholar_profile_id}/toggle",
+        headers=headers,
+    )
+    assert toggle_response.status_code == 200
+    assert toggle_response.json()["data"]["is_enabled"] is False
+
+    delete_response = client.delete(
+        f"/api/v1/scholars/{scholar_profile_id}",
+        headers=headers,
+    )
+    assert delete_response.status_code == 200
+    assert delete_response.json()["data"]["message"] == "Scholar deleted."
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_scholars_search_and_profile_image_management(
+    db_session: AsyncSession,
+    tmp_path: Path,
+) -> None:
+    await insert_user(
+        db_session,
+        email="api-scholar-images@example.com",
+        password="api-password",
+    )
+
+    class StubScholarSource:
+        async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
+            assert scholar_id == "abcDEF123456"
+            return FetchResult(
+                requested_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
+                status_code=200,
+                final_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
+                body=(
+                    "<html><head>"
+                    '<meta property="og:image" content="https://images.example.com/ada.png" />'
+                    "</head><body>"
+                    '<div id="gsc_prf_in">Ada Lovelace</div>'
+                    "</body></html>"
+                ),
+                error=None,
+            )
+
+        async def fetch_author_search_html(self, query: str, *, start: int) -> FetchResult:
+            assert query == "Ada Lovelace"
+            assert start == 0
+            return FetchResult(
+                requested_url="https://scholar.google.com/citations?hl=en&view_op=search_authors&mauthors=ada",
+                status_code=200,
+                final_url="https://scholar.google.com/citations?hl=en&view_op=search_authors&mauthors=ada",
+                body=(
+                    '<div class="gsc_1usr">'
+                    '<img src="/citations/images/avatar_scholar_256.png" />'
+                    '<a class="gs_ai_name" href="/citations?hl=en&user=abcDEF123456">Ada Lovelace</a>'
+                    '<div class="gs_ai_aff">Analytical Engine</div>'
+                    '<div class="gs_ai_eml">Verified email at computing.example</div>'
+                    '<div class="gs_ai_cby">Cited by 42</div>'
+                    '<a class="gs_ai_one_int">Mathematics</a>'
+                    "</div>"
+                ),
+                error=None,
+            )
+
+    previous_upload_dir = settings.scholar_image_upload_dir
+    previous_upload_max_bytes = settings.scholar_image_upload_max_bytes
+    previous_queue_enabled = settings.ingestion_continuation_queue_enabled
+    app.dependency_overrides[get_scholar_source] = lambda: StubScholarSource()
+    object.__setattr__(settings, "scholar_image_upload_dir", str(tmp_path / "scholar_images"))
+    object.__setattr__(settings, "scholar_image_upload_max_bytes", 1_000_000)
+    object.__setattr__(settings, "ingestion_continuation_queue_enabled", False)
+
+    try:
+        client = TestClient(app)
+        login_user(client, email="api-scholar-images@example.com", password="api-password")
+        headers = api_csrf_headers(client)
+
+        search_response = client.get("/api/v1/scholars/search", params={"query": "Ada Lovelace", "limit": 5})
+        assert search_response.status_code == 200
+        search_payload = search_response.json()["data"]
+        assert search_payload["state"] == "ok"
+        assert len(search_payload["candidates"]) == 1
+        candidate = search_payload["candidates"][0]
+        assert candidate["scholar_id"] == "abcDEF123456"
+        assert candidate["profile_image_url"] == "https://scholar.google.com/citations/images/avatar_scholar_256.png"
+
+        create_response = client.post(
+            "/api/v1/scholars",
+            json={
+                "scholar_id": candidate["scholar_id"],
+            },
+            headers=headers,
+        )
+        assert create_response.status_code == 201
+        created = create_response.json()["data"]
+        scholar_profile_id = int(created["id"])
+        assert created["profile_image_source"] == "scraped"
+        assert created["profile_image_url"] == "https://images.example.com/ada.png"
+
+        set_url_response = client.put(
+            f"/api/v1/scholars/{scholar_profile_id}/image/url",
+            json={"image_url": "https://cdn.example.com/custom-avatar.png"},
+            headers=headers,
+        )
+        assert set_url_response.status_code == 200
+        set_url_data = set_url_response.json()["data"]
+        assert set_url_data["profile_image_source"] == "override"
+        assert set_url_data["profile_image_url"] == "https://cdn.example.com/custom-avatar.png"
+
+        uploaded_bytes = b"\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01"
+        upload_response = client.post(
+            f"/api/v1/scholars/{scholar_profile_id}/image/upload",
+            files={"image": ("avatar.png", uploaded_bytes, "image/png")},
+            headers=headers,
+        )
+        assert upload_response.status_code == 200
+        upload_data = upload_response.json()["data"]
+        assert upload_data["profile_image_source"] == "upload"
+        assert upload_data["profile_image_url"] == f"/scholar-images/{scholar_profile_id}/upload"
+
+        uploaded_image_response = client.get(f"/scholar-images/{scholar_profile_id}/upload")
+        assert uploaded_image_response.status_code == 200
+        assert uploaded_image_response.headers["content-type"].startswith("image/png")
+        assert uploaded_image_response.content == uploaded_bytes
+
+        clear_response = client.delete(
+            f"/api/v1/scholars/{scholar_profile_id}/image",
+            headers=headers,
+        )
+        assert clear_response.status_code == 200
+        clear_data = clear_response.json()["data"]
+        assert clear_data["profile_image_source"] == "scraped"
+        assert clear_data["profile_image_url"] == "https://images.example.com/ada.png"
+    finally:
+        app.dependency_overrides.pop(get_scholar_source, None)
+        object.__setattr__(settings, "scholar_image_upload_dir", previous_upload_dir)
+        object.__setattr__(
+            settings,
+            "scholar_image_upload_max_bytes",
+            previous_upload_max_bytes,
+        )
+        object.__setattr__(settings, "ingestion_continuation_queue_enabled", previous_queue_enabled)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_scholar_import_export_round_trip(
+    db_session: AsyncSession,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-import-export@example.com",
+        password="api-password",
+    )
+    scholar_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
+            VALUES (:user_id, :scholar_id, :display_name, true)
+            RETURNING id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "abcDEF123456",
+            "display_name": "Existing Scholar",
+        },
+    )
+    scholar_profile_id = int(scholar_result.scalar_one())
+    publication_result = await db_session.execute(
+        text(
+            """
+            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
+            VALUES (:fingerprint, :title_raw, :title_normalized, 1)
+            RETURNING id
+            """
+        ),
+        {
+            "fingerprint": f"{(user_id + 500):064x}",
+            "title_raw": "Existing Publication",
+            "title_normalized": "existingpublication",
+        },
+    )
+    publication_id = int(publication_result.scalar_one())
+    await db_session.execute(
+        text(
+            """
+            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
+            VALUES (:scholar_profile_id, :publication_id, false)
+            """
+        ),
+        {
+            "scholar_profile_id": scholar_profile_id,
+            "publication_id": publication_id,
+        },
+    )
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-import-export@example.com", password="api-password")
+    headers = api_csrf_headers(client)
+
+    export_response = client.get("/api/v1/scholars/export")
+    assert export_response.status_code == 200
+    export_payload = export_response.json()["data"]
+    assert export_payload["schema_version"] == 1
+    assert len(export_payload["scholars"]) == 1
+    assert len(export_payload["publications"]) == 1
+
+    import_response = client.post(
+        "/api/v1/scholars/import",
+        json={
+            "schema_version": 1,
+            "scholars": [
+                {
+                    "scholar_id": "abcDEF123456",
+                    "display_name": "Updated Scholar",
+                    "is_enabled": False,
+                    "profile_image_override_url": "https://cdn.example.com/avatar.png",
+                },
+                {
+                    "scholar_id": "zzzYYY111222",
+                    "display_name": "Imported Scholar",
+                    "is_enabled": True,
+                    "profile_image_override_url": None,
+                },
+            ],
+            "publications": [
+                {
+                    "scholar_id": "abcDEF123456",
+                    "title": "Existing Publication",
+                    "year": 2024,
+                    "citation_count": 8,
+                    "author_text": "A. Author",
+                    "venue_text": "Test Venue",
+                    "pub_url": "https://example.org/existing",
+                    "pdf_url": "https://example.org/existing.pdf",
+                    "is_read": True,
+                },
+                {
+                    "scholar_id": "zzzYYY111222",
+                    "title": "Imported Publication",
+                    "year": 2025,
+                    "citation_count": 2,
+                    "author_text": "B. Author",
+                    "venue_text": "Another Venue",
+                    "pub_url": "https://example.org/imported",
+                    "pdf_url": "https://example.org/imported.pdf",
+                    "is_read": False,
+                },
+            ],
+        },
+        headers=headers,
+    )
+    assert import_response.status_code == 200
+    import_data = import_response.json()["data"]
+    assert int(import_data["scholars_created"]) == 1
+    assert int(import_data["scholars_updated"]) >= 1
+    assert int(import_data["publications_created"]) == 1
+    assert int(import_data["links_created"]) == 1
+
+    updated_scholar_result = await db_session.execute(
+        text(
+            """
+            SELECT display_name, is_enabled, profile_image_override_url
+            FROM scholar_profiles
+            WHERE user_id = :user_id AND scholar_id = :scholar_id
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "abcDEF123456",
+        },
+    )
+    updated_scholar = updated_scholar_result.one()
+    assert updated_scholar[0] == "Updated Scholar"
+    assert updated_scholar[1] is False
+    assert updated_scholar[2] == "https://cdn.example.com/avatar.png"
+
+    imported_pub_result = await db_session.execute(
+        text(
+            """
+            SELECT p.title_raw, p.pdf_url
+            FROM publications p
+            WHERE p.title_raw = :title
+            """
+        ),
+        {"title": "Imported Publication"},
+    )
+    imported_pub = imported_pub_result.one()
+    assert imported_pub[0] == "Imported Publication"
+    assert imported_pub[1] == "https://example.org/imported.pdf"
+
+    updated_link_result = await db_session.execute(
+        text(
+            """
+            SELECT sp.is_read
+            FROM scholar_publications sp
+            JOIN scholar_profiles s ON s.id = sp.scholar_profile_id
+            JOIN publications p ON p.id = sp.publication_id
+            WHERE s.user_id = :user_id
+              AND s.scholar_id = :scholar_id
+              AND p.title_raw = :title
+            """
+        ),
+        {
+            "user_id": user_id,
+            "scholar_id": "abcDEF123456",
+            "title": "Existing Publication",
+        },
+    )
+    assert bool(updated_link_result.scalar_one()) is True
diff --git a/tests/integration/test_api_settings.py b/tests/integration/test_api_settings.py
new file mode 100644
index 0000000..aa9e2c1
--- /dev/null
+++ b/tests/integration/test_api_settings.py
@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.main import app
+from app.services.settings import application as user_settings_service
+from app.settings import settings
+from tests.integration.helpers import (
+    api_csrf_headers,
+    assert_safety_state_contract,
+    insert_user,
+    login_user,
+)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_settings_get_and_update(db_session: AsyncSession) -> None:
+    await insert_user(
+        db_session,
+        email="api-settings@example.com",
+        password="api-password",
+    )
+
+    client = TestClient(app)
+    login_user(client, email="api-settings@example.com", password="api-password")
+    headers = api_csrf_headers(client)
+
+    get_response = client.get("/api/v1/settings")
+    assert get_response.status_code == 200
+    settings_payload = get_response.json()["data"]
+    assert "request_delay_seconds" in settings_payload
+    assert "nav_visible_pages" in settings_payload
+    assert settings_payload["policy"]["min_run_interval_minutes"] == user_settings_service.resolve_run_interval_minimum(
+        settings.ingestion_min_run_interval_minutes
+    )
+    assert settings_payload["policy"][
+        "min_request_delay_seconds"
+    ] == user_settings_service.resolve_request_delay_minimum(settings.ingestion_min_request_delay_seconds)
+    assert settings_payload["policy"]["automation_allowed"] is settings.ingestion_automation_allowed
+    assert settings_payload["policy"]["manual_run_allowed"] is settings.ingestion_manual_run_allowed
+    assert settings_payload["policy"]["blocked_failure_threshold"] == max(
+        1,
+        int(settings.ingestion_alert_blocked_failure_threshold),
+    )
+    assert settings_payload["policy"]["network_failure_threshold"] == max(
+        1,
+        int(settings.ingestion_alert_network_failure_threshold),
+    )
+    assert settings_payload["policy"]["cooldown_blocked_seconds"] == max(
+        60,
+        int(settings.ingestion_safety_cooldown_blocked_seconds),
+    )
+    assert settings_payload["policy"]["cooldown_network_seconds"] == max(
+        60,
+        int(settings.ingestion_safety_cooldown_network_seconds),
+    )
+    assert_safety_state_contract(settings_payload["safety_state"])
+    assert settings_payload["safety_state"]["cooldown_active"] is False
+
+    policy = settings_payload["policy"]
+    run_interval_minutes = max(45, int(policy["min_run_interval_minutes"]))
+    request_delay_seconds = max(6, int(policy["min_request_delay_seconds"]))
+
+    update_response = client.put(
+        "/api/v1/settings",
+        json={
+            "auto_run_enabled": True,
+            "run_interval_minutes": run_interval_minutes,
+            "request_delay_seconds": request_delay_seconds,
+            "nav_visible_pages": ["dashboard", "scholars", "publications", "settings", "runs"],
+        },
+        headers=headers,
+    )
+    assert update_response.status_code == 200
+    updated = update_response.json()["data"]
+    assert updated["auto_run_enabled"] is True
+    assert updated["run_interval_minutes"] == run_interval_minutes
+    assert updated["request_delay_seconds"] == request_delay_seconds
+    assert updated["nav_visible_pages"] == [
+        "dashboard",
+        "scholars",
+        "publications",
+        "settings",
+        "runs",
+    ]
+    assert "policy" in updated
+    assert_safety_state_contract(updated["safety_state"])
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_settings_enforce_env_minimums(db_session: AsyncSession) -> None:
+    await insert_user(
+        db_session,
+        email="api-settings-policy@example.com",
+        password="api-password",
+    )
+
+    client = TestClient(app)
+    login_user(client, email="api-settings-policy@example.com", password="api-password")
+    headers = api_csrf_headers(client)
+
+    previous_min_interval = settings.ingestion_min_run_interval_minutes
+    previous_min_delay = settings.ingestion_min_request_delay_seconds
+    object.__setattr__(settings, "ingestion_min_run_interval_minutes", 30)
+    object.__setattr__(settings, "ingestion_min_request_delay_seconds", 8)
+    try:
+        interval_response = client.put(
+            "/api/v1/settings",
+            json={
+                "auto_run_enabled": True,
+                "run_interval_minutes": 29,
+                "request_delay_seconds": 9,
+                "nav_visible_pages": ["dashboard", "scholars", "settings"],
+            },
+            headers=headers,
+        )
+        assert interval_response.status_code == 400
+        assert interval_response.json()["error"]["code"] == "invalid_settings"
+        assert interval_response.json()["error"]["message"] == "Check interval must be at least 30 minutes."
+
+        delay_response = client.put(
+            "/api/v1/settings",
+            json={
+                "auto_run_enabled": True,
+                "run_interval_minutes": 30,
+                "request_delay_seconds": 7,
+                "nav_visible_pages": ["dashboard", "scholars", "settings"],
+            },
+            headers=headers,
+        )
+        assert delay_response.status_code == 400
+        assert delay_response.json()["error"]["code"] == "invalid_settings"
+        assert delay_response.json()["error"]["message"] == "Request delay must be at least 8 seconds."
+    finally:
+        object.__setattr__(settings, "ingestion_min_run_interval_minutes", previous_min_interval)
+        object.__setattr__(settings, "ingestion_min_request_delay_seconds", previous_min_delay)
+
+
+@pytest.mark.integration
+@pytest.mark.db
+@pytest.mark.asyncio
+async def test_api_settings_clears_expired_scrape_safety_cooldown(
+    db_session: AsyncSession,
+) -> None:
+    user_id = await insert_user(
+        db_session,
+        email="api-settings-safety-expired@example.com",
+        password="api-password",
+    )
+    user_settings = await user_settings_service.get_or_create_settings(
+        db_session,
+        user_id=user_id,
+    )
+    user_settings.scrape_safety_state = {"blocked_start_count": 2}
+    user_settings.scrape_cooldown_reason = "blocked_failure_threshold_exceeded"
+    user_settings.scrape_cooldown_until = datetime.now(UTC) - timedelta(seconds=15)
+    await db_session.commit()
+
+    client = TestClient(app)
+    login_user(client, email="api-settings-safety-expired@example.com", password="api-password")
+
+    settings_response = client.get("/api/v1/settings")
+    assert settings_response.status_code == 200
+    settings_safety_state = settings_response.json()["data"]["safety_state"]
+    assert_safety_state_contract(settings_safety_state)
+    assert settings_safety_state["cooldown_active"] is False
+    assert settings_safety_state["cooldown_reason"] is None
+    assert int(settings_safety_state["counters"]["blocked_start_count"]) == 2
+
+    runs_response = client.get("/api/v1/runs")
+    assert runs_response.status_code == 200
+    runs_safety_state = runs_response.json()["data"]["safety_state"]
+    assert_safety_state_contract(runs_safety_state)
+    assert runs_safety_state["cooldown_active"] is False
+    assert runs_safety_state["cooldown_reason"] is None
diff --git a/tests/integration/test_api_v1.py b/tests/integration/test_api_v1.py
deleted file mode 100644
index 06551ca..0000000
--- a/tests/integration/test_api_v1.py
+++ /dev/null
@@ -1,2721 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from datetime import UTC, datetime, timedelta
-from pathlib import Path
-
-import pytest
-from fastapi.testclient import TestClient
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.api.runtime_deps import get_scholar_source
-from app.main import app
-from app.services.publications.types import PublicationListItem
-from app.services.scholar.source import FetchResult
-from app.services.settings import application as user_settings_service
-from app.settings import settings
-from tests.integration.helpers import insert_user, login_user
-
-REGRESSION_FIXTURE_DIR = Path("tests/fixtures/scholar/regression")
-SAFETY_STATE_KEYS = {
-    "cooldown_active",
-    "cooldown_reason",
-    "cooldown_reason_label",
-    "cooldown_until",
-    "cooldown_remaining_seconds",
-    "recommended_action",
-    "counters",
-}
-SAFETY_COUNTER_KEYS = {
-    "consecutive_blocked_runs",
-    "consecutive_network_runs",
-    "cooldown_entry_count",
-    "blocked_start_count",
-    "last_blocked_failure_count",
-    "last_network_failure_count",
-    "last_evaluated_run_id",
-}
-
-
-def _api_bootstrap_csrf_headers(client: TestClient) -> dict[str, str]:
-    bootstrap_response = client.get("/api/v1/auth/csrf")
-    assert bootstrap_response.status_code == 200
-    payload = bootstrap_response.json()["data"]
-    token = payload["csrf_token"]
-    assert isinstance(token, str) and token
-    return {"X-CSRF-Token": token}
-
-
-def _api_csrf_headers(client: TestClient) -> dict[str, str]:
-    me_response = client.get("/api/v1/auth/me")
-    assert me_response.status_code == 200
-    body = me_response.json()
-    token = body["data"]["csrf_token"]
-    assert isinstance(token, str) and token
-    return {"X-CSRF-Token": token}
-
-
-def _regression_fixture(name: str) -> str:
-    return (REGRESSION_FIXTURE_DIR / name).read_text(encoding="utf-8")
-
-
-def _assert_safety_state_contract(payload: dict[str, object]) -> None:
-    assert set(payload.keys()) == SAFETY_STATE_KEYS
-    counters = payload["counters"]
-    assert isinstance(counters, dict)
-    assert set(counters.keys()) == SAFETY_COUNTER_KEYS
-
-
-_ACTIVE_RUN_STATUSES = {"running", "resolving"}
-
-
-async def _wait_for_run_complete(
-    client: TestClient,
-    run_id: int,
-    *,
-    max_retries: int = 300,
-    poll_interval: float = 0.2,
-) -> dict:
-    """Poll GET /api/v1/runs/{run_id} until the run is in a terminal state.
-
-    Returns the final run detail data dict.
-    """
-    for _ in range(max_retries):
-        await asyncio.sleep(poll_interval)
-        r = client.get(f"/api/v1/runs/{run_id}")
-        assert r.status_code == 200
-        data = r.json()["data"]
-        if data["run"]["status"] not in _ACTIVE_RUN_STATUSES:
-            return data
-    r = client.get(f"/api/v1/runs/{run_id}")
-    return r.json()["data"]
-
-
-async def _seed_publication_link_for_user(
-    db_session: AsyncSession,
-    *,
-    user_id: int,
-    scholar_id: str,
-    title: str,
-    fingerprint: str,
-) -> tuple[int, int]:
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {"user_id": user_id, "scholar_id": scholar_id, "display_name": scholar_id},
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-    publication_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 4)
-            RETURNING id
-            """
-        ),
-        {"fingerprint": fingerprint, "title_raw": title, "title_normalized": title.lower()},
-    )
-    publication_id = int(publication_result.scalar_one())
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
-            VALUES (:scholar_profile_id, :publication_id, false)
-            """
-        ),
-        {"scholar_profile_id": scholar_profile_id, "publication_id": publication_id},
-    )
-    await db_session.commit()
-    return scholar_profile_id, publication_id
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_me_requires_authentication() -> None:
-    client = TestClient(app)
-
-    response = client.get("/api/v1/auth/me")
-
-    assert response.status_code == 401
-    payload = response.json()
-    assert payload["error"]["code"] == "auth_required"
-    assert payload["error"]["message"] == "Authentication required."
-    assert "request_id" in payload["meta"]
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_csrf_bootstrap_returns_token_for_anonymous_and_authenticated(
-    db_session: AsyncSession,
-) -> None:
-    await insert_user(
-        db_session,
-        email="api-bootstrap@example.com",
-        password="api-password",
-    )
-    client = TestClient(app)
-
-    anonymous_response = client.get("/api/v1/auth/csrf")
-    assert anonymous_response.status_code == 200
-    anonymous_payload = anonymous_response.json()["data"]
-    assert isinstance(anonymous_payload["csrf_token"], str)
-    assert anonymous_payload["authenticated"] is False
-
-    login_user(client, email="api-bootstrap@example.com", password="api-password")
-    authenticated_response = client.get("/api/v1/auth/csrf")
-    assert authenticated_response.status_code == 200
-    authenticated_payload = authenticated_response.json()["data"]
-    assert isinstance(authenticated_payload["csrf_token"], str)
-    assert authenticated_payload["authenticated"] is True
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_me_returns_user_and_csrf_token(db_session: AsyncSession) -> None:
-    await insert_user(
-        db_session,
-        email="api-me@example.com",
-        password="api-password",
-    )
-
-    client = TestClient(app)
-    login_user(client, email="api-me@example.com", password="api-password")
-
-    response = client.get("/api/v1/auth/me")
-
-    assert response.status_code == 200
-    payload = response.json()
-    assert payload["data"]["authenticated"] is True
-    assert payload["data"]["user"]["email"] == "api-me@example.com"
-    assert isinstance(payload["data"]["csrf_token"], str)
-    assert payload["meta"]["request_id"]
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_login_and_change_password_flow(db_session: AsyncSession) -> None:
-    await insert_user(
-        db_session,
-        email="api-login@example.com",
-        password="old-password",
-    )
-    client = TestClient(app)
-
-    missing_csrf = client.post(
-        "/api/v1/auth/login",
-        json={"email": "api-login@example.com", "password": "old-password"},
-    )
-    assert missing_csrf.status_code == 403
-    assert missing_csrf.json()["error"]["code"] == "csrf_missing"
-
-    login_headers = _api_bootstrap_csrf_headers(client)
-    login_response = client.post(
-        "/api/v1/auth/login",
-        json={"email": "api-login@example.com", "password": "old-password"},
-        headers=login_headers,
-    )
-    assert login_response.status_code == 200
-    login_payload = login_response.json()["data"]
-    assert login_payload["authenticated"] is True
-    assert login_payload["user"]["email"] == "api-login@example.com"
-    assert isinstance(login_payload["csrf_token"], str)
-
-    bad_change_response = client.post(
-        "/api/v1/auth/change-password",
-        json={
-            "current_password": "not-correct",
-            "new_password": "new-password",
-            "confirm_password": "new-password",
-        },
-        headers={"X-CSRF-Token": login_payload["csrf_token"]},
-    )
-    assert bad_change_response.status_code == 400
-    assert bad_change_response.json()["error"]["code"] == "invalid_current_password"
-
-    change_response = client.post(
-        "/api/v1/auth/change-password",
-        json={
-            "current_password": "old-password",
-            "new_password": "new-password",
-            "confirm_password": "new-password",
-        },
-        headers={"X-CSRF-Token": login_payload["csrf_token"]},
-    )
-    assert change_response.status_code == 200
-    assert change_response.json()["data"]["message"] == "Password updated successfully."
-
-    logout_response = client.post(
-        "/api/v1/auth/logout",
-        headers={"X-CSRF-Token": login_payload["csrf_token"]},
-    )
-    assert logout_response.status_code == 200
-
-    relogin_headers = _api_bootstrap_csrf_headers(client)
-    old_password_login = client.post(
-        "/api/v1/auth/login",
-        json={"email": "api-login@example.com", "password": "old-password"},
-        headers=relogin_headers,
-    )
-    assert old_password_login.status_code == 401
-    assert old_password_login.json()["error"]["code"] == "invalid_credentials"
-
-    fresh_headers = _api_bootstrap_csrf_headers(client)
-    new_password_login = client.post(
-        "/api/v1/auth/login",
-        json={"email": "api-login@example.com", "password": "new-password"},
-        headers=fresh_headers,
-    )
-    assert new_password_login.status_code == 200
-    assert new_password_login.json()["data"]["authenticated"] is True
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_admin_user_management_endpoints(db_session: AsyncSession) -> None:
-    admin_user_id = await insert_user(
-        db_session,
-        email="api-admin@example.com",
-        password="admin-password",
-        is_admin=True,
-    )
-    target_user_id = await insert_user(
-        db_session,
-        email="api-target@example.com",
-        password="target-password",
-        is_admin=False,
-    )
-    await insert_user(
-        db_session,
-        email="api-member@example.com",
-        password="member-password",
-        is_admin=False,
-    )
-
-    client = TestClient(app)
-    login_user(client, email="api-admin@example.com", password="admin-password")
-    headers = _api_csrf_headers(client)
-
-    list_response = client.get("/api/v1/admin/users")
-    assert list_response.status_code == 200
-    users = list_response.json()["data"]["users"]
-    assert any(item["email"] == "api-target@example.com" for item in users)
-
-    create_response = client.post(
-        "/api/v1/admin/users",
-        json={
-            "email": "api-created@example.com",
-            "password": "created-password",
-            "is_admin": True,
-        },
-        headers=headers,
-    )
-    assert create_response.status_code == 201
-    created_user = create_response.json()["data"]
-    assert created_user["email"] == "api-created@example.com"
-    created_user_id = int(created_user["id"])
-
-    deactivate_response = client.patch(
-        f"/api/v1/admin/users/{target_user_id}/active",
-        json={"is_active": False},
-        headers=headers,
-    )
-    assert deactivate_response.status_code == 200
-    assert deactivate_response.json()["data"]["is_active"] is False
-
-    reactivate_response = client.patch(
-        f"/api/v1/admin/users/{target_user_id}/active",
-        json={"is_active": True},
-        headers=headers,
-    )
-    assert reactivate_response.status_code == 200
-    assert reactivate_response.json()["data"]["is_active"] is True
-
-    reset_response = client.post(
-        f"/api/v1/admin/users/{target_user_id}/reset-password",
-        json={"new_password": "target-password-updated"},
-        headers=headers,
-    )
-    assert reset_response.status_code == 200
-    assert "Password reset" in reset_response.json()["data"]["message"]
-
-    self_deactivate = client.patch(
-        f"/api/v1/admin/users/{admin_user_id}/active",
-        json={"is_active": False},
-        headers=headers,
-    )
-    assert self_deactivate.status_code == 400
-    assert self_deactivate.json()["error"]["code"] == "cannot_deactivate_self"
-
-    logout_response = client.post("/api/v1/auth/logout", headers=headers)
-    assert logout_response.status_code == 200
-
-    target_headers = _api_bootstrap_csrf_headers(client)
-    target_login = client.post(
-        "/api/v1/auth/login",
-        json={"email": "api-target@example.com", "password": "target-password-updated"},
-        headers=target_headers,
-    )
-    assert target_login.status_code == 200
-
-    non_admin_headers = {"X-CSRF-Token": target_login.json()["data"]["csrf_token"]}
-    forbidden_response = client.get("/api/v1/admin/users")
-    assert forbidden_response.status_code == 403
-    assert forbidden_response.json()["error"]["code"] == "forbidden"
-
-    forbidden_create = client.post(
-        "/api/v1/admin/users",
-        json={
-            "email": "should-not-work@example.com",
-            "password": "password-123",
-            "is_admin": False,
-        },
-        headers=non_admin_headers,
-    )
-    assert forbidden_create.status_code == 403
-
-    created_exists = await db_session.execute(
-        text("SELECT COUNT(*) FROM users WHERE id = :user_id"),
-        {"user_id": created_user_id},
-    )
-    assert created_exists.scalar_one() == 1
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_admin_scholar_http_settings_endpoints(db_session: AsyncSession) -> None:
-    await insert_user(
-        db_session,
-        email="api-admin-http@example.com",
-        password="admin-password",
-        is_admin=True,
-    )
-    await insert_user(
-        db_session,
-        email="api-member-http@example.com",
-        password="member-password",
-        is_admin=False,
-    )
-    previous_user_agent = settings.scholar_http_user_agent
-    previous_rotate = settings.scholar_http_rotate_user_agent
-    previous_accept_language = settings.scholar_http_accept_language
-    previous_cookie = settings.scholar_http_cookie
-    try:
-        client = TestClient(app)
-        login_user(client, email="api-admin-http@example.com", password="admin-password")
-        headers = _api_csrf_headers(client)
-
-        read_response = client.get("/api/v1/admin/settings/scholar-http")
-        assert read_response.status_code == 200
-
-        update_response = client.put(
-            "/api/v1/admin/settings/scholar-http",
-            json={
-                "user_agent": "Mozilla/5.0 Test Runner",
-                "rotate_user_agent": False,
-                "accept_language": "en-US,en;q=0.8",
-                "cookie": "SID=test-cookie",
-            },
-            headers=headers,
-        )
-        assert update_response.status_code == 200
-        payload = update_response.json()["data"]
-        assert payload["user_agent"] == "Mozilla/5.0 Test Runner"
-        assert payload["cookie"] == "SID=test-cookie"
-        assert settings.scholar_http_user_agent == "Mozilla/5.0 Test Runner"
-
-        client.post("/api/v1/auth/logout", headers=headers)
-        login_user(client, email="api-member-http@example.com", password="member-password")
-        forbidden_response = client.get("/api/v1/admin/settings/scholar-http")
-        assert forbidden_response.status_code == 403
-    finally:
-        object.__setattr__(settings, "scholar_http_user_agent", previous_user_agent)
-        object.__setattr__(settings, "scholar_http_rotate_user_agent", previous_rotate)
-        object.__setattr__(settings, "scholar_http_accept_language", previous_accept_language)
-        object.__setattr__(settings, "scholar_http_cookie", previous_cookie)
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_admin_dbops_integrity_and_repair_flow(db_session: AsyncSession) -> None:
-    await insert_user(db_session, email="api-admin-dbops@example.com", password="admin-password", is_admin=True)
-    target_user_id = await insert_user(db_session, email="api-dbops-target@example.com", password="target-password")
-    _scholar_id, publication_id = await _seed_publication_link_for_user(
-        db_session,
-        user_id=target_user_id,
-        scholar_id="dbopsTarget01",
-        title="DB Ops Target Paper",
-        fingerprint=f"{(target_user_id + 31):064x}",
-    )
-    client = TestClient(app)
-    login_user(client, email="api-admin-dbops@example.com", password="admin-password")
-    headers = _api_csrf_headers(client)
-
-    integrity_response = client.get("/api/v1/admin/db/integrity")
-    assert integrity_response.status_code == 200
-    integrity_payload = integrity_response.json()["data"]
-    assert integrity_payload["status"] in {"ok", "warning", "failed"}
-    assert any(check["name"] == "missing_pdf_url" for check in integrity_payload["checks"])
-
-    repair_response = client.post(
-        "/api/v1/admin/db/repairs/publication-links",
-        json={"user_id": target_user_id, "dry_run": True},
-        headers=headers,
-    )
-    assert repair_response.status_code == 200
-    repair_data = repair_response.json()["data"]
-    assert repair_data["status"] == "completed"
-    assert bool(repair_data["summary"]["dry_run"]) is True
-    job_id = int(repair_data["job_id"])
-
-    jobs_response = client.get("/api/v1/admin/db/repair-jobs?limit=10")
-    assert jobs_response.status_code == 200
-    jobs = jobs_response.json()["data"]["jobs"]
-    assert any(int(job["id"]) == job_id for job in jobs)
-
-    pdf_queue_response = client.get("/api/v1/admin/db/pdf-queue?limit=20")
-    assert pdf_queue_response.status_code == 200
-    pdf_queue_payload = pdf_queue_response.json()["data"]
-    assert isinstance(pdf_queue_payload["items"], list)
-    assert int(pdf_queue_payload["page"]) == 1
-    assert int(pdf_queue_payload["page_size"]) == 20
-    assert int(pdf_queue_payload["total_count"]) >= 0
-    assert isinstance(pdf_queue_payload["has_next"], bool)
-    assert isinstance(pdf_queue_payload["has_prev"], bool)
-    page_two_response = client.get("/api/v1/admin/db/pdf-queue?page=2&page_size=1")
-    assert page_two_response.status_code == 200
-    page_two_payload = page_two_response.json()["data"]
-    assert int(page_two_payload["page"]) == 2
-    assert int(page_two_payload["page_size"]) == 1
-    assert page_two_payload["has_prev"] is True
-    untracked_response = client.get("/api/v1/admin/db/pdf-queue?limit=20&status=untracked")
-    assert untracked_response.status_code == 200
-    assert any(item["status"] == "untracked" for item in untracked_response.json()["data"]["items"])
-
-    link_count_result = await db_session.execute(
-        text("SELECT count(*) FROM scholar_publications WHERE publication_id = :publication_id"),
-        {"publication_id": publication_id},
-    )
-    assert int(link_count_result.scalar_one()) == 1
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_admin_dbops_pdf_queue_requeue_endpoint(
-    db_session: AsyncSession,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    await insert_user(db_session, email="api-admin-pdf@example.com", password="admin-password", is_admin=True)
-    target_user_id = await insert_user(db_session, email="api-pdf-target@example.com", password="target-password")
-    _scholar_id, publication_id = await _seed_publication_link_for_user(
-        db_session,
-        user_id=target_user_id,
-        scholar_id="dbopsPdf01",
-        title="PDF Queue Target",
-        fingerprint=f"{(target_user_id + 73):064x}",
-    )
-    monkeypatch.setattr(
-        "app.services.publications.pdf_queue._schedule_rows",
-        lambda **_kwargs: None,
-    )
-    client = TestClient(app)
-    login_user(client, email="api-admin-pdf@example.com", password="admin-password")
-    headers = _api_csrf_headers(client)
-
-    first_response = client.post(
-        f"/api/v1/admin/db/pdf-queue/{publication_id}/requeue",
-        headers=headers,
-    )
-    assert first_response.status_code == 200
-    first_data = first_response.json()["data"]
-    assert first_data["publication_id"] == publication_id
-    assert first_data["queued"] is True
-    assert first_data["status"] == "queued"
-
-    second_response = client.post(
-        f"/api/v1/admin/db/pdf-queue/{publication_id}/requeue",
-        headers=headers,
-    )
-    assert second_response.status_code == 200
-    second_data = second_response.json()["data"]
-    assert second_data["queued"] is False
-    assert second_data["status"] == "blocked"
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_admin_dbops_pdf_queue_requeue_all_endpoint(
-    db_session: AsyncSession,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    await insert_user(db_session, email="api-admin-pdf-all@example.com", password="admin-password", is_admin=True)
-    target_user_id = await insert_user(db_session, email="api-pdf-all-target@example.com", password="target-password")
-    _scholar_id, _publication_id = await _seed_publication_link_for_user(
-        db_session,
-        user_id=target_user_id,
-        scholar_id="dbopsPdfAll01",
-        title="PDF Queue All Target",
-        fingerprint=f"{(target_user_id + 83):064x}",
-    )
-    monkeypatch.setattr(
-        "app.services.publications.pdf_queue._schedule_rows",
-        lambda **_kwargs: None,
-    )
-    client = TestClient(app)
-    login_user(client, email="api-admin-pdf-all@example.com", password="admin-password")
-    headers = _api_csrf_headers(client)
-
-    response = client.post(
-        "/api/v1/admin/db/pdf-queue/requeue-all?limit=500",
-        headers=headers,
-    )
-    assert response.status_code == 200
-    payload = response.json()["data"]
-    assert int(payload["requested_count"]) >= 1
-    assert int(payload["queued_count"]) >= 1
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_admin_dbops_forbidden_for_non_admin_and_validates_scope(db_session: AsyncSession) -> None:
-    await insert_user(db_session, email="api-admin-dbops2@example.com", password="admin-password", is_admin=True)
-    member_user_id = await insert_user(db_session, email="api-dbops-member@example.com", password="member-password")
-    client = TestClient(app)
-    login_user(client, email="api-dbops-member@example.com", password="member-password")
-    headers = _api_csrf_headers(client)
-
-    forbidden_integrity = client.get("/api/v1/admin/db/integrity")
-    assert forbidden_integrity.status_code == 403
-    assert forbidden_integrity.json()["error"]["code"] == "forbidden"
-
-    forbidden_pdf_queue = client.get("/api/v1/admin/db/pdf-queue")
-    assert forbidden_pdf_queue.status_code == 403
-    assert forbidden_pdf_queue.json()["error"]["code"] == "forbidden"
-
-    forbidden_requeue = client.post(
-        "/api/v1/admin/db/pdf-queue/1/requeue",
-        headers=headers,
-    )
-    assert forbidden_requeue.status_code == 403
-    assert forbidden_requeue.json()["error"]["code"] == "forbidden"
-
-    forbidden_requeue_all = client.post(
-        "/api/v1/admin/db/pdf-queue/requeue-all?limit=100",
-        headers=headers,
-    )
-    assert forbidden_requeue_all.status_code == 403
-    assert forbidden_requeue_all.json()["error"]["code"] == "forbidden"
-
-    forbidden_repair = client.post(
-        "/api/v1/admin/db/repairs/publication-links",
-        json={"user_id": member_user_id, "dry_run": True},
-        headers=headers,
-    )
-    assert forbidden_repair.status_code == 403
-    assert forbidden_repair.json()["error"]["code"] == "forbidden"
-
-    forbidden_near_duplicate = client.post(
-        "/api/v1/admin/db/repairs/publication-near-duplicates",
-        json={"dry_run": True},
-        headers=headers,
-    )
-    assert forbidden_near_duplicate.status_code == 403
-    assert forbidden_near_duplicate.json()["error"]["code"] == "forbidden"
-
-    admin_headers = _api_bootstrap_csrf_headers(client)
-    admin_login = client.post(
-        "/api/v1/auth/login",
-        json={"email": "api-admin-dbops2@example.com", "password": "admin-password"},
-        headers=admin_headers,
-    )
-    assert admin_login.status_code == 200
-    post_login_headers = {"X-CSRF-Token": admin_login.json()["data"]["csrf_token"]}
-    invalid_scope = client.post(
-        "/api/v1/admin/db/repairs/publication-links",
-        json={"user_id": member_user_id, "dry_run": True},
-        headers=post_login_headers,
-    )
-    assert invalid_scope.status_code == 400
-    assert invalid_scope.json()["error"]["code"] == "invalid_repair_scope"
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_admin_dbops_all_users_apply_requires_confirmation(db_session: AsyncSession) -> None:
-    await insert_user(db_session, email="api-admin-dbops3@example.com", password="admin-password", is_admin=True)
-    first_user_id = await insert_user(db_session, email="api-dbops-a@example.com", password="user-password")
-    second_user_id = await insert_user(db_session, email="api-dbops-b@example.com", password="user-password")
-    await _seed_publication_link_for_user(
-        db_session,
-        user_id=first_user_id,
-        scholar_id="dbopsAll01",
-        title="DB Ops All User Paper One",
-        fingerprint=f"{(first_user_id + 61):064x}",
-    )
-    await _seed_publication_link_for_user(
-        db_session,
-        user_id=second_user_id,
-        scholar_id="dbopsAll02",
-        title="DB Ops All User Paper Two",
-        fingerprint=f"{(second_user_id + 71):064x}",
-    )
-
-    client = TestClient(app)
-    login_user(client, email="api-admin-dbops3@example.com", password="admin-password")
-    headers = _api_csrf_headers(client)
-
-    missing_confirmation = client.post(
-        "/api/v1/admin/db/repairs/publication-links",
-        json={"scope_mode": "all_users", "dry_run": False},
-        headers=headers,
-    )
-    assert missing_confirmation.status_code == 422
-    assert "confirmation_text" in str(missing_confirmation.json())
-
-    apply_response = client.post(
-        "/api/v1/admin/db/repairs/publication-links",
-        json={
-            "scope_mode": "all_users",
-            "dry_run": False,
-            "confirmation_text": "REPAIR ALL USERS",
-        },
-        headers=headers,
-    )
-    assert apply_response.status_code == 200
-    apply_data = apply_response.json()["data"]
-    assert apply_data["status"] == "completed"
-    assert apply_data["scope"]["scope_mode"] == "all_users"
-    assert int(apply_data["summary"]["links_deleted"]) >= 2
-
-    remaining_links = await db_session.execute(text("SELECT count(*) FROM scholar_publications"))
-    assert int(remaining_links.scalar_one()) == 0
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_admin_dbops_near_duplicate_repair_scan_and_apply(
-    db_session: AsyncSession,
-) -> None:
-    await insert_user(
-        db_session,
-        email="api-admin-near-dup@example.com",
-        password="admin-password",
-        is_admin=True,
-    )
-    user_id = await insert_user(
-        db_session,
-        email="api-near-dup-target@example.com",
-        password="user-password",
-    )
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "nearDupScholar01",
-            "display_name": "Near Dup Target",
-        },
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-    first_pub = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, year, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 2014, 100)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 1201):064x}",
-            "title_raw": "Adam: A method for stochastic optimization",
-            "title_normalized": "adam a method for stochastic optimization",
-        },
-    )
-    first_publication_id = int(first_pub.scalar_one())
-    second_pub = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, year, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 2015, 10)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 1202):064x}",
-            "title_raw": "†œAdam: A method for stochastic optimization, †3rd Int. Conf. Learn. Represent.",
-            "title_normalized": "adam method for stochastic optimization",
-        },
-    )
-    second_publication_id = int(second_pub.scalar_one())
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
-            VALUES (:scholar_profile_id, :first_publication_id, false),
-                   (:scholar_profile_id, :second_publication_id, false)
-            """
-        ),
-        {
-            "scholar_profile_id": scholar_profile_id,
-            "first_publication_id": first_publication_id,
-            "second_publication_id": second_publication_id,
-        },
-    )
-    await db_session.commit()
-
-    client = TestClient(app)
-    login_user(client, email="api-admin-near-dup@example.com", password="admin-password")
-    headers = _api_csrf_headers(client)
-
-    scan_response = client.post(
-        "/api/v1/admin/db/repairs/publication-near-duplicates",
-        json={"dry_run": True, "max_clusters": 20},
-        headers=headers,
-    )
-    assert scan_response.status_code == 200
-    scan_data = scan_response.json()["data"]
-    assert scan_data["status"] == "completed"
-    assert int(scan_data["summary"]["candidate_cluster_count"]) >= 1
-    assert len(scan_data["clusters"]) >= 1
-    selected_key = str(scan_data["clusters"][0]["cluster_key"])
-
-    missing_confirmation = client.post(
-        "/api/v1/admin/db/repairs/publication-near-duplicates",
-        json={"dry_run": False, "selected_cluster_keys": [selected_key]},
-        headers=headers,
-    )
-    assert missing_confirmation.status_code == 422
-    assert "confirmation_text" in str(missing_confirmation.json())
-
-    apply_response = client.post(
-        "/api/v1/admin/db/repairs/publication-near-duplicates",
-        json={
-            "dry_run": False,
-            "selected_cluster_keys": [selected_key],
-            "confirmation_text": "MERGE SELECTED DUPLICATES",
-        },
-        headers=headers,
-    )
-    assert apply_response.status_code == 200
-    apply_data = apply_response.json()["data"]
-    assert apply_data["status"] == "completed"
-    assert int(apply_data["summary"]["merged_publications"]) >= 1
-
-    remaining = await db_session.execute(
-        text(
-            """
-            SELECT count(*)
-            FROM publications
-            WHERE id IN (:first_publication_id, :second_publication_id)
-            """
-        ),
-        {
-            "first_publication_id": first_publication_id,
-            "second_publication_id": second_publication_id,
-        },
-    )
-    assert int(remaining.scalar_one()) == 1
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_scholars_crud_flow(db_session: AsyncSession) -> None:
-    await insert_user(
-        db_session,
-        email="api-scholars@example.com",
-        password="api-password",
-    )
-
-    client = TestClient(app)
-    login_user(client, email="api-scholars@example.com", password="api-password")
-    headers = _api_csrf_headers(client)
-
-    missing_csrf = client.post(
-        "/api/v1/scholars",
-        json={"scholar_id": "abcDEF123456"},
-    )
-    assert missing_csrf.status_code == 403
-    assert missing_csrf.json()["error"]["code"] == "csrf_invalid"
-
-    create_response = client.post(
-        "/api/v1/scholars",
-        json={"scholar_id": "abcDEF123456"},
-        headers=headers,
-    )
-    assert create_response.status_code == 201
-    created = create_response.json()["data"]
-    assert created["scholar_id"] == "abcDEF123456"
-    scholar_profile_id = int(created["id"])
-
-    list_response = client.get("/api/v1/scholars")
-    assert list_response.status_code == 200
-    scholars = list_response.json()["data"]["scholars"]
-    assert any(int(item["id"]) == scholar_profile_id for item in scholars)
-
-    toggle_response = client.patch(
-        f"/api/v1/scholars/{scholar_profile_id}/toggle",
-        headers=headers,
-    )
-    assert toggle_response.status_code == 200
-    assert toggle_response.json()["data"]["is_enabled"] is False
-
-    delete_response = client.delete(
-        f"/api/v1/scholars/{scholar_profile_id}",
-        headers=headers,
-    )
-    assert delete_response.status_code == 200
-    assert delete_response.json()["data"]["message"] == "Scholar deleted."
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_scholars_search_and_profile_image_management(
-    db_session: AsyncSession,
-    tmp_path: Path,
-) -> None:
-    await insert_user(
-        db_session,
-        email="api-scholar-images@example.com",
-        password="api-password",
-    )
-
-    class StubScholarSource:
-        async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
-            assert scholar_id == "abcDEF123456"
-            return FetchResult(
-                requested_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
-                status_code=200,
-                final_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
-                body=(
-                    "<html><head>"
-                    '<meta property="og:image" content="https://images.example.com/ada.png" />'
-                    "</head><body>"
-                    '<div id="gsc_prf_in">Ada Lovelace</div>'
-                    "</body></html>"
-                ),
-                error=None,
-            )
-
-        async def fetch_author_search_html(self, query: str, *, start: int) -> FetchResult:
-            assert query == "Ada Lovelace"
-            assert start == 0
-            return FetchResult(
-                requested_url="https://scholar.google.com/citations?hl=en&view_op=search_authors&mauthors=ada",
-                status_code=200,
-                final_url="https://scholar.google.com/citations?hl=en&view_op=search_authors&mauthors=ada",
-                body=(
-                    '<div class="gsc_1usr">'
-                    '<img src="/citations/images/avatar_scholar_256.png" />'
-                    '<a class="gs_ai_name" href="/citations?hl=en&user=abcDEF123456">Ada Lovelace</a>'
-                    '<div class="gs_ai_aff">Analytical Engine</div>'
-                    '<div class="gs_ai_eml">Verified email at computing.example</div>'
-                    '<div class="gs_ai_cby">Cited by 42</div>'
-                    '<a class="gs_ai_one_int">Mathematics</a>'
-                    "</div>"
-                ),
-                error=None,
-            )
-
-    previous_upload_dir = settings.scholar_image_upload_dir
-    previous_upload_max_bytes = settings.scholar_image_upload_max_bytes
-    previous_queue_enabled = settings.ingestion_continuation_queue_enabled
-    app.dependency_overrides[get_scholar_source] = lambda: StubScholarSource()
-    object.__setattr__(settings, "scholar_image_upload_dir", str(tmp_path / "scholar_images"))
-    object.__setattr__(settings, "scholar_image_upload_max_bytes", 1_000_000)
-    object.__setattr__(settings, "ingestion_continuation_queue_enabled", False)
-
-    try:
-        client = TestClient(app)
-        login_user(client, email="api-scholar-images@example.com", password="api-password")
-        headers = _api_csrf_headers(client)
-
-        search_response = client.get("/api/v1/scholars/search", params={"query": "Ada Lovelace", "limit": 5})
-        assert search_response.status_code == 200
-        search_payload = search_response.json()["data"]
-        assert search_payload["state"] == "ok"
-        assert len(search_payload["candidates"]) == 1
-        candidate = search_payload["candidates"][0]
-        assert candidate["scholar_id"] == "abcDEF123456"
-        assert candidate["profile_image_url"] == "https://scholar.google.com/citations/images/avatar_scholar_256.png"
-
-        create_response = client.post(
-            "/api/v1/scholars",
-            json={
-                "scholar_id": candidate["scholar_id"],
-            },
-            headers=headers,
-        )
-        assert create_response.status_code == 201
-        created = create_response.json()["data"]
-        scholar_profile_id = int(created["id"])
-        assert created["profile_image_source"] == "scraped"
-        assert created["profile_image_url"] == "https://images.example.com/ada.png"
-
-        set_url_response = client.put(
-            f"/api/v1/scholars/{scholar_profile_id}/image/url",
-            json={"image_url": "https://cdn.example.com/custom-avatar.png"},
-            headers=headers,
-        )
-        assert set_url_response.status_code == 200
-        set_url_data = set_url_response.json()["data"]
-        assert set_url_data["profile_image_source"] == "override"
-        assert set_url_data["profile_image_url"] == "https://cdn.example.com/custom-avatar.png"
-
-        uploaded_bytes = b"\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01"
-        upload_response = client.post(
-            f"/api/v1/scholars/{scholar_profile_id}/image/upload",
-            files={"image": ("avatar.png", uploaded_bytes, "image/png")},
-            headers=headers,
-        )
-        assert upload_response.status_code == 200
-        upload_data = upload_response.json()["data"]
-        assert upload_data["profile_image_source"] == "upload"
-        assert upload_data["profile_image_url"] == f"/scholar-images/{scholar_profile_id}/upload"
-
-        uploaded_image_response = client.get(f"/scholar-images/{scholar_profile_id}/upload")
-        assert uploaded_image_response.status_code == 200
-        assert uploaded_image_response.headers["content-type"].startswith("image/png")
-        assert uploaded_image_response.content == uploaded_bytes
-
-        clear_response = client.delete(
-            f"/api/v1/scholars/{scholar_profile_id}/image",
-            headers=headers,
-        )
-        assert clear_response.status_code == 200
-        clear_data = clear_response.json()["data"]
-        assert clear_data["profile_image_source"] == "scraped"
-        assert clear_data["profile_image_url"] == "https://images.example.com/ada.png"
-    finally:
-        app.dependency_overrides.pop(get_scholar_source, None)
-        object.__setattr__(settings, "scholar_image_upload_dir", previous_upload_dir)
-        object.__setattr__(
-            settings,
-            "scholar_image_upload_max_bytes",
-            previous_upload_max_bytes,
-        )
-        object.__setattr__(settings, "ingestion_continuation_queue_enabled", previous_queue_enabled)
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_scholar_import_export_round_trip(
-    db_session: AsyncSession,
-) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-import-export@example.com",
-        password="api-password",
-    )
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "abcDEF123456",
-            "display_name": "Existing Scholar",
-        },
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-    publication_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 1)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 500):064x}",
-            "title_raw": "Existing Publication",
-            "title_normalized": "existingpublication",
-        },
-    )
-    publication_id = int(publication_result.scalar_one())
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
-            VALUES (:scholar_profile_id, :publication_id, false)
-            """
-        ),
-        {
-            "scholar_profile_id": scholar_profile_id,
-            "publication_id": publication_id,
-        },
-    )
-    await db_session.commit()
-
-    client = TestClient(app)
-    login_user(client, email="api-import-export@example.com", password="api-password")
-    headers = _api_csrf_headers(client)
-
-    export_response = client.get("/api/v1/scholars/export")
-    assert export_response.status_code == 200
-    export_payload = export_response.json()["data"]
-    assert export_payload["schema_version"] == 1
-    assert len(export_payload["scholars"]) == 1
-    assert len(export_payload["publications"]) == 1
-
-    import_response = client.post(
-        "/api/v1/scholars/import",
-        json={
-            "schema_version": 1,
-            "scholars": [
-                {
-                    "scholar_id": "abcDEF123456",
-                    "display_name": "Updated Scholar",
-                    "is_enabled": False,
-                    "profile_image_override_url": "https://cdn.example.com/avatar.png",
-                },
-                {
-                    "scholar_id": "zzzYYY111222",
-                    "display_name": "Imported Scholar",
-                    "is_enabled": True,
-                    "profile_image_override_url": None,
-                },
-            ],
-            "publications": [
-                {
-                    "scholar_id": "abcDEF123456",
-                    "title": "Existing Publication",
-                    "year": 2024,
-                    "citation_count": 8,
-                    "author_text": "A. Author",
-                    "venue_text": "Test Venue",
-                    "pub_url": "https://example.org/existing",
-                    "pdf_url": "https://example.org/existing.pdf",
-                    "is_read": True,
-                },
-                {
-                    "scholar_id": "zzzYYY111222",
-                    "title": "Imported Publication",
-                    "year": 2025,
-                    "citation_count": 2,
-                    "author_text": "B. Author",
-                    "venue_text": "Another Venue",
-                    "pub_url": "https://example.org/imported",
-                    "pdf_url": "https://example.org/imported.pdf",
-                    "is_read": False,
-                },
-            ],
-        },
-        headers=headers,
-    )
-    assert import_response.status_code == 200
-    import_data = import_response.json()["data"]
-    assert int(import_data["scholars_created"]) == 1
-    assert int(import_data["scholars_updated"]) >= 1
-    assert int(import_data["publications_created"]) == 1
-    assert int(import_data["links_created"]) == 1
-
-    updated_scholar_result = await db_session.execute(
-        text(
-            """
-            SELECT display_name, is_enabled, profile_image_override_url
-            FROM scholar_profiles
-            WHERE user_id = :user_id AND scholar_id = :scholar_id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "abcDEF123456",
-        },
-    )
-    updated_scholar = updated_scholar_result.one()
-    assert updated_scholar[0] == "Updated Scholar"
-    assert updated_scholar[1] is False
-    assert updated_scholar[2] == "https://cdn.example.com/avatar.png"
-
-    imported_pub_result = await db_session.execute(
-        text(
-            """
-            SELECT p.title_raw, p.pdf_url
-            FROM publications p
-            WHERE p.title_raw = :title
-            """
-        ),
-        {"title": "Imported Publication"},
-    )
-    imported_pub = imported_pub_result.one()
-    assert imported_pub[0] == "Imported Publication"
-    assert imported_pub[1] == "https://example.org/imported.pdf"
-
-    updated_link_result = await db_session.execute(
-        text(
-            """
-            SELECT sp.is_read
-            FROM scholar_publications sp
-            JOIN scholar_profiles s ON s.id = sp.scholar_profile_id
-            JOIN publications p ON p.id = sp.publication_id
-            WHERE s.user_id = :user_id
-              AND s.scholar_id = :scholar_id
-              AND p.title_raw = :title
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "abcDEF123456",
-            "title": "Existing Publication",
-        },
-    )
-    assert bool(updated_link_result.scalar_one()) is True
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_manual_run_skips_unchanged_initial_page_for_scholar(
-    db_session: AsyncSession,
-) -> None:
-    await insert_user(
-        db_session,
-        email="api-skip-unchanged@example.com",
-        password="api-password",
-    )
-
-    profile_html = """
-    <html>
-      <head>
-        <meta property="og:image" content="https://images.example.com/skip.png" />
-      </head>
-      <body>
-        <div id="gsc_prf_in">Skip Candidate</div>
-        <span id="gsc_a_nn">Articles 1-1</span>
-        <table>
-          <tbody id="gsc_a_b">
-            <tr class="gsc_a_tr">
-              <td class="gsc_a_t">
-                <a class="gsc_a_at" href="/citations?view_op=view_citation&citation_for_view=abcDEF123456:xyz123">Stable Paper</a>
-                <div class="gs_gray">A Author</div>
-                <div class="gs_gray">Stable Venue</div>
-              </td>
-              <td class="gsc_a_c"><a class="gsc_a_ac">5</a></td>
-              <td class="gsc_a_y"><span class="gsc_a_h">2024</span></td>
-            </tr>
-          </tbody>
-        </table>
-      </body>
-    </html>
-    """
-
-    class StubScholarSource:
-        async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
-            assert scholar_id == "abcDEF123456"
-            return FetchResult(
-                requested_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
-                status_code=200,
-                final_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
-                body=profile_html,
-                error=None,
-            )
-
-        async def fetch_profile_page_html(
-            self,
-            scholar_id: str,
-            *,
-            cstart: int,
-            pagesize: int,
-        ) -> FetchResult:
-            assert scholar_id == "abcDEF123456"
-            assert cstart == 0
-            assert pagesize == settings.ingestion_page_size
-            return FetchResult(
-                requested_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
-                status_code=200,
-                final_url="https://scholar.google.com/citations?hl=en&user=abcDEF123456",
-                body=profile_html,
-                error=None,
-            )
-
-    app.dependency_overrides[get_scholar_source] = lambda: StubScholarSource()
-    try:
-        with TestClient(app) as client:
-            login_user(client, email="api-skip-unchanged@example.com", password="api-password")
-            headers = _api_csrf_headers(client)
-
-            create_response = client.post(
-                "/api/v1/scholars",
-                json={"scholar_id": "abcDEF123456"},
-                headers=headers,
-            )
-            assert create_response.status_code == 201
-
-            first_run_response = client.post(
-                "/api/v1/runs/manual",
-                headers={**headers, "Idempotency-Key": "skip-unchanged-run-001"},
-            )
-            assert first_run_response.status_code == 200
-            first_run_id = int(first_run_response.json()["data"]["run_id"])
-
-            first_detail_data = await _wait_for_run_complete(client, first_run_id)
-            first_results = first_detail_data["scholar_results"]
-            assert len(first_results) == 1
-            assert first_results[0]["state_reason"] != "no_change_initial_page_signature"
-
-            second_run_response = client.post(
-                "/api/v1/runs/manual",
-                headers={**headers, "Idempotency-Key": "skip-unchanged-run-002"},
-            )
-            assert second_run_response.status_code == 200
-            second_run_id = int(second_run_response.json()["data"]["run_id"])
-
-            second_detail_data = await _wait_for_run_complete(client, second_run_id)
-            second_results = second_detail_data["scholar_results"]
-            assert len(second_results) == 1
-            assert second_results[0]["state_reason"] == "no_change_initial_page_signature"
-            assert second_results[0]["publication_count"] == 0
-            assert second_results[0]["outcome"] == "success"
-    finally:
-        app.dependency_overrides.pop(get_scholar_source, None)
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_settings_get_and_update(db_session: AsyncSession) -> None:
-    await insert_user(
-        db_session,
-        email="api-settings@example.com",
-        password="api-password",
-    )
-
-    client = TestClient(app)
-    login_user(client, email="api-settings@example.com", password="api-password")
-    headers = _api_csrf_headers(client)
-
-    get_response = client.get("/api/v1/settings")
-    assert get_response.status_code == 200
-    settings_payload = get_response.json()["data"]
-    assert "request_delay_seconds" in settings_payload
-    assert "nav_visible_pages" in settings_payload
-    assert settings_payload["policy"]["min_run_interval_minutes"] == user_settings_service.resolve_run_interval_minimum(
-        settings.ingestion_min_run_interval_minutes
-    )
-    assert settings_payload["policy"][
-        "min_request_delay_seconds"
-    ] == user_settings_service.resolve_request_delay_minimum(settings.ingestion_min_request_delay_seconds)
-    assert settings_payload["policy"]["automation_allowed"] is settings.ingestion_automation_allowed
-    assert settings_payload["policy"]["manual_run_allowed"] is settings.ingestion_manual_run_allowed
-    assert settings_payload["policy"]["blocked_failure_threshold"] == max(
-        1,
-        int(settings.ingestion_alert_blocked_failure_threshold),
-    )
-    assert settings_payload["policy"]["network_failure_threshold"] == max(
-        1,
-        int(settings.ingestion_alert_network_failure_threshold),
-    )
-    assert settings_payload["policy"]["cooldown_blocked_seconds"] == max(
-        60,
-        int(settings.ingestion_safety_cooldown_blocked_seconds),
-    )
-    assert settings_payload["policy"]["cooldown_network_seconds"] == max(
-        60,
-        int(settings.ingestion_safety_cooldown_network_seconds),
-    )
-    _assert_safety_state_contract(settings_payload["safety_state"])
-    assert settings_payload["safety_state"]["cooldown_active"] is False
-
-    policy = settings_payload["policy"]
-    run_interval_minutes = max(45, int(policy["min_run_interval_minutes"]))
-    request_delay_seconds = max(6, int(policy["min_request_delay_seconds"]))
-
-    update_response = client.put(
-        "/api/v1/settings",
-        json={
-            "auto_run_enabled": True,
-            "run_interval_minutes": run_interval_minutes,
-            "request_delay_seconds": request_delay_seconds,
-            "nav_visible_pages": ["dashboard", "scholars", "publications", "settings", "runs"],
-        },
-        headers=headers,
-    )
-    assert update_response.status_code == 200
-    updated = update_response.json()["data"]
-    assert updated["auto_run_enabled"] is True
-    assert updated["run_interval_minutes"] == run_interval_minutes
-    assert updated["request_delay_seconds"] == request_delay_seconds
-    assert updated["nav_visible_pages"] == [
-        "dashboard",
-        "scholars",
-        "publications",
-        "settings",
-        "runs",
-    ]
-    assert "policy" in updated
-    _assert_safety_state_contract(updated["safety_state"])
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_settings_enforce_env_minimums(db_session: AsyncSession) -> None:
-    await insert_user(
-        db_session,
-        email="api-settings-policy@example.com",
-        password="api-password",
-    )
-
-    client = TestClient(app)
-    login_user(client, email="api-settings-policy@example.com", password="api-password")
-    headers = _api_csrf_headers(client)
-
-    previous_min_interval = settings.ingestion_min_run_interval_minutes
-    previous_min_delay = settings.ingestion_min_request_delay_seconds
-    object.__setattr__(settings, "ingestion_min_run_interval_minutes", 30)
-    object.__setattr__(settings, "ingestion_min_request_delay_seconds", 8)
-    try:
-        interval_response = client.put(
-            "/api/v1/settings",
-            json={
-                "auto_run_enabled": True,
-                "run_interval_minutes": 29,
-                "request_delay_seconds": 9,
-                "nav_visible_pages": ["dashboard", "scholars", "settings"],
-            },
-            headers=headers,
-        )
-        assert interval_response.status_code == 400
-        assert interval_response.json()["error"]["code"] == "invalid_settings"
-        assert interval_response.json()["error"]["message"] == "Check interval must be at least 30 minutes."
-
-        delay_response = client.put(
-            "/api/v1/settings",
-            json={
-                "auto_run_enabled": True,
-                "run_interval_minutes": 30,
-                "request_delay_seconds": 7,
-                "nav_visible_pages": ["dashboard", "scholars", "settings"],
-            },
-            headers=headers,
-        )
-        assert delay_response.status_code == 400
-        assert delay_response.json()["error"]["code"] == "invalid_settings"
-        assert delay_response.json()["error"]["message"] == "Request delay must be at least 8 seconds."
-    finally:
-        object.__setattr__(settings, "ingestion_min_run_interval_minutes", previous_min_interval)
-        object.__setattr__(settings, "ingestion_min_request_delay_seconds", previous_min_delay)
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_runs_manual_and_queue_actions(db_session: AsyncSession) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-runs@example.com",
-        password="api-password",
-    )
-
-    client = TestClient(app)
-    login_user(client, email="api-runs@example.com", password="api-password")
-    headers = _api_csrf_headers(client)
-
-    run_response = client.post(
-        "/api/v1/runs/manual",
-        headers={**headers, "Idempotency-Key": "manual-run-0001"},
-    )
-    assert run_response.status_code == 200
-    run_payload = run_response.json()["data"]
-    assert "run_id" in run_payload
-    assert run_payload["status"] in {"running", "resolving", "success", "partial_failure", "failed"}
-    assert run_payload["reused_existing_run"] is False
-    assert run_payload["idempotency_key"] == "manual-run-0001"
-    _assert_safety_state_contract(run_payload["safety_state"])
-    run_id = int(run_payload["run_id"])
-
-    stored_key = await db_session.execute(
-        text("SELECT idempotency_key FROM crawl_runs WHERE id = :run_id"),
-        {"run_id": run_id},
-    )
-    assert stored_key.scalar_one() == "manual-run-0001"
-
-    replay_response = client.post(
-        "/api/v1/runs/manual",
-        headers={**headers, "Idempotency-Key": "manual-run-0001"},
-    )
-    assert replay_response.status_code in {200, 409}
-    if replay_response.status_code == 200:
-        replay_payload = replay_response.json()["data"]
-        assert replay_payload["run_id"] == run_payload["run_id"]
-        assert replay_payload["reused_existing_run"] is True
-        _assert_safety_state_contract(replay_payload["safety_state"])
-    else:
-        replay_error = replay_response.json()["error"]
-        assert replay_error["code"] == "run_in_progress"
-
-    runs_response = client.get("/api/v1/runs")
-    assert runs_response.status_code == 200
-    assert len(runs_response.json()["data"]["runs"]) >= 1
-    _assert_safety_state_contract(runs_response.json()["data"]["safety_state"])
-
-    run_detail_response = client.get(f"/api/v1/runs/{run_id}")
-    assert run_detail_response.status_code == 200
-    detail_payload = run_detail_response.json()["data"]
-    assert "summary" in detail_payload
-    assert isinstance(detail_payload["scholar_results"], list)
-    _assert_safety_state_contract(detail_payload["safety_state"])
-
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "abcDEF123456",
-            "display_name": "Queue Scholar",
-        },
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-    queue_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO ingestion_queue_items (
-                user_id,
-                scholar_profile_id,
-                resume_cstart,
-                reason,
-                status,
-                attempt_count,
-                next_attempt_dt,
-                dropped_reason,
-                dropped_at
-            )
-            VALUES (
-                :user_id,
-                :scholar_profile_id,
-                7,
-                'dropped',
-                'dropped',
-                2,
-                NOW(),
-                'manual_drop',
-                NOW()
-            )
-            RETURNING id
-            """
-        ),
-        {"user_id": user_id, "scholar_profile_id": scholar_profile_id},
-    )
-    queue_item_id = int(queue_result.scalar_one())
-    await db_session.commit()
-
-    queue_list_response = client.get("/api/v1/runs/queue/items")
-    assert queue_list_response.status_code == 200
-    assert any(int(item["id"]) == queue_item_id for item in queue_list_response.json()["data"]["queue_items"])
-
-    retry_response = client.post(f"/api/v1/runs/queue/{queue_item_id}/retry", headers=headers)
-    assert retry_response.status_code == 200
-    assert retry_response.json()["data"]["status"] == "queued"
-
-    retry_again_response = client.post(
-        f"/api/v1/runs/queue/{queue_item_id}/retry",
-        headers=headers,
-    )
-    assert retry_again_response.status_code == 409
-    assert retry_again_response.json()["error"]["code"] == "queue_item_already_queued"
-
-    drop_response = client.post(f"/api/v1/runs/queue/{queue_item_id}/drop", headers=headers)
-    assert drop_response.status_code == 200
-    assert drop_response.json()["data"]["status"] == "dropped"
-
-    clear_response = client.request(
-        "DELETE",
-        f"/api/v1/runs/queue/{queue_item_id}",
-        headers=headers,
-    )
-    assert clear_response.status_code == 200
-    assert clear_response.json()["data"]["status"] == "cleared"
-    assert clear_response.json()["data"]["message"] == "Queue item cleared."
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_manual_run_can_be_disabled_by_policy(db_session: AsyncSession) -> None:
-    await insert_user(
-        db_session,
-        email="api-runs-policy@example.com",
-        password="api-password",
-    )
-    client = TestClient(app)
-    login_user(client, email="api-runs-policy@example.com", password="api-password")
-    headers = _api_csrf_headers(client)
-
-    previous_manual_allowed = settings.ingestion_manual_run_allowed
-    object.__setattr__(settings, "ingestion_manual_run_allowed", False)
-    try:
-        response = client.post("/api/v1/runs/manual", headers=headers)
-        assert response.status_code == 403
-        payload = response.json()
-        assert payload["error"]["code"] == "manual_runs_disabled"
-        assert payload["error"]["details"]["policy"]["manual_run_allowed"] is False
-        assert payload["error"]["details"]["safety_state"]["cooldown_active"] is False
-    finally:
-        object.__setattr__(settings, "ingestion_manual_run_allowed", previous_manual_allowed)
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_manual_run_enforces_scrape_safety_cooldown(db_session: AsyncSession) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-runs-safety@example.com",
-        password="api-password",
-    )
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "A1B2C3D4E5F6",
-            "display_name": "Safety Probe",
-        },
-    )
-    await db_session.commit()
-
-    blocked_fixture = _regression_fixture("profile_AAAAAAAAAAAA.html")
-
-    class BlockedScholarSource:
-        async def fetch_profile_page_html(
-            self,
-            scholar_id: str,
-            *,
-            cstart: int,
-            pagesize: int,
-        ) -> FetchResult:
-            _ = (scholar_id, cstart, pagesize)
-            return FetchResult(
-                requested_url="https://scholar.google.com/citations?hl=en&user=A1B2C3D4E5F6",
-                status_code=200,
-                final_url=(
-                    "https://accounts.google.com/v3/signin/identifier"
-                    "?continue=https%3A%2F%2Fscholar.google.com%2Fcitations"
-                ),
-                body=blocked_fixture,
-                error=None,
-            )
-
-        async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
-            _ = scholar_id
-            return await self.fetch_profile_page_html(
-                "A1B2C3D4E5F6",
-                cstart=0,
-                pagesize=settings.ingestion_page_size,
-            )
-
-    app.dependency_overrides[get_scholar_source] = lambda: BlockedScholarSource()
-
-    previous_blocked_threshold = settings.ingestion_alert_blocked_failure_threshold
-    previous_blocked_cooldown_seconds = settings.ingestion_safety_cooldown_blocked_seconds
-    object.__setattr__(settings, "ingestion_alert_blocked_failure_threshold", 1)
-    object.__setattr__(settings, "ingestion_safety_cooldown_blocked_seconds", 600)
-
-    try:
-        with TestClient(app) as client:
-            login_user(client, email="api-runs-safety@example.com", password="api-password")
-            headers = _api_csrf_headers(client)
-
-            first_run_response = client.post(
-                "/api/v1/runs/manual",
-                headers={**headers, "Idempotency-Key": "safety-cooldown-run-1"},
-            )
-            assert first_run_response.status_code == 200
-            first_run_id = int(first_run_response.json()["data"]["run_id"])
-            await _wait_for_run_complete(client, first_run_id)
-
-            settings_response = client.get("/api/v1/settings")
-            assert settings_response.status_code == 200
-            safety_state = settings_response.json()["data"]["safety_state"]
-            _assert_safety_state_contract(safety_state)
-            assert safety_state["cooldown_active"] is True
-            assert safety_state["cooldown_reason"] == "blocked_failure_threshold_exceeded"
-            assert int(safety_state["cooldown_remaining_seconds"]) > 0
-            assert int(safety_state["counters"]["cooldown_entry_count"]) >= 1
-            assert int(safety_state["counters"]["last_blocked_failure_count"]) >= 1
-
-            blocked_start_response = client.post(
-                "/api/v1/runs/manual",
-                headers={**headers, "Idempotency-Key": "safety-cooldown-run-2"},
-            )
-            assert blocked_start_response.status_code == 429
-            blocked_payload = blocked_start_response.json()
-            assert blocked_payload["error"]["code"] == "scrape_cooldown_active"
-            blocked_state = blocked_payload["error"]["details"]["safety_state"]
-            _assert_safety_state_contract(blocked_state)
-            assert blocked_state["cooldown_active"] is True
-            assert blocked_state["cooldown_reason"] == "blocked_failure_threshold_exceeded"
-            assert int(blocked_state["counters"]["blocked_start_count"]) >= 1
-
-            runs_response = client.get("/api/v1/runs")
-            assert runs_response.status_code == 200
-            _assert_safety_state_contract(runs_response.json()["data"]["safety_state"])
-            assert runs_response.json()["data"]["safety_state"]["cooldown_active"] is True
-    finally:
-        object.__setattr__(settings, "ingestion_alert_blocked_failure_threshold", previous_blocked_threshold)
-        object.__setattr__(settings, "ingestion_safety_cooldown_blocked_seconds", previous_blocked_cooldown_seconds)
-        app.dependency_overrides.pop(get_scholar_source, None)
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_manual_run_enforces_network_failure_safety_cooldown(
-    db_session: AsyncSession,
-) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-runs-safety-network@example.com",
-        password="api-password",
-    )
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "NNN111NNN111",
-            "display_name": "Network Safety Probe",
-        },
-    )
-    await db_session.commit()
-
-    class NetworkFailureScholarSource:
-        async def fetch_profile_page_html(
-            self,
-            scholar_id: str,
-            *,
-            cstart: int,
-            pagesize: int,
-        ) -> FetchResult:
-            _ = (scholar_id, cstart, pagesize)
-            return FetchResult(
-                requested_url="https://scholar.google.com/citations?hl=en&user=NNN111NNN111",
-                status_code=None,
-                final_url=None,
-                body="",
-                error="timed out",
-            )
-
-        async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
-            _ = scholar_id
-            return await self.fetch_profile_page_html(
-                "NNN111NNN111",
-                cstart=0,
-                pagesize=settings.ingestion_page_size,
-            )
-
-    app.dependency_overrides[get_scholar_source] = lambda: NetworkFailureScholarSource()
-
-    previous_network_threshold = settings.ingestion_alert_network_failure_threshold
-    previous_network_cooldown_seconds = settings.ingestion_safety_cooldown_network_seconds
-    previous_network_retries = settings.ingestion_network_error_retries
-    previous_retry_backoff = settings.ingestion_retry_backoff_seconds
-    object.__setattr__(settings, "ingestion_alert_network_failure_threshold", 1)
-    object.__setattr__(settings, "ingestion_safety_cooldown_network_seconds", 600)
-    object.__setattr__(settings, "ingestion_network_error_retries", 0)
-    object.__setattr__(settings, "ingestion_retry_backoff_seconds", 0.0)
-
-    try:
-        with TestClient(app) as client:
-            login_user(client, email="api-runs-safety-network@example.com", password="api-password")
-            headers = _api_csrf_headers(client)
-
-            first_run_response = client.post(
-                "/api/v1/runs/manual",
-                headers={**headers, "Idempotency-Key": "safety-network-cooldown-run-1"},
-            )
-            assert first_run_response.status_code == 200
-            first_run_id = int(first_run_response.json()["data"]["run_id"])
-            await _wait_for_run_complete(client, first_run_id)
-
-            settings_response = client.get("/api/v1/settings")
-            assert settings_response.status_code == 200
-            safety_state = settings_response.json()["data"]["safety_state"]
-            _assert_safety_state_contract(safety_state)
-            assert safety_state["cooldown_active"] is True
-            assert safety_state["cooldown_reason"] == "network_failure_threshold_exceeded"
-            assert int(safety_state["cooldown_remaining_seconds"]) > 0
-            assert int(safety_state["counters"]["last_network_failure_count"]) >= 1
-
-            blocked_start_response = client.post(
-                "/api/v1/runs/manual",
-                headers={**headers, "Idempotency-Key": "safety-network-cooldown-run-2"},
-            )
-            assert blocked_start_response.status_code == 429
-            blocked_payload = blocked_start_response.json()
-            assert blocked_payload["error"]["code"] == "scrape_cooldown_active"
-            blocked_state = blocked_payload["error"]["details"]["safety_state"]
-            _assert_safety_state_contract(blocked_state)
-            assert blocked_state["cooldown_active"] is True
-            assert blocked_state["cooldown_reason"] == "network_failure_threshold_exceeded"
-            assert int(blocked_state["counters"]["blocked_start_count"]) >= 1
-    finally:
-        object.__setattr__(settings, "ingestion_alert_network_failure_threshold", previous_network_threshold)
-        object.__setattr__(settings, "ingestion_safety_cooldown_network_seconds", previous_network_cooldown_seconds)
-        object.__setattr__(settings, "ingestion_network_error_retries", previous_network_retries)
-        object.__setattr__(settings, "ingestion_retry_backoff_seconds", previous_retry_backoff)
-        app.dependency_overrides.pop(get_scholar_source, None)
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_settings_clears_expired_scrape_safety_cooldown(
-    db_session: AsyncSession,
-) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-settings-safety-expired@example.com",
-        password="api-password",
-    )
-    user_settings = await user_settings_service.get_or_create_settings(
-        db_session,
-        user_id=user_id,
-    )
-    user_settings.scrape_safety_state = {"blocked_start_count": 2}
-    user_settings.scrape_cooldown_reason = "blocked_failure_threshold_exceeded"
-    user_settings.scrape_cooldown_until = datetime.now(UTC) - timedelta(seconds=15)
-    await db_session.commit()
-
-    client = TestClient(app)
-    login_user(client, email="api-settings-safety-expired@example.com", password="api-password")
-
-    settings_response = client.get("/api/v1/settings")
-    assert settings_response.status_code == 200
-    settings_safety_state = settings_response.json()["data"]["safety_state"]
-    _assert_safety_state_contract(settings_safety_state)
-    assert settings_safety_state["cooldown_active"] is False
-    assert settings_safety_state["cooldown_reason"] is None
-    assert int(settings_safety_state["counters"]["blocked_start_count"]) == 2
-
-    runs_response = client.get("/api/v1/runs")
-    assert runs_response.status_code == 200
-    runs_safety_state = runs_response.json()["data"]["safety_state"]
-    _assert_safety_state_contract(runs_safety_state)
-    assert runs_safety_state["cooldown_active"] is False
-    assert runs_safety_state["cooldown_reason"] is None
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_publications_list_and_mark_read(db_session: AsyncSession) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-pubs@example.com",
-        password="api-password",
-    )
-
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "abcDEF123456",
-            "display_name": "Publication Owner",
-        },
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-
-    publication_a = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (
-                fingerprint_sha256,
-                title_raw,
-                title_normalized,
-                citation_count,
-                pdf_url
-            )
-            VALUES (:fingerprint, :title_raw, :title_normalized, 10, :pdf_url)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{user_id:064x}",
-            "title_raw": "Paper A",
-            "title_normalized": "paper a",
-            "pdf_url": "https://example.org/paper-a.pdf",
-        },
-    )
-    publication_a_id = int(publication_a.scalar_one())
-
-    publication_b = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 4)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 1):064x}",
-            "title_raw": "Paper B",
-            "title_normalized": "paper b",
-        },
-    )
-    publication_b_id = int(publication_b.scalar_one())
-
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
-            VALUES
-              (:scholar_profile_id, :publication_a_id, false),
-              (:scholar_profile_id, :publication_b_id, false)
-            """
-        ),
-        {
-            "scholar_profile_id": scholar_profile_id,
-            "publication_a_id": publication_a_id,
-            "publication_b_id": publication_b_id,
-        },
-    )
-    await db_session.commit()
-
-    client = TestClient(app)
-    login_user(client, email="api-pubs@example.com", password="api-password")
-    headers = _api_csrf_headers(client)
-
-    list_response = client.get("/api/v1/publications?mode=all")
-    assert list_response.status_code == 200
-    data = list_response.json()["data"]
-    assert data["mode"] == "all"
-    assert data["favorite_only"] is False
-    assert data["total_count"] == 2
-    assert data["unread_count"] == 2
-    assert data["favorites_count"] == 0
-    assert data["latest_count"] == 0
-    assert data["new_count"] == data["latest_count"]
-    assert data["page"] == 1
-    assert data["page_size"] == 100
-    assert data["has_prev"] is False
-    assert data["has_next"] is False
-    assert isinstance(data["publications"], list)
-    assert len(data["publications"]) == 2
-    assert all(bool(item["is_favorite"]) is False for item in data["publications"])
-    pdf_urls = {item["title"]: item["pdf_url"] for item in data["publications"]}
-    assert pdf_urls["Paper A"] == "https://example.org/paper-a.pdf"
-    assert pdf_urls["Paper B"] is None
-
-    latest_response = client.get("/api/v1/publications?mode=latest")
-    assert latest_response.status_code == 200
-    latest_data = latest_response.json()["data"]
-    assert latest_data["mode"] == "latest"
-    assert latest_data["latest_count"] == 0
-
-    unread_response = client.get("/api/v1/publications?mode=unread")
-    assert unread_response.status_code == 200
-    unread_data = unread_response.json()["data"]
-    assert unread_data["mode"] == "unread"
-    assert unread_data["unread_count"] == 2
-
-    alias_response = client.get("/api/v1/publications?mode=new")
-    assert alias_response.status_code == 200
-    alias_data = alias_response.json()["data"]
-    assert alias_data["mode"] == "latest"
-    assert alias_data["latest_count"] == latest_data["latest_count"]
-    assert alias_data["publications"] == latest_data["publications"]
-
-    mark_selected_response = client.post(
-        "/api/v1/publications/mark-read",
-        json={
-            "selections": [
-                {
-                    "scholar_profile_id": scholar_profile_id,
-                    "publication_id": publication_a_id,
-                }
-            ]
-        },
-        headers=headers,
-    )
-    assert mark_selected_response.status_code == 200
-    assert mark_selected_response.json()["data"]["requested_count"] == 1
-    assert mark_selected_response.json()["data"]["updated_count"] == 1
-
-    read_state = await db_session.execute(
-        text(
-            """
-            SELECT publication_id, is_read
-            FROM scholar_publications
-            WHERE scholar_profile_id = :scholar_profile_id
-            ORDER BY publication_id
-            """
-        ),
-        {"scholar_profile_id": scholar_profile_id},
-    )
-    states = {int(row[0]): bool(row[1]) for row in read_state.all()}
-    assert states[publication_a_id] is True
-    assert states[publication_b_id] is False
-
-    mark_response = client.post("/api/v1/publications/mark-all-read", headers=headers)
-    assert mark_response.status_code == 200
-    assert mark_response.json()["data"]["updated_count"] == 1
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_publications_list_supports_pagination(db_session: AsyncSession) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-pubs-paging@example.com",
-        password="api-password",
-    )
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "pagingScholar01",
-            "display_name": "Paging Scholar",
-        },
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-
-    publication_ids: list[int] = []
-    for index in range(3):
-        created = await db_session.execute(
-            text(
-                """
-                INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-                VALUES (:fingerprint, :title_raw, :title_normalized, 1)
-                RETURNING id
-                """
-            ),
-            {
-                "fingerprint": f"{(user_id + 500 + index):064x}",
-                "title_raw": f"Paged Paper {index}",
-                "title_normalized": f"paged paper {index}",
-            },
-        )
-        publication_ids.append(int(created.scalar_one()))
-
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
-            VALUES
-              (:scholar_profile_id, :publication_1, false, false),
-              (:scholar_profile_id, :publication_2, false, false),
-              (:scholar_profile_id, :publication_3, false, false)
-            """
-        ),
-        {
-            "scholar_profile_id": scholar_profile_id,
-            "publication_1": publication_ids[0],
-            "publication_2": publication_ids[1],
-            "publication_3": publication_ids[2],
-        },
-    )
-    await db_session.commit()
-
-    client = TestClient(app)
-    login_user(client, email="api-pubs-paging@example.com", password="api-password")
-
-    first_page = client.get("/api/v1/publications?mode=all&page=1&page_size=2")
-    assert first_page.status_code == 200
-    first_data = first_page.json()["data"]
-    assert first_data["total_count"] == 3
-    assert first_data["page"] == 1
-    assert first_data["page_size"] == 2
-    assert first_data["has_prev"] is False
-    assert first_data["has_next"] is True
-    assert len(first_data["publications"]) == 2
-
-    second_page = client.get("/api/v1/publications?mode=all&page=2&page_size=2")
-    assert second_page.status_code == 200
-    second_data = second_page.json()["data"]
-    assert second_data["total_count"] == 3
-    assert second_data["page"] == 2
-    assert second_data["page_size"] == 2
-    assert second_data["has_prev"] is True
-    assert second_data["has_next"] is False
-    assert len(second_data["publications"]) == 1
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_publications_search_pagination_uses_filtered_total_count(
-    db_session: AsyncSession,
-) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-pubs-search-page@example.com",
-        password="api-password",
-    )
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "searchPagingScholar01",
-            "display_name": "Search Paging Scholar",
-        },
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-    titles = ["Alpha Optimization", "Alpha Learning", "Beta Methods"]
-    publication_ids: list[int] = []
-    for index, title in enumerate(titles):
-        created = await db_session.execute(
-            text(
-                """
-                INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-                VALUES (:fingerprint, :title_raw, :title_normalized, 1)
-                RETURNING id
-                """
-            ),
-            {
-                "fingerprint": f"{(user_id + 900 + index):064x}",
-                "title_raw": title,
-                "title_normalized": title.lower(),
-            },
-        )
-        publication_ids.append(int(created.scalar_one()))
-    for publication_id in publication_ids:
-        await db_session.execute(
-            text(
-                """
-                INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
-                VALUES (:scholar_profile_id, :publication_id, false, false)
-                """
-            ),
-            {"scholar_profile_id": scholar_profile_id, "publication_id": publication_id},
-        )
-    await db_session.commit()
-
-    client = TestClient(app)
-    login_user(client, email="api-pubs-search-page@example.com", password="api-password")
-
-    response = client.get("/api/v1/publications?mode=all&page=1&page_size=2&search=alpha")
-    assert response.status_code == 200
-    data = response.json()["data"]
-    assert int(data["total_count"]) == 2
-    assert data["has_next"] is False
-    assert len(data["publications"]) == 2
-    assert all("alpha" in str(item["title"]).lower() for item in data["publications"])
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_publications_supports_sort_by_pdf_status(
-    db_session: AsyncSession,
-) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-pubs-pdf-sort@example.com",
-        password="api-password",
-    )
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "pdfSortScholar01",
-            "display_name": "PDF Sort Scholar",
-        },
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-
-    resolved_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count, pdf_url)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 1, :pdf_url)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 1300):064x}",
-            "title_raw": "Resolved PDF",
-            "title_normalized": "resolved pdf",
-            "pdf_url": "https://example.org/resolved.pdf",
-        },
-    )
-    resolved_publication_id = int(resolved_result.scalar_one())
-    queued_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 1)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 1301):064x}",
-            "title_raw": "Queued PDF",
-            "title_normalized": "queued pdf",
-        },
-    )
-    queued_publication_id = int(queued_result.scalar_one())
-    failed_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 1)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 1302):064x}",
-            "title_raw": "Failed PDF",
-            "title_normalized": "failed pdf",
-        },
-    )
-    failed_publication_id = int(failed_result.scalar_one())
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
-            VALUES
-              (:scholar_profile_id, :resolved_publication_id, false, false),
-              (:scholar_profile_id, :queued_publication_id, false, false),
-              (:scholar_profile_id, :failed_publication_id, false, false)
-            """
-        ),
-        {
-            "scholar_profile_id": scholar_profile_id,
-            "resolved_publication_id": resolved_publication_id,
-            "queued_publication_id": queued_publication_id,
-            "failed_publication_id": failed_publication_id,
-        },
-    )
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO publication_pdf_jobs (publication_id, status, attempt_count)
-            VALUES (:queued_publication_id, 'queued', 1),
-                   (:failed_publication_id, 'failed', 2)
-            """
-        ),
-        {
-            "queued_publication_id": queued_publication_id,
-            "failed_publication_id": failed_publication_id,
-        },
-    )
-    await db_session.commit()
-
-    client = TestClient(app)
-    login_user(client, email="api-pubs-pdf-sort@example.com", password="api-password")
-
-    response = client.get("/api/v1/publications?mode=all&sort_by=pdf_status&sort_dir=desc")
-    assert response.status_code == 200
-    publications = response.json()["data"]["publications"]
-    publication_ids = [int(item["publication_id"]) for item in publications]
-    assert publication_ids[0] == resolved_publication_id
-    assert publication_ids[-1] == failed_publication_id
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_publications_favorite_toggle_and_filter(db_session: AsyncSession) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-pubs-favorites@example.com",
-        password="api-password",
-    )
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "favoriteScholar01",
-            "display_name": "Favorite Scholar",
-        },
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-    publication_a_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 9)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 101):064x}",
-            "title_raw": "Favorite Target",
-            "title_normalized": "favorite target",
-        },
-    )
-    publication_a_id = int(publication_a_result.scalar_one())
-    publication_b_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 2)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 102):064x}",
-            "title_raw": "Not Favorite",
-            "title_normalized": "not favorite",
-        },
-    )
-    publication_b_id = int(publication_b_result.scalar_one())
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read, is_favorite)
-            VALUES
-              (:scholar_profile_id, :publication_a_id, false, false),
-              (:scholar_profile_id, :publication_b_id, false, false)
-            """
-        ),
-        {
-            "scholar_profile_id": scholar_profile_id,
-            "publication_a_id": publication_a_id,
-            "publication_b_id": publication_b_id,
-        },
-    )
-    await db_session.commit()
-
-    client = TestClient(app)
-    login_user(client, email="api-pubs-favorites@example.com", password="api-password")
-    headers = _api_csrf_headers(client)
-
-    set_response = client.post(
-        f"/api/v1/publications/{publication_a_id}/favorite",
-        json={"scholar_profile_id": scholar_profile_id, "is_favorite": True},
-        headers=headers,
-    )
-    assert set_response.status_code == 200
-    set_data = set_response.json()["data"]
-    assert set_data["publication"]["publication_id"] == publication_a_id
-    assert set_data["publication"]["is_favorite"] is True
-
-    favorite_only_response = client.get("/api/v1/publications?mode=all&favorite_only=true")
-    assert favorite_only_response.status_code == 200
-    favorite_only_data = favorite_only_response.json()["data"]
-    assert favorite_only_data["favorite_only"] is True
-    assert favorite_only_data["favorites_count"] == 1
-    assert favorite_only_data["total_count"] == 1
-    assert len(favorite_only_data["publications"]) == 1
-    assert int(favorite_only_data["publications"][0]["publication_id"]) == publication_a_id
-
-    clear_response = client.post(
-        f"/api/v1/publications/{publication_a_id}/favorite",
-        json={"scholar_profile_id": scholar_profile_id, "is_favorite": False},
-        headers=headers,
-    )
-    assert clear_response.status_code == 200
-    clear_data = clear_response.json()["data"]
-    assert clear_data["publication"]["publication_id"] == publication_a_id
-    assert clear_data["publication"]["is_favorite"] is False
-
-    favorite_only_after_clear_response = client.get("/api/v1/publications?mode=all&favorite_only=true")
-    assert favorite_only_after_clear_response.status_code == 200
-    favorite_only_after_clear_data = favorite_only_after_clear_response.json()["data"]
-    assert favorite_only_after_clear_data["favorites_count"] == 0
-    assert favorite_only_after_clear_data["total_count"] == 0
-    assert favorite_only_after_clear_data["publications"] == []
-
-    favorite_state_result = await db_session.execute(
-        text(
-            """
-            SELECT is_favorite
-            FROM scholar_publications
-            WHERE scholar_profile_id = :scholar_profile_id
-              AND publication_id = :publication_id
-            """
-        ),
-        {
-            "scholar_profile_id": scholar_profile_id,
-            "publication_id": publication_a_id,
-        },
-    )
-    assert bool(favorite_state_result.scalar_one()) is False
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_publications_list_schedules_background_enrichment(
-    db_session: AsyncSession,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-pubs-bg@example.com",
-        password="api-password",
-    )
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "background111",
-            "display_name": "Background Scholar",
-        },
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-    publication_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 3)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 17):064x}",
-            "title_raw": "Background Target",
-            "title_normalized": "background target",
-        },
-    )
-    publication_id = int(publication_result.scalar_one())
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
-            VALUES (:scholar_profile_id, :publication_id, false)
-            """
-        ),
-        {
-            "scholar_profile_id": scholar_profile_id,
-            "publication_id": publication_id,
-        },
-    )
-    await db_session.commit()
-
-    async def _fake_schedule(db_session, *, user_id: int, request_email: str | None, items, max_items: int):
-        assert db_session is not None
-        assert user_id > 0
-        assert request_email == "api-pubs-bg@example.com"
-        assert int(max_items) > 0
-        assert any(int(item.publication_id) == publication_id for item in items)
-        return 1
-
-    monkeypatch.setattr(
-        "app.services.publications.application.schedule_missing_pdf_enrichment_for_user",
-        _fake_schedule,
-    )
-
-    client = TestClient(app)
-    login_user(client, email="api-pubs-bg@example.com", password="api-password")
-
-    response = client.get("/api/v1/publications?mode=all")
-    assert response.status_code == 200
-    data = response.json()["data"]
-    assert len(data["publications"]) == 1
-    assert int(data["publications"][0]["publication_id"]) == publication_id
-    assert data["publications"][0]["pdf_url"] is None
-    assert data["publications"][0]["pdf_status"] in {"untracked", "queued", "running", "failed"}
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_publication_retry_pdf_queues_resolution_job(
-    db_session: AsyncSession,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-pubs-retry@example.com",
-        password="api-password",
-    )
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "retryScholar01",
-            "display_name": "Retry Scholar",
-        },
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-    publication_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 7)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 9):064x}",
-            "title_raw": "Retry Target",
-            "title_normalized": "retry target",
-        },
-    )
-    publication_id = int(publication_result.scalar_one())
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_publications (scholar_profile_id, publication_id, is_read)
-            VALUES (:scholar_profile_id, :publication_id, false)
-            """
-        ),
-        {
-            "scholar_profile_id": scholar_profile_id,
-            "publication_id": publication_id,
-        },
-    )
-    await db_session.commit()
-
-    async def _fake_retry_scheduler(db_session, *, user_id: int, request_email: str | None, item: PublicationListItem):
-        assert db_session is not None
-        assert user_id > 0
-        assert request_email == "api-pubs-retry@example.com"
-        assert int(item.publication_id) == publication_id
-        return True
-
-    monkeypatch.setattr(
-        "app.services.publications.application.schedule_retry_pdf_enrichment_for_row",
-        _fake_retry_scheduler,
-    )
-
-    async def _fake_hydrate(db_session, *, items: list[PublicationListItem]):
-        assert db_session is not None
-        assert len(items) == 1
-        item = items[0]
-        return [
-            PublicationListItem(
-                publication_id=item.publication_id,
-                scholar_profile_id=item.scholar_profile_id,
-                scholar_label=item.scholar_label,
-                title=item.title,
-                year=item.year,
-                citation_count=item.citation_count,
-                venue_text=item.venue_text,
-                pub_url=item.pub_url,
-                pdf_url=item.pdf_url,
-                is_read=item.is_read,
-                first_seen_at=item.first_seen_at,
-                is_new_in_latest_run=item.is_new_in_latest_run,
-                pdf_status="queued",
-                pdf_attempt_count=1,
-                pdf_failure_reason="no_pdf_found",
-                pdf_failure_detail="no_pdf_found",
-            )
-        ]
-
-    monkeypatch.setattr(
-        "app.services.publications.application.hydrate_pdf_enrichment_state",
-        _fake_hydrate,
-    )
-
-    client = TestClient(app)
-    login_user(client, email="api-pubs-retry@example.com", password="api-password")
-    headers = _api_csrf_headers(client)
-
-    response = client.post(
-        f"/api/v1/publications/{publication_id}/retry-pdf",
-        json={"scholar_profile_id": scholar_profile_id},
-        headers=headers,
-    )
-    assert response.status_code == 200
-    payload = response.json()["data"]
-    assert payload["queued"] is True
-    assert payload["resolved_pdf"] is False
-    assert payload["publication"]["publication_id"] == publication_id
-    assert payload["publication"]["pdf_url"] is None
-    assert payload["publication"]["pdf_status"] == "queued"
-    assert payload["publication"]["pdf_attempt_count"] == 1
-    assert payload["publication"]["pdf_failure_reason"] == "no_pdf_found"
-
-    stored = await db_session.execute(
-        text("SELECT pdf_url FROM publications WHERE id = :publication_id"),
-        {"publication_id": publication_id},
-    )
-    stored_pdf_url = stored.scalar_one()
-    assert stored_pdf_url is None
-
-
-@pytest.mark.integration
-@pytest.mark.db
-@pytest.mark.asyncio
-async def test_api_publications_unread_and_latest_modes_can_diverge(
-    db_session: AsyncSession,
-) -> None:
-    user_id = await insert_user(
-        db_session,
-        email="api-pubs-mismatch@example.com",
-        password="api-password",
-    )
-    scholar_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_profiles (user_id, scholar_id, display_name, is_enabled)
-            VALUES (:user_id, :scholar_id, :display_name, true)
-            RETURNING id
-            """
-        ),
-        {
-            "user_id": user_id,
-            "scholar_id": "mismatchScholar01",
-            "display_name": "Mismatch Scholar",
-        },
-    )
-    scholar_profile_id = int(scholar_result.scalar_one())
-
-    older_run_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO crawl_runs (user_id, trigger_type, status, scholar_count, new_pub_count)
-            VALUES (:user_id, 'manual', 'success', 1, 1)
-            RETURNING id
-            """
-        ),
-        {"user_id": user_id},
-    )
-    older_run_id = int(older_run_result.scalar_one())
-
-    latest_run_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO crawl_runs (user_id, trigger_type, status, scholar_count, new_pub_count)
-            VALUES (:user_id, 'scheduled', 'success', 1, 0)
-            RETURNING id
-            """
-        ),
-        {"user_id": user_id},
-    )
-    latest_run_id = int(latest_run_result.scalar_one())
-    assert latest_run_id > older_run_id
-
-    publication_result = await db_session.execute(
-        text(
-            """
-            INSERT INTO publications (fingerprint_sha256, title_raw, title_normalized, citation_count)
-            VALUES (:fingerprint, :title_raw, :title_normalized, 12)
-            RETURNING id
-            """
-        ),
-        {
-            "fingerprint": f"{(user_id + 99):064x}",
-            "title_raw": "Unread But Not Latest",
-            "title_normalized": "unread but not latest",
-        },
-    )
-    publication_id = int(publication_result.scalar_one())
-
-    await db_session.execute(
-        text(
-            """
-            INSERT INTO scholar_publications (
-                scholar_profile_id,
-                publication_id,
-                is_read,
-                first_seen_run_id
-            )
-            VALUES (:scholar_profile_id, :publication_id, false, :first_seen_run_id)
-            """
-        ),
-        {
-            "scholar_profile_id": scholar_profile_id,
-            "publication_id": publication_id,
-            "first_seen_run_id": older_run_id,
-        },
-    )
-    await db_session.commit()
-
-    client = TestClient(app)
-    login_user(client, email="api-pubs-mismatch@example.com", password="api-password")
-
-    unread_response = client.get("/api/v1/publications?mode=unread")
-    assert unread_response.status_code == 200
-    unread_data = unread_response.json()["data"]
-    assert unread_data["mode"] == "unread"
-    assert unread_data["unread_count"] == 1
-    assert unread_data["latest_count"] == 0
-    assert unread_data["new_count"] == 0
-    assert len(unread_data["publications"]) == 1
-    assert int(unread_data["publications"][0]["publication_id"]) == publication_id
-    assert unread_data["publications"][0]["is_new_in_latest_run"] is False
-
-    latest_response = client.get("/api/v1/publications?mode=latest")
-    assert latest_response.status_code == 200
-    latest_data = latest_response.json()["data"]
-    assert latest_data["mode"] == "latest"
-    assert latest_data["latest_count"] == 0
-    assert len(latest_data["publications"]) == 0
-
-    alias_response = client.get("/api/v1/publications?mode=new")
-    assert alias_response.status_code == 200
-    alias_data = alias_response.json()["data"]
-    assert alias_data["mode"] == "latest"
-    assert alias_data["latest_count"] == latest_data["latest_count"]
-    assert alias_data["publications"] == latest_data["publications"]
diff --git a/tests/integration/test_fixture_probe_runs.py b/tests/integration/test_fixture_probe_runs.py
index 49f72f0..feeb602 100644
--- a/tests/integration/test_fixture_probe_runs.py
+++ b/tests/integration/test_fixture_probe_runs.py
@@ -95,7 +95,7 @@ async def test_fixture_probe_run_emits_failure_and_retry_summary_metrics(
         "retry": "RSTUVWX12345",
     }
 
-    for label in ("ok", "blocked", "retry"):
+    for label in ("ok", "retry", "blocked"):
         await db_session.execute(
             text(
                 """
diff --git a/tests/integration/test_run_lifecycle_consistency.py b/tests/integration/test_run_lifecycle_consistency.py
index f8239e4..6009cf3 100644
--- a/tests/integration/test_run_lifecycle_consistency.py
+++ b/tests/integration/test_run_lifecycle_consistency.py
@@ -13,9 +13,29 @@ from app.api.runtime_deps import get_ingestion_service
 from app.db.models import CrawlRun, Publication, RunStatus, RunTriggerType
 from app.main import app
 from app.services.ingestion.application import ScholarIngestionService
+from app.services.ingestion.run_enrichment import background_enrich
+from app.services.scholar.source import FetchResult
 from tests.integration.helpers import insert_user, login_user
 
 
+class _PassthroughSource:
+    """Minimal source that passes preflight without making real requests."""
+
+    async def fetch_profile_html(self, scholar_id: str) -> FetchResult:
+        return FetchResult(
+            requested_url=f"https://scholar.google.com/citations?user={scholar_id}",
+            status_code=200,
+            final_url=f"https://scholar.google.com/citations?user={scholar_id}",
+            body="<html></html>",
+            error=None,
+        )
+
+    async def fetch_profile_page_html(
+        self, scholar_id: str, *, cstart: int, pagesize: int
+    ) -> FetchResult:
+        return await self.fetch_profile_html(scholar_id)
+
+
 def _csrf_headers(client: TestClient) -> dict[str, str]:
     response = client.get("/api/v1/auth/me")
     assert response.status_code == 200
@@ -81,7 +101,7 @@ async def test_api_manual_run_conflicts_when_an_active_run_exists(
     )
     await db_session.commit()
 
-    service = ScholarIngestionService(source=object())
+    service = ScholarIngestionService(source=_PassthroughSource())
 
     async def _stall_execute_run(**_kwargs: Any) -> None:
         await asyncio.sleep(0.4)
@@ -218,9 +238,12 @@ async def test_background_enrichment_preserves_canceled_status(
         _OpenAlexClientStub,
     )
 
-    service = ScholarIngestionService(source=object())
-    await service._background_enrich(
+    from app.services.ingestion.enrichment import EnrichmentRunner
+
+    enrichment_runner = EnrichmentRunner()
+    await background_enrich(
         session_factory,
+        enrichment_runner,
         run_id=int(run.id),
         intended_final_status=RunStatus.SUCCESS,
     )
diff --git a/tests/unit/test_logging_policy.py b/tests/unit/test_logging_policy.py
new file mode 100644
index 0000000..c0fec71
--- /dev/null
+++ b/tests/unit/test_logging_policy.py
@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+RAW_LOG_METHODS = {
+    "debug",
+    "info",
+    "warning",
+    "error",
+    "exception",
+    "critical",
+}
+APP_DIR = Path(__file__).resolve().parents[2] / "app"
+
+
+def _raw_logger_calls(path: Path) -> list[tuple[int, str]]:
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    violations: list[tuple[int, str]] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+        if not isinstance(func, ast.Attribute):
+            continue
+        if not isinstance(func.value, ast.Name) or func.value.id != "logger":
+            continue
+        if func.attr not in RAW_LOG_METHODS:
+            continue
+        violations.append((int(node.lineno), func.attr))
+    return violations
+
+
+def test_app_runtime_uses_structured_log_only() -> None:
+    violations: list[str] = []
+    for path in sorted(APP_DIR.rglob("*.py")):
+        for line_number, method in _raw_logger_calls(path):
+            relative_path = path.relative_to(APP_DIR.parent)
+            violations.append(f"{relative_path}:{line_number} logger.{method}()")
+    assert not violations, "raw logger calls found:\n" + "\n".join(violations)
diff --git a/tests/unit/test_portability_import.py b/tests/unit/test_portability_import.py
new file mode 100644
index 0000000..6ffd3e4
--- /dev/null
+++ b/tests/unit/test_portability_import.py
@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from app.services.portability.publication_import import (
+    _build_imported_publication_input,
+    _initialize_import_counters,
+    _update_link_counters,
+)
+
+
+def _mock_profile(scholar_id: str = "ABC123DEF456") -> MagicMock:
+    profile = MagicMock()
+    profile.id = 1
+    profile.scholar_id = scholar_id
+    return profile
+
+
+def _scholar_map(scholar_id: str = "ABC123DEF456") -> dict[str, MagicMock]:
+    return {scholar_id: _mock_profile(scholar_id)}
+
+
+class TestBuildImportedPublicationInput:
+    def test_returns_parsed_input_for_valid_item(self) -> None:
+        item = {
+            "scholar_id": "ABC123DEF456",
+            "title": "Deep Learning",
+            "year": 2024,
+            "author_text": "Smith, J",
+            "venue_text": "ICML",
+            "citation_count": 10,
+        }
+        result = _build_imported_publication_input(item=item, scholar_map=_scholar_map())
+        assert result is not None
+        assert result.title == "Deep Learning"
+        assert result.year == 2024
+        assert result.citation_count == 10
+        assert result.author_text == "Smith, J"
+
+    def test_returns_none_when_title_missing(self) -> None:
+        item = {"scholar_id": "ABC123DEF456"}
+        result = _build_imported_publication_input(item=item, scholar_map=_scholar_map())
+        assert result is None
+
+    def test_returns_none_when_scholar_id_missing(self) -> None:
+        item = {"title": "Test Title"}
+        result = _build_imported_publication_input(item=item, scholar_map=_scholar_map())
+        assert result is None
+
+    def test_returns_none_when_scholar_not_in_map(self) -> None:
+        item = {"scholar_id": "UNKNOWN12345", "title": "Test Title"}
+        result = _build_imported_publication_input(item=item, scholar_map=_scholar_map())
+        assert result is None
+
+    def test_defaults_is_read_to_false(self) -> None:
+        item = {"scholar_id": "ABC123DEF456", "title": "Test Title"}
+        result = _build_imported_publication_input(item=item, scholar_map=_scholar_map())
+        assert result is not None
+        assert result.is_read is False
+
+    def test_respects_is_read_true(self) -> None:
+        item = {"scholar_id": "ABC123DEF456", "title": "Test Title", "is_read": True}
+        result = _build_imported_publication_input(item=item, scholar_map=_scholar_map())
+        assert result is not None
+        assert result.is_read is True
+
+    def test_normalizes_year(self) -> None:
+        item = {"scholar_id": "ABC123DEF456", "title": "Test Title", "year": "invalid"}
+        result = _build_imported_publication_input(item=item, scholar_map=_scholar_map())
+        assert result is not None
+        assert result.year is None
+
+    def test_normalizes_citation_count(self) -> None:
+        item = {"scholar_id": "ABC123DEF456", "title": "Test Title", "citation_count": "not_a_number"}
+        result = _build_imported_publication_input(item=item, scholar_map=_scholar_map())
+        assert result is not None
+        assert result.citation_count == 0
+
+    def test_computes_fingerprint_when_not_provided(self) -> None:
+        item = {"scholar_id": "ABC123DEF456", "title": "Test Title"}
+        result = _build_imported_publication_input(item=item, scholar_map=_scholar_map())
+        assert result is not None
+        assert len(result.fingerprint) == 64
+
+    def test_uses_provided_valid_fingerprint(self) -> None:
+        valid_sha = "b" * 64
+        item = {"scholar_id": "ABC123DEF456", "title": "Test Title", "fingerprint_sha256": valid_sha}
+        result = _build_imported_publication_input(item=item, scholar_map=_scholar_map())
+        assert result is not None
+        assert result.fingerprint == valid_sha
+
+
+class TestInitializeImportCounters:
+    def test_adds_publication_and_link_keys(self) -> None:
+        counters: dict[str, int] = {"existing_key": 5}
+        _initialize_import_counters(counters)
+        assert counters["publications_created"] == 0
+        assert counters["publications_updated"] == 0
+        assert counters["links_created"] == 0
+        assert counters["links_updated"] == 0
+        assert counters["existing_key"] == 5
+
+
+class TestUpdateLinkCounters:
+    def test_increments_created(self) -> None:
+        counters = {"links_created": 0, "links_updated": 0}
+        _update_link_counters(counters=counters, link_created=True, link_updated=False)
+        assert counters["links_created"] == 1
+        assert counters["links_updated"] == 0
+
+    def test_increments_updated(self) -> None:
+        counters = {"links_created": 0, "links_updated": 0}
+        _update_link_counters(counters=counters, link_created=False, link_updated=True)
+        assert counters["links_created"] == 0
+        assert counters["links_updated"] == 1
+
+    def test_no_change_when_both_false(self) -> None:
+        counters = {"links_created": 0, "links_updated": 0}
+        _update_link_counters(counters=counters, link_created=False, link_updated=False)
+        assert counters["links_created"] == 0
+        assert counters["links_updated"] == 0
diff --git a/tests/unit/test_portability_normalize.py b/tests/unit/test_portability_normalize.py
new file mode 100644
index 0000000..7d7e439
--- /dev/null
+++ b/tests/unit/test_portability_normalize.py
@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import pytest
+
+from app.services.portability.constants import MAX_IMPORT_PUBLICATIONS, MAX_IMPORT_SCHOLARS
+from app.services.portability.normalize import (
+    _build_fingerprint,
+    _first_author_last_name,
+    _first_venue_word,
+    _normalize_citation_count,
+    _normalize_optional_text,
+    _normalize_optional_year,
+    _resolve_fingerprint,
+    _validate_import_sizes,
+)
+from app.services.portability.types import ImportExportError
+
+
+class TestNormalizeOptionalText:
+    def test_returns_stripped_string(self) -> None:
+        assert _normalize_optional_text("  hello  ") == "hello"
+
+    def test_returns_none_for_none(self) -> None:
+        assert _normalize_optional_text(None) is None
+
+    def test_returns_none_for_empty_string(self) -> None:
+        assert _normalize_optional_text("") is None
+
+    def test_returns_none_for_whitespace_only(self) -> None:
+        assert _normalize_optional_text("   ") is None
+
+    def test_coerces_non_string_to_string(self) -> None:
+        assert _normalize_optional_text(42) == "42"
+
+
+class TestNormalizeOptionalYear:
+    def test_valid_year(self) -> None:
+        assert _normalize_optional_year(2024) == 2024
+
+    def test_string_year(self) -> None:
+        assert _normalize_optional_year("1999") == 1999
+
+    def test_returns_none_for_none(self) -> None:
+        assert _normalize_optional_year(None) is None
+
+    def test_returns_none_for_non_numeric(self) -> None:
+        assert _normalize_optional_year("abc") is None
+
+    def test_returns_none_for_year_below_1500(self) -> None:
+        assert _normalize_optional_year(1499) is None
+
+    def test_returns_none_for_year_above_3000(self) -> None:
+        assert _normalize_optional_year(3001) is None
+
+    def test_boundary_1500_accepted(self) -> None:
+        assert _normalize_optional_year(1500) == 1500
+
+    def test_boundary_3000_accepted(self) -> None:
+        assert _normalize_optional_year(3000) == 3000
+
+
+class TestNormalizeCitationCount:
+    def test_valid_positive(self) -> None:
+        assert _normalize_citation_count(10) == 10
+
+    def test_zero(self) -> None:
+        assert _normalize_citation_count(0) == 0
+
+    def test_negative_clamped_to_zero(self) -> None:
+        assert _normalize_citation_count(-5) == 0
+
+    def test_string_number(self) -> None:
+        assert _normalize_citation_count("42") == 42
+
+    def test_none_returns_zero(self) -> None:
+        assert _normalize_citation_count(None) == 0
+
+    def test_invalid_string_returns_zero(self) -> None:
+        assert _normalize_citation_count("abc") == 0
+
+
+class TestFirstAuthorLastName:
+    def test_single_author(self) -> None:
+        assert _first_author_last_name("John Smith") == "smith"
+
+    def test_multiple_authors(self) -> None:
+        assert _first_author_last_name("Jane Doe, John Smith") == "doe"
+
+    def test_empty_string(self) -> None:
+        assert _first_author_last_name("") == ""
+
+    def test_none(self) -> None:
+        assert _first_author_last_name(None) == ""
+
+
+class TestFirstVenueWord:
+    def test_returns_first_word(self) -> None:
+        assert _first_venue_word("Nature Communications") == "nature"
+
+    def test_empty_string(self) -> None:
+        assert _first_venue_word("") == ""
+
+    def test_none(self) -> None:
+        assert _first_venue_word(None) == ""
+
+
+class TestBuildFingerprint:
+    def test_produces_64_hex_digest(self) -> None:
+        fp = _build_fingerprint(title="Test Title", year=2024, author_text="Smith", venue_text="ICML")
+        assert len(fp) == 64
+        assert all(c in "0123456789abcdef" for c in fp)
+
+    def test_deterministic(self) -> None:
+        kwargs = {"title": "Test Title", "year": 2024, "author_text": "Smith", "venue_text": "ICML"}
+        assert _build_fingerprint(**kwargs) == _build_fingerprint(**kwargs)
+
+    def test_different_titles_produce_different_fingerprints(self) -> None:
+        fp1 = _build_fingerprint(title="Title A", year=2024, author_text=None, venue_text=None)
+        fp2 = _build_fingerprint(title="Title B", year=2024, author_text=None, venue_text=None)
+        assert fp1 != fp2
+
+    def test_none_year_handled(self) -> None:
+        fp = _build_fingerprint(title="Test", year=None, author_text=None, venue_text=None)
+        assert len(fp) == 64
+
+
+class TestResolveFingerprint:
+    def test_uses_provided_valid_sha256(self) -> None:
+        valid_sha = "a" * 64
+        result = _resolve_fingerprint(
+            title="Test",
+            year=2024,
+            author_text=None,
+            venue_text=None,
+            provided_fingerprint=valid_sha,
+        )
+        assert result == valid_sha
+
+    def test_computes_fingerprint_when_provided_is_none(self) -> None:
+        result = _resolve_fingerprint(
+            title="Test",
+            year=2024,
+            author_text=None,
+            venue_text=None,
+            provided_fingerprint=None,
+        )
+        assert len(result) == 64
+
+    def test_computes_fingerprint_when_provided_is_invalid(self) -> None:
+        result = _resolve_fingerprint(
+            title="Test",
+            year=2024,
+            author_text=None,
+            venue_text=None,
+            provided_fingerprint="not-a-sha",
+        )
+        assert len(result) == 64
+
+    def test_normalizes_provided_to_lowercase(self) -> None:
+        valid_sha = "A" * 64
+        result = _resolve_fingerprint(
+            title="Test",
+            year=2024,
+            author_text=None,
+            venue_text=None,
+            provided_fingerprint=valid_sha,
+        )
+        assert result == "a" * 64
+
+
+class TestValidateImportSizes:
+    def test_accepts_within_limits(self) -> None:
+        _validate_import_sizes(scholars=[{}], publications=[{}])
+
+    def test_rejects_too_many_scholars(self) -> None:
+        with pytest.raises(ImportExportError, match="max scholars"):
+            _validate_import_sizes(
+                scholars=[{}] * (MAX_IMPORT_SCHOLARS + 1),
+                publications=[],
+            )
+
+    def test_rejects_too_many_publications(self) -> None:
+        with pytest.raises(ImportExportError, match="max publications"):
+            _validate_import_sizes(
+                scholars=[],
+                publications=[{}] * (MAX_IMPORT_PUBLICATIONS + 1),
+            )
+
+    def test_accepts_exact_limit(self) -> None:
+        _validate_import_sizes(
+            scholars=[{}] * MAX_IMPORT_SCHOLARS,
+            publications=[{}] * MAX_IMPORT_PUBLICATIONS,
+        )
diff --git a/tests/unit/test_scholar_validators.py b/tests/unit/test_scholar_validators.py
new file mode 100644
index 0000000..460b315
--- /dev/null
+++ b/tests/unit/test_scholar_validators.py
@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import os
+import tempfile
+
+import pytest
+
+from app.services.scholars.constants import MAX_IMAGE_URL_LENGTH
+from app.services.scholars.exceptions import ScholarServiceError
+from app.services.scholars.uploads import (
+    _ensure_upload_root,
+    _resolve_upload_path,
+    _safe_remove_upload,
+    resolve_upload_file_path,
+)
+from app.services.scholars.validators import (
+    normalize_display_name,
+    normalize_profile_image_url,
+    validate_scholar_id,
+)
+
+
+class TestValidateScholarId:
+    def test_valid_12_char_id(self) -> None:
+        assert validate_scholar_id("ABCDEF123456") == "ABCDEF123456"
+
+    def test_valid_with_hyphens_and_underscores(self) -> None:
+        assert validate_scholar_id("AB-CD_EF1234") == "AB-CD_EF1234"
+
+    def test_strips_whitespace(self) -> None:
+        assert validate_scholar_id("  ABCDEF123456  ") == "ABCDEF123456"
+
+    def test_rejects_too_short(self) -> None:
+        with pytest.raises(ScholarServiceError, match="12"):
+            validate_scholar_id("ABC123")
+
+    def test_rejects_too_long(self) -> None:
+        with pytest.raises(ScholarServiceError, match="12"):
+            validate_scholar_id("ABCDEF1234567")
+
+    def test_rejects_special_characters(self) -> None:
+        with pytest.raises(ScholarServiceError, match="12"):
+            validate_scholar_id("ABCDEF12345!")
+
+
+class TestNormalizeDisplayName:
+    def test_returns_stripped_name(self) -> None:
+        assert normalize_display_name("  John Doe  ") == "John Doe"
+
+    def test_returns_none_for_empty(self) -> None:
+        assert normalize_display_name("") is None
+
+    def test_returns_none_for_whitespace_only(self) -> None:
+        assert normalize_display_name("   ") is None
+
+    def test_preserves_non_empty(self) -> None:
+        assert normalize_display_name("A") == "A"
+
+
+class TestNormalizeProfileImageUrl:
+    def test_valid_https_url(self) -> None:
+        assert normalize_profile_image_url("https://example.com/img.png") == "https://example.com/img.png"
+
+    def test_valid_http_url(self) -> None:
+        assert normalize_profile_image_url("http://example.com/img.png") == "http://example.com/img.png"
+
+    def test_returns_none_for_none(self) -> None:
+        assert normalize_profile_image_url(None) is None
+
+    def test_returns_none_for_empty(self) -> None:
+        assert normalize_profile_image_url("") is None
+
+    def test_returns_none_for_whitespace(self) -> None:
+        assert normalize_profile_image_url("   ") is None
+
+    def test_rejects_ftp_scheme(self) -> None:
+        with pytest.raises(ScholarServiceError, match="http"):
+            normalize_profile_image_url("ftp://example.com/img.png")
+
+    def test_rejects_no_scheme(self) -> None:
+        with pytest.raises(ScholarServiceError, match="http"):
+            normalize_profile_image_url("example.com/img.png")
+
+    def test_rejects_url_too_long(self) -> None:
+        long_url = "https://example.com/" + "a" * MAX_IMAGE_URL_LENGTH
+        with pytest.raises(ScholarServiceError, match="characters or fewer"):
+            normalize_profile_image_url(long_url)
+
+    def test_accepts_url_at_max_length(self) -> None:
+        url = "https://example.com/" + "a" * (MAX_IMAGE_URL_LENGTH - len("https://example.com/"))
+        assert len(url) == MAX_IMAGE_URL_LENGTH
+        assert normalize_profile_image_url(url) == url
+
+
+class TestUploadPathSafety:
+    def test_resolve_upload_path_rejects_traversal(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = _ensure_upload_root(tmpdir, create=False)
+            with pytest.raises(ScholarServiceError, match="Invalid"):
+                _resolve_upload_path(root, "../../../etc/passwd")
+
+    def test_resolve_upload_path_accepts_valid_relative(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = _ensure_upload_root(tmpdir, create=False)
+            result = _resolve_upload_path(root, "scholar_img.png")
+            assert result.name == "scholar_img.png"
+            assert root in result.parents or root == result.parent
+
+    def test_ensure_upload_root_creates_directory(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            new_dir = os.path.join(tmpdir, "uploads", "images")
+            root = _ensure_upload_root(new_dir, create=True)
+            assert root.exists()
+
+    def test_safe_remove_upload_removes_existing_file(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = _ensure_upload_root(tmpdir, create=False)
+            test_file = root / "test.png"
+            test_file.write_bytes(b"fake image")
+            assert test_file.exists()
+            _safe_remove_upload(root, "test.png")
+            assert not test_file.exists()
+
+    def test_safe_remove_upload_ignores_missing_file(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = _ensure_upload_root(tmpdir, create=False)
+            _safe_remove_upload(root, "nonexistent.png")
+
+    def test_safe_remove_upload_ignores_none(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = _ensure_upload_root(tmpdir, create=False)
+            _safe_remove_upload(root, None)
+
+    def test_safe_remove_upload_ignores_traversal_path(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = _ensure_upload_root(tmpdir, create=False)
+            _safe_remove_upload(root, "../../../etc/passwd")
+
+    def test_resolve_upload_file_path(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            result = resolve_upload_file_path(upload_dir=tmpdir, relative_path="img.png")
+            assert result.name == "img.png"
diff --git a/tests/unit/test_user_validation.py b/tests/unit/test_user_validation.py
new file mode 100644
index 0000000..dddc7f4
--- /dev/null
+++ b/tests/unit/test_user_validation.py
@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import pytest
+
+from app.services.users.application import (
+    UserServiceError,
+    normalize_email,
+    validate_email,
+    validate_password,
+)
+
+
+class TestNormalizeEmail:
+    def test_lowercases_and_strips(self) -> None:
+        assert normalize_email("  Alice@Example.COM  ") == "alice@example.com"
+
+    def test_already_normalized(self) -> None:
+        assert normalize_email("user@example.com") == "user@example.com"
+
+
+class TestValidateEmail:
+    def test_valid_email(self) -> None:
+        assert validate_email("user@example.com") == "user@example.com"
+
+    def test_strips_and_lowercases(self) -> None:
+        assert validate_email("  User@Example.COM  ") == "user@example.com"
+
+    def test_rejects_missing_at(self) -> None:
+        with pytest.raises(UserServiceError, match="valid email"):
+            validate_email("userexample.com")
+
+    def test_rejects_missing_domain(self) -> None:
+        with pytest.raises(UserServiceError, match="valid email"):
+            validate_email("user@")
+
+    def test_rejects_missing_tld(self) -> None:
+        with pytest.raises(UserServiceError, match="valid email"):
+            validate_email("user@example")
+
+    def test_rejects_empty_string(self) -> None:
+        with pytest.raises(UserServiceError, match="valid email"):
+            validate_email("")
+
+    def test_rejects_whitespace_only(self) -> None:
+        with pytest.raises(UserServiceError, match="valid email"):
+            validate_email("   ")
+
+    def test_rejects_spaces_in_local_part(self) -> None:
+        with pytest.raises(UserServiceError, match="valid email"):
+            validate_email("us er@example.com")
+
+    def test_accepts_plus_addressing(self) -> None:
+        assert validate_email("user+tag@example.com") == "user+tag@example.com"
+
+    def test_accepts_dots_in_local(self) -> None:
+        assert validate_email("first.last@example.com") == "first.last@example.com"
+
+
+class TestValidatePassword:
+    def test_valid_password(self) -> None:
+        assert validate_password("securepass") == "securepass"
+
+    def test_exactly_8_characters(self) -> None:
+        assert validate_password("12345678") == "12345678"
+
+    def test_rejects_7_characters(self) -> None:
+        with pytest.raises(UserServiceError, match="at least 8"):
+            validate_password("1234567")
+
+    def test_rejects_empty(self) -> None:
+        with pytest.raises(UserServiceError, match="at least 8"):
+            validate_password("")
+
+    def test_strips_whitespace(self) -> None:
+        assert validate_password("  securepass  ") == "securepass"
+
+    def test_whitespace_only_too_short(self) -> None:
+        with pytest.raises(UserServiceError, match="at least 8"):
+            validate_password("       ")
-- 
2.49.1


From 4403c9ebde75025edf7cfc4424e04dd340ce9d64 Mon Sep 17 00:00:00 2001
From: Justin Visser <justinfvisser@gmail.com>
Date: Sun, 1 Mar 2026 22:54:23 +0100
Subject: [PATCH 38/38] Bugfixeds

---
 .github/workflows/release.yml                 |  4 ++
 app/api/routers/run_manual.py                 |  6 +-
 app/api/schemas/admin.py                      |  8 +--
 app/api/schemas/auth.py                       |  8 +--
 app/main.py                                   | 20 ++++++
 app/services/arxiv/rate_limit.py              | 57 ++++++++++------
 app/services/crossref/application.py          |  7 +-
 app/services/dbops/near_duplicate_repair.py   |  3 +
 app/services/ingestion/application.py         |  1 +
 app/services/ingestion/publication_upsert.py  | 68 ++++++++++---------
 app/services/ingestion/queue.py               |  1 +
 app/services/publications/pdf_queue_common.py |  1 +
 .../publications/pdf_queue_resolution.py      | 22 +++++-
 app/services/runs/events.py                   | 13 +++-
 .../components/PublicationTableRow.test.ts    |  2 +-
 .../composables/usePublicationData.ts         |  6 +-
 .../features/settings/SettingsAdminPanel.vue  |  6 +-
 .../components/AdminPdfQueueSection.vue       | 16 ++++-
 .../components/AdminRepairsSection.vue        | 12 +++-
 frontend/src/pages/PublicationsPage.vue       | 23 +++++--
 20 files changed, 199 insertions(+), 85 deletions(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 9f39e29..f43fb27 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -21,6 +21,10 @@ jobs:
           python-version: "3.12"
       - uses: astral-sh/setup-uv@v4
       - run: uv sync --extra dev
+      - name: Lint
+        run: uv run ruff check
+      - name: Test
+        run: uv run pytest
       - name: Semantic Release
         id: release
         run: uv run semantic-release publish
diff --git a/app/api/routers/run_manual.py b/app/api/routers/run_manual.py
index 0632e39..cdb5e99 100644
--- a/app/api/routers/run_manual.py
+++ b/app/api/routers/run_manual.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any
+from typing import Any, NoReturn
 
 from fastapi import Request
 from sqlalchemy.exc import IntegrityError
@@ -215,7 +215,7 @@ async def execute_manual_run(
         raise_manual_failed(exc=exc, user_id=user_id)
 
 
-def raise_manual_blocked_safety(*, exc, user_id: int) -> None:
+def raise_manual_blocked_safety(*, exc, user_id: int) -> NoReturn:
     structured_log(
         logger,
         "info",
@@ -233,7 +233,7 @@ def raise_manual_blocked_safety(*, exc, user_id: int) -> None:
     ) from exc
 
 
-def raise_manual_failed(*, exc: Exception, user_id: int) -> None:
+def raise_manual_failed(*, exc: Exception, user_id: int) -> NoReturn:
     structured_log(
         logger,
         "exception",
diff --git a/app/api/schemas/admin.py b/app/api/schemas/admin.py
index f5f73b5..932f93c 100644
--- a/app/api/schemas/admin.py
+++ b/app/api/schemas/admin.py
@@ -35,7 +35,7 @@ class AdminUsersListEnvelope(BaseModel):
 
 class AdminUserCreateRequest(BaseModel):
     email: str = Field(max_length=254)
-    password: str = Field(max_length=128)
+    password: str = Field(min_length=8, max_length=128)
     is_admin: bool = False
 
     model_config = ConfigDict(extra="forbid")
@@ -55,7 +55,7 @@ class AdminUserEnvelope(BaseModel):
 
 
 class AdminResetPasswordRequest(BaseModel):
-    new_password: str = Field(max_length=128)
+    new_password: str = Field(min_length=8, max_length=128)
 
     model_config = ConfigDict(extra="forbid")
 
@@ -64,7 +64,7 @@ class AdminScholarHttpSettingsData(BaseModel):
     user_agent: str
     rotate_user_agent: bool
     accept_language: str
-    cookie: str
+    cookie: str | None = None
 
     model_config = ConfigDict(extra="forbid")
 
@@ -80,7 +80,7 @@ class AdminScholarHttpSettingsUpdateRequest(BaseModel):
     user_agent: str
     rotate_user_agent: bool
     accept_language: str
-    cookie: str
+    cookie: str | None = None
 
     model_config = ConfigDict(extra="forbid")
 
diff --git a/app/api/schemas/auth.py b/app/api/schemas/auth.py
index f160b24..14efa57 100644
--- a/app/api/schemas/auth.py
+++ b/app/api/schemas/auth.py
@@ -45,7 +45,7 @@ class CsrfBootstrapEnvelope(BaseModel):
 
 class LoginRequest(BaseModel):
     email: str = Field(max_length=254)
-    password: str = Field(max_length=128)
+    password: str = Field(min_length=8, max_length=128)
 
     model_config = ConfigDict(extra="forbid")
 
@@ -66,8 +66,8 @@ class LoginEnvelope(BaseModel):
 
 
 class ChangePasswordRequest(BaseModel):
-    current_password: str = Field(max_length=128)
-    new_password: str = Field(max_length=128)
-    confirm_password: str = Field(max_length=128)
+    current_password: str = Field(min_length=8, max_length=128)
+    new_password: str = Field(min_length=8, max_length=128)
+    confirm_password: str = Field(min_length=8, max_length=128)
 
     model_config = ConfigDict(extra="forbid")
diff --git a/app/main.py b/app/main.py
index feda0c8..f8610e1 100644
--- a/app/main.py
+++ b/app/main.py
@@ -81,6 +81,26 @@ async def lifespan(_: FastAPI):
             error=str(exc),
         )
 
+    try:
+        session_factory = get_session_factory()
+        async with session_factory() as session:
+            await session.execute(
+                text(
+                    "UPDATE publication_pdf_jobs SET status = 'queued'"
+                    " WHERE status = 'running'"
+                    " AND (last_attempt_at IS NULL OR last_attempt_at < NOW() - INTERVAL '10 minutes')"
+                )
+            )
+            await session.commit()
+            structured_log(logger, "info", "app.startup_stuck_pdf_jobs_recovered")
+    except Exception as exc:
+        structured_log(
+            logger,
+            "error",
+            "app.startup_stuck_pdf_jobs_recovery_failed",
+            error=str(exc),
+        )
+
     await scheduler_service.start()
     yield
     await scheduler_service.stop()
diff --git a/app/services/arxiv/rate_limit.py b/app/services/arxiv/rate_limit.py
index 1f3ab3f..8d1a5a1 100644
--- a/app/services/arxiv/rate_limit.py
+++ b/app/services/arxiv/rate_limit.py
@@ -53,7 +53,7 @@ async def get_arxiv_cooldown_status(*, now_utc: datetime | None = None) -> Arxiv
         result = await db_session.execute(
             select(ArxivRuntimeState.cooldown_until).where(ArxivRuntimeState.state_key == ARXIV_RUNTIME_STATE_KEY)
         )
-    cooldown_until = _normalize_datetime(result.scalar_one_or_none())
+        cooldown_until = _normalize_datetime(result.scalar_one_or_none())
     remaining_seconds = _cooldown_remaining_seconds(cooldown_until, now_utc=timestamp)
     return ArxivCooldownStatus(
         is_active=remaining_seconds > 0.0,
@@ -68,26 +68,31 @@ async def _run_serialized_fetch(
     source_path: str,
 ) -> tuple[httpx.Response, bool]:
     session_factory = get_session_factory()
-    async with session_factory() as db_session, db_session.begin():
-        await _acquire_arxiv_lock(db_session)
-        runtime_state = await _load_runtime_state_for_update(db_session)
-        wait_seconds = await _wait_for_allowed_slot_or_raise(
-            runtime_state,
-            source_path=source_path,
-        )
-        runtime_state.next_allowed_at = datetime.now(UTC) + timedelta(seconds=_min_interval_seconds())
+    async with session_factory() as lock_session:
+        await _acquire_arxiv_lock(lock_session)
+        try:
+            async with session_factory() as db_session, db_session.begin():
+                runtime_state = await _load_runtime_state_for_update(db_session)
+                wait_seconds = await _wait_for_allowed_slot_or_raise(
+                    runtime_state,
+                    source_path=source_path,
+                )
+                runtime_state.next_allowed_at = datetime.now(UTC) + timedelta(seconds=_min_interval_seconds())
 
-    if wait_seconds > 0:
-        await asyncio.sleep(wait_seconds)
-    response = await fetch()
+            if wait_seconds > 0:
+                await asyncio.sleep(wait_seconds)
+            response = await fetch()
 
-    async with session_factory() as db_session, db_session.begin():
-        runtime_state = await _load_runtime_state_for_update(db_session)
-        hit_rate_limit = _record_post_response_state(
-            runtime_state,
-            response_status=int(response.status_code),
-            source_path=source_path,
-        )
+            async with session_factory() as db_session, db_session.begin():
+                runtime_state = await _load_runtime_state_for_update(db_session)
+                hit_rate_limit = _record_post_response_state(
+                    runtime_state,
+                    response_status=int(response.status_code),
+                    source_path=source_path,
+                )
+                cooldown_until_value = runtime_state.cooldown_until
+        finally:
+            await _release_arxiv_lock(lock_session)
     structured_log(
         logger,
         "info",
@@ -95,7 +100,7 @@ async def _run_serialized_fetch(
         status_code=int(response.status_code),
         wait_seconds=wait_seconds,
         cooldown_remaining_seconds=_cooldown_remaining_seconds(
-            runtime_state.cooldown_until, now_utc=datetime.now(UTC)
+            cooldown_until_value, now_utc=datetime.now(UTC)
         ),
         source_path=source_path,
     )
@@ -104,7 +109,17 @@ async def _run_serialized_fetch(
 
 async def _acquire_arxiv_lock(db_session: AsyncSession) -> None:
     await db_session.execute(
-        text("SELECT pg_advisory_xact_lock(:namespace, :lock_key)"),
+        text("SELECT pg_advisory_lock(:namespace, :lock_key)"),
+        {
+            "namespace": ARXIV_RATE_LIMIT_LOCK_NAMESPACE,
+            "lock_key": ARXIV_RATE_LIMIT_LOCK_KEY,
+        },
+    )
+
+
+async def _release_arxiv_lock(db_session: AsyncSession) -> None:
+    await db_session.execute(
+        text("SELECT pg_advisory_unlock(:namespace, :lock_key)"),
         {
             "namespace": ARXIV_RATE_LIMIT_LOCK_NAMESPACE,
             "lock_key": ARXIV_RATE_LIMIT_LOCK_KEY,
diff --git a/app/services/crossref/application.py b/app/services/crossref/application.py
index 7a2908b..a546a9f 100644
--- a/app/services/crossref/application.py
+++ b/app/services/crossref/application.py
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
     from app.services.publications.types import PublicationListItem, UnreadPublicationItem
 
 TOKEN_RE = re.compile(r"[a-z0-9]+")
-NON_ALNUM_RE = re.compile(r"[^a-z0-9\\s]+")
+NON_ALNUM_RE = re.compile(r"[^a-z0-9\s]+")
 STOP_WORDS = {"the", "and", "for", "with", "from", "method", "study", "analysis"}
 _RATE_LOCK = threading.Lock()
 _LAST_REQUEST_AT = 0.0
@@ -35,8 +35,9 @@ def _rate_limit_wait(min_interval_seconds: float) -> None:
     with _RATE_LOCK:
         elapsed = time.monotonic() - _LAST_REQUEST_AT
         remaining = interval - elapsed
-        if remaining > 0:
-            time.sleep(remaining)
+    if remaining > 0:
+        time.sleep(remaining)
+    with _RATE_LOCK:
         _LAST_REQUEST_AT = time.monotonic()
 
 
diff --git a/app/services/dbops/near_duplicate_repair.py b/app/services/dbops/near_duplicate_repair.py
index 8d50570..70c902c 100644
--- a/app/services/dbops/near_duplicate_repair.py
+++ b/app/services/dbops/near_duplicate_repair.py
@@ -162,7 +162,10 @@ async def _complete_job(
 
 
 async def _fail_job(db_session: AsyncSession, *, job: DataRepairJob, error: Exception) -> None:
+    from sqlalchemy.orm import make_transient
+
     await db_session.rollback()
+    make_transient(job)
     job.status = REPAIR_STATUS_FAILED
     job.error_text = str(error)
     job.finished_at = _utcnow()
diff --git a/app/services/ingestion/application.py b/app/services/ingestion/application.py
index cd5e6ea..1a6293e 100644
--- a/app/services/ingestion/application.py
+++ b/app/services/ingestion/application.py
@@ -401,6 +401,7 @@ class ScholarIngestionService:
                 if run_to_fail:
                     run_to_fail.status = RunStatus.FAILED
                     run_to_fail.end_dt = datetime.now(UTC)
+                    run_to_fail.error_log = run_to_fail.error_log or {}
                     run_to_fail.error_log["terminal_exception"] = str(exc)
                     await cleanup_session.commit()
         except Exception:
diff --git a/app/services/ingestion/publication_upsert.py b/app/services/ingestion/publication_upsert.py
index d2ba42b..ae7b1b8 100644
--- a/app/services/ingestion/publication_upsert.py
+++ b/app/services/ingestion/publication_upsert.py
@@ -176,45 +176,51 @@ async def upsert_profile_publications(
     seen_publication_ids: set[int] = set()
     discovered_count = 0
 
-    for candidate in publications:
-        publication = await resolve_publication(db_session, candidate)
-        if publication.id in seen_publication_ids:
-            continue
-        seen_publication_ids.add(publication.id)
+    try:
+        for candidate in publications:
+            publication = await resolve_publication(db_session, candidate)
+            if publication.id in seen_publication_ids:
+                continue
+            seen_publication_ids.add(publication.id)
 
-        link_result = await db_session.execute(
-            select(ScholarPublication).where(
-                ScholarPublication.scholar_profile_id == scholar.id,
-                ScholarPublication.publication_id == publication.id,
+            link_result = await db_session.execute(
+                select(ScholarPublication).where(
+                    ScholarPublication.scholar_profile_id == scholar.id,
+                    ScholarPublication.publication_id == publication.id,
+                )
             )
-        )
-        link = link_result.scalar_one_or_none()
-        if link is not None:
-            continue
+            link = link_result.scalar_one_or_none()
+            if link is not None:
+                continue
 
-        link = ScholarPublication(
-            scholar_profile_id=scholar.id,
-            publication_id=publication.id,
-            is_read=False,
-            first_seen_run_id=run.id,
-        )
-        db_session.add(link)
-        discovered_count += 1
+            link = ScholarPublication(
+                scholar_profile_id=scholar.id,
+                publication_id=publication.id,
+                is_read=False,
+                first_seen_run_id=run.id,
+            )
+            db_session.add(link)
+            discovered_count += 1
 
-        await commit_discovered_publication(
-            db_session,
-            run=run,
-            scholar=scholar,
-            publication=publication,
-        )
+            await flush_discovered_publication(
+                db_session,
+                run=run,
+                scholar=scholar,
+                publication=publication,
+            )
 
-    if not scholar.baseline_completed:
-        scholar.baseline_completed = True
+        if not scholar.baseline_completed:
+            scholar.baseline_completed = True
+
+        await db_session.commit()
+    except Exception:
+        await db_session.rollback()
+        raise
 
     return discovered_count
 
 
-async def commit_discovered_publication(
+async def flush_discovered_publication(
     db_session: AsyncSession,
     *,
     run: CrawlRun,
@@ -222,7 +228,7 @@ async def commit_discovered_publication(
     publication: Publication,
 ) -> None:
     run.new_pub_count = int(run.new_pub_count or 0) + 1
-    await db_session.commit()
+    await db_session.flush()
     await run_events.publish(
         run_id=run.id,
         event_type="publication_discovered",
diff --git a/app/services/ingestion/queue.py b/app/services/ingestion/queue.py
index 2016f63..8bdddbc 100644
--- a/app/services/ingestion/queue.py
+++ b/app/services/ingestion/queue.py
@@ -196,6 +196,7 @@ async def list_due_jobs(
             IngestionQueueItem.id.asc(),
         )
         .limit(limit)
+        .with_for_update(skip_locked=True)
     )
     rows = list(result.scalars().all())
     jobs: list[ContinuationQueueJob] = []
diff --git a/app/services/publications/pdf_queue_common.py b/app/services/publications/pdf_queue_common.py
index 9eb95ed..0bff88b 100644
--- a/app/services/publications/pdf_queue_common.py
+++ b/app/services/publications/pdf_queue_common.py
@@ -47,4 +47,5 @@ def queued_job(
         status=PDF_STATUS_QUEUED,
         queued_at=now,
         last_requested_by_user_id=user_id,
+        attempt_count=0,
     )
diff --git a/app/services/publications/pdf_queue_resolution.py b/app/services/publications/pdf_queue_resolution.py
index aec3f74..ec4422e 100644
--- a/app/services/publications/pdf_queue_resolution.py
+++ b/app/services/publications/pdf_queue_resolution.py
@@ -46,7 +46,7 @@ async def _mark_attempt_started(
             db_session.add(job)
         job.status = PDF_STATUS_RUNNING
         job.last_attempt_at = utcnow()
-        job.attempt_count = int(job.attempt_count) + 1
+        job.attempt_count = int(job.attempt_count or 0) + 1
         db_session.add(
             event_row(
                 publication_id=publication_id,
@@ -240,6 +240,26 @@ async def _run_resolution_task(
                 detail="Stopping PDF resolution batch — OpenAlex daily budget exhausted",
             )
             break
+        except Exception:
+            structured_log(
+                logger,
+                "exception",
+                "pdf_queue.row_failed",
+                publication_id=row.publication_id,
+            )
+            try:
+                await _persist_outcome(
+                    publication_id=row.publication_id,
+                    user_id=user_id,
+                    outcome=_failed_outcome(row=row),
+                )
+            except Exception:
+                structured_log(
+                    logger,
+                    "exception",
+                    "pdf_queue.row_fail_persist_error",
+                    publication_id=row.publication_id,
+                )
 
 
 def _register_task(task: asyncio.Task[None]) -> None:
diff --git a/app/services/runs/events.py b/app/services/runs/events.py
index 17baa62..dbcac2d 100644
--- a/app/services/runs/events.py
+++ b/app/services/runs/events.py
@@ -8,6 +8,8 @@ from app.logging_utils import structured_log
 
 logger = logging.getLogger(__name__)
 
+_SUBSCRIBER_QUEUE_MAXSIZE = 256
+
 
 class RunEventPublisher:
     def __init__(self) -> None:
@@ -17,7 +19,7 @@ class RunEventPublisher:
     def subscribe(self, run_id: int) -> asyncio.Queue:
         if run_id not in self._subscribers:
             self._subscribers[run_id] = set()
-        queue: asyncio.Queue[Any] = asyncio.Queue()
+        queue: asyncio.Queue[Any] = asyncio.Queue(maxsize=_SUBSCRIBER_QUEUE_MAXSIZE)
         self._subscribers[run_id].add(queue)
         structured_log(
             logger,
@@ -51,6 +53,10 @@ class RunEventPublisher:
                     "runs.event_subscriber_queue_full",
                     run_id=run_id,
                 )
+                self._subscribers[run_id].discard(queue)
+
+    async def publish_run_complete(self, run_id: int) -> None:
+        await self.publish(run_id, "run_complete", {})
 
 
 run_events = RunEventPublisher()
@@ -62,8 +68,11 @@ async def event_generator(run_id: int) -> AsyncGenerator[str, None]:
         while True:
             # Wait for a new event
             message = await queue.get()
-            # Server-Sent Events format: "event: <type>\ndata: <json>\n\n"
             event_type = message["type"]
+            if event_type == "run_complete":
+                yield f"event: {event_type}\ndata: {{}}\n\n"
+                break
+            # Server-Sent Events format: "event: <type>\ndata: <json>\n\n"
             data_str = json.dumps(message["data"])
             yield f"event: {event_type}\ndata: {data_str}\n\n"
     except asyncio.CancelledError:
diff --git a/frontend/src/features/publications/components/PublicationTableRow.test.ts b/frontend/src/features/publications/components/PublicationTableRow.test.ts
index 3a1110d..e3d8915 100644
--- a/frontend/src/features/publications/components/PublicationTableRow.test.ts
+++ b/frontend/src/features/publications/components/PublicationTableRow.test.ts
@@ -13,7 +13,7 @@ function buildItem(overrides: Partial<PublicationItem> = {}): PublicationItem {
     citation_count: 42,
     pub_url: "https://example.com/pub",
     pdf_url: null,
-    pdf_status: null,
+    pdf_status: "untracked",
     is_read: false,
     is_favorite: false,
     is_new_in_latest_run: true,
diff --git a/frontend/src/features/publications/composables/usePublicationData.ts b/frontend/src/features/publications/composables/usePublicationData.ts
index e48209e..1ce8d11 100644
--- a/frontend/src/features/publications/composables/usePublicationData.ts
+++ b/frontend/src/features/publications/composables/usePublicationData.ts
@@ -1,4 +1,4 @@
-import { computed, ref, watch } from "vue";
+import { computed, onScopeDispose, ref, watch } from "vue";
 import { useRoute, useRouter } from "vue-router";
 import {
   listPublications,
@@ -271,6 +271,10 @@ export function usePublicationData() {
     }, 300);
   });
 
+  onScopeDispose(() => {
+    if (searchDebounceTimer !== null) clearTimeout(searchDebounceTimer);
+  });
+
   // --- Run-triggered refresh watcher ---
 
   watch(
diff --git a/frontend/src/features/settings/SettingsAdminPanel.vue b/frontend/src/features/settings/SettingsAdminPanel.vue
index 585dd6a..b306d1e 100644
--- a/frontend/src/features/settings/SettingsAdminPanel.vue
+++ b/frontend/src/features/settings/SettingsAdminPanel.vue
@@ -36,10 +36,8 @@ async function refreshForSection(): Promise<void> {
     return;
   }
   if (props.section === SECTION_REPAIRS) {
-    await Promise.all([
-      usersRef.value?.load(),
-      repairsRef.value?.load(),
-    ]);
+    await usersRef.value?.load();
+    await repairsRef.value?.load();
     return;
   }
   if (props.section === SECTION_PDF && pdfQueueRef.value) {
diff --git a/frontend/src/features/settings/components/AdminPdfQueueSection.vue b/frontend/src/features/settings/components/AdminPdfQueueSection.vue
index f1500ca..fdeb98a 100644
--- a/frontend/src/features/settings/components/AdminPdfQueueSection.vue
+++ b/frontend/src/features/settings/components/AdminPdfQueueSection.vue
@@ -7,6 +7,7 @@ import AppHelpHint from "@/components/ui/AppHelpHint.vue";
 import AppRefreshButton from "@/components/ui/AppRefreshButton.vue";
 import AppSelect from "@/components/ui/AppSelect.vue";
 import AppTable from "@/components/ui/AppTable.vue";
+import RequestStateAlerts from "@/components/patterns/RequestStateAlerts.vue";
 import {
   listAdminPdfQueue,
   requeueAdminPdfLookup,
@@ -15,7 +16,7 @@ import {
 } from "@/features/admin_dbops";
 import { useRequestState } from "@/composables/useRequestState";
 
-const { clearAlerts, assignError, setSuccess } = useRequestState();
+const { errorMessage, errorRequestId, successMessage, clearAlerts, assignError, setSuccess } = useRequestState();
 
 const refreshingPdfQueue = ref(false);
 const requeueingPublicationId = ref<number | null>(null);
@@ -131,7 +132,17 @@ defineExpose({ load });
 </script>
 
 <template>
-  <AppCard class="space-y-3">
+  <section class="grid gap-4">
+    <RequestStateAlerts
+      :success-message="successMessage"
+      :error-message="errorMessage"
+      :error-request-id="errorRequestId"
+      success-title="PDF queue operation complete"
+      error-title="PDF queue operation failed"
+      @dismiss-success="successMessage = null"
+    />
+
+    <AppCard class="space-y-3">
     <div class="flex flex-wrap items-center justify-between gap-2">
       <div class="flex items-center gap-1">
         <h2 class="text-lg font-semibold text-ink-primary">PDF Gathering Queue</h2>
@@ -200,4 +211,5 @@ defineExpose({ load });
       </div>
     </div>
   </AppCard>
+  </section>
 </template>
diff --git a/frontend/src/features/settings/components/AdminRepairsSection.vue b/frontend/src/features/settings/components/AdminRepairsSection.vue
index 3f3a88a..05eab7a 100644
--- a/frontend/src/features/settings/components/AdminRepairsSection.vue
+++ b/frontend/src/features/settings/components/AdminRepairsSection.vue
@@ -9,6 +9,7 @@ import AppInput from "@/components/ui/AppInput.vue";
 import AppRefreshButton from "@/components/ui/AppRefreshButton.vue";
 import AppSelect from "@/components/ui/AppSelect.vue";
 import AppTable from "@/components/ui/AppTable.vue";
+import RequestStateAlerts from "@/components/patterns/RequestStateAlerts.vue";
 import {
   dropAllPublications,
   listAdminDbRepairJobs,
@@ -34,7 +35,7 @@ const DROP_PUBLICATIONS_CONFIRM_TEXT = "DROP ALL PUBLICATIONS";
 
 type RepairScopeMode = typeof SCOPE_SINGLE_USER | typeof SCOPE_ALL_USERS;
 
-const { clearAlerts, assignError, setSuccess } = useRequestState();
+const { errorMessage, errorRequestId, successMessage, clearAlerts, assignError, setSuccess } = useRequestState();
 
 const refreshingJobs = ref(false);
 const runningRepair = ref(false);
@@ -246,6 +247,15 @@ defineExpose({ load });
 
 <template>
   <section class="grid gap-4">
+    <RequestStateAlerts
+      :success-message="successMessage"
+      :error-message="errorMessage"
+      :error-request-id="errorRequestId"
+      success-title="Repair operation complete"
+      error-title="Repair operation failed"
+      @dismiss-success="successMessage = null"
+    />
+
     <AppCard class="space-y-3">
       <div class="flex items-center gap-1">
         <h2 class="text-lg font-semibold text-ink-primary">Publication Link Repair</h2>
diff --git a/frontend/src/pages/PublicationsPage.vue b/frontend/src/pages/PublicationsPage.vue
index 4f0ad86..9dcfec7 100644
--- a/frontend/src/pages/PublicationsPage.vue
+++ b/frontend/src/pages/PublicationsPage.vue
@@ -335,14 +335,23 @@ async function onStartRun(): Promise<void> {
   pub.successMessage.value = null;
   pub.errorMessage.value = null;
   pub.errorRequestId.value = null;
-  const result = await runStatus.startManualCheck();
-  if (result.kind === "started") { pub.successMessage.value = `Run #${result.runId} started.`; return; }
-  if (result.kind === "already_running") {
-    pub.successMessage.value = result.runId ? `Run #${result.runId} is already in progress.` : "A run is already in progress.";
-    return;
+  try {
+    const result = await runStatus.startManualCheck();
+    if (result.kind === "started") { pub.successMessage.value = `Run #${result.runId} started.`; return; }
+    if (result.kind === "already_running") {
+      pub.successMessage.value = result.runId ? `Run #${result.runId} is already in progress.` : "A run is already in progress.";
+      return;
+    }
+    pub.errorMessage.value = result.message;
+    pub.errorRequestId.value = result.requestId;
+  } catch (error) {
+    if (error instanceof ApiRequestError) {
+      pub.errorMessage.value = error.message;
+      pub.errorRequestId.value = error.requestId;
+    } else {
+      pub.errorMessage.value = "Unable to start manual run.";
+    }
   }
-  pub.errorMessage.value = result.message;
-  pub.errorRequestId.value = result.requestId;
 }
 
 // --- Lifecycle ---
-- 
2.49.1