Sprint 1 — Setup initial : arborescence, schémas Pydantic, profils JSON, prompts, tests

- Structure canonique complète (backend/app/, profiles/, prompts/, infra/)
- Schémas Pydantic v2 : CorpusProfile, PageMaster, AnnotationLayer
- 4 profils JSON (medieval-illuminated, medieval-textual, early-modern-print, modern-handwritten)
- 9 templates de prompts avec variables {{profile_label}}, {{language_hints}}, {{script_type}}
- 54 tests pytest : 100% passed (test_schemas.py + test_profiles.py)
- backend/pyproject.toml avec dépendances stack technique
- .gitignore avec exclusion du dossier data/

https://claude.ai/code/session_018woyEHc8HG2th7V4ewJ4Kg

.gitignore

@@ -0,0 +1,40 @@
+# Data — jamais versionné (CLAUDE.md section 3)
+data/
+
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.Python
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+venv/
+env/
+.env
+
+# pytest / coverage
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Secrets — jamais versionné (CLAUDE.md R06)
+.env.local
+.env.*.local
+*.key
+secrets/

backend/app/schemas/annotation.py

@@ -0,0 +1,32 @@
+"""
+Schémas Pydantic pour les couches d'annotation de page.
+"""
+# 1. stdlib
+from datetime import datetime
+from enum import Enum
+
+# 2. third-party
+from pydantic import BaseModel
+
+# 3. local
+from app.schemas.corpus_profile import LayerType
+
+
+class LayerStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    DONE = "done"
+    FAILED = "failed"
+    NEEDS_REVIEW = "needs_review"
+    VALIDATED = "validated"
+
+
+class AnnotationLayer(BaseModel):
+    id: str
+    page_id: str
+    layer_type: LayerType
+    status: LayerStatus = LayerStatus.PENDING
+    version: int = 1
+    source_model: str | None = None
+    prompt_version: str | None = None
+    created_at: datetime

backend/app/schemas/corpus_profile.py

@@ -0,0 +1,54 @@
+"""
+Schémas Pydantic pour le profil de corpus — entité centrale du pipeline.
+"""
+# 1. stdlib
+from enum import Enum
+
+# 2. third-party
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class LayerType(str, Enum):
+    IMAGE = "image"
+    OCR_DIPLOMATIC = "ocr_diplomatic"
+    OCR_NORMALIZED = "ocr_normalized"
+    TRANSLATION_FR = "translation_fr"
+    TRANSLATION_EN = "translation_en"
+    SUMMARY = "summary"
+    SCHOLARLY_COMMENTARY = "scholarly_commentary"
+    PUBLIC_COMMENTARY = "public_commentary"
+    ICONOGRAPHY_DETECTION = "iconography_detection"
+    MATERIAL_NOTES = "material_notes"
+    UNCERTAINTY = "uncertainty"
+
+
+class ScriptType(str, Enum):
+    CAROLINE = "caroline"
+    GOTHIC = "gothic"
+    PRINT = "print"
+    CURSIVE = "cursive"
+    OTHER = "other"
+
+
+class ExportConfig(BaseModel):
+    mets: bool = True
+    alto: bool = True
+    tei: bool = False
+
+
+class UncertaintyConfig(BaseModel):
+    flag_below: float = Field(0.4, ge=0.0, le=1.0)
+    min_acceptable: float = Field(0.25, ge=0.0, le=1.0)
+
+
+class CorpusProfile(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    profile_id: str
+    label: str
+    language_hints: list[str]
+    script_type: ScriptType
+    active_layers: list[LayerType]
+    prompt_templates: dict[str, str]
+    uncertainty_config: UncertaintyConfig
+    export_config: ExportConfig

backend/app/schemas/page_master.py

@@ -0,0 +1,108 @@
+"""
+Schémas Pydantic pour le JSON maître de page — source canonique de toutes les sorties.
+"""
+# 1. stdlib
+from datetime import datetime
+from enum import Enum
+from typing import Any, Literal
+
+# 2. third-party
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class RegionType(str, Enum):
+    TEXT_BLOCK = "text_block"
+    MINIATURE = "miniature"
+    DECORATED_INITIAL = "decorated_initial"
+    MARGIN = "margin"
+    RUBRIC = "rubric"
+    OTHER = "other"
+
+
+class Region(BaseModel):
+    id: str
+    type: RegionType
+    bbox: list[int] = Field(..., min_length=4, max_length=4)
+    confidence: float = Field(..., ge=0.0, le=1.0)
+    polygon: list[list[int]] | None = None
+    parent_region_id: str | None = None
+
+    @field_validator("bbox")
+    @classmethod
+    def bbox_must_be_positive(cls, v: list[int]) -> list[int]:
+        if any(x < 0 for x in v):
+            raise ValueError("bbox values must be >= 0")
+        if v[2] <= 0 or v[3] <= 0:
+            raise ValueError("bbox width and height must be > 0")
+        return v
+
+
+class OCRResult(BaseModel):
+    diplomatic_text: str = ""
+    blocks: list[dict] = []
+    lines: list[dict] = []
+    language: str = "la"
+    confidence: float = Field(0.0, ge=0.0, le=1.0)
+    uncertain_segments: list[str] = []
+
+
+class Translation(BaseModel):
+    fr: str = ""
+    en: str = ""
+
+
+class CommentaryClaim(BaseModel):
+    claim: str
+    evidence_region_ids: list[str] = []
+    certainty: Literal["high", "medium", "low", "speculative"] = "medium"
+
+
+class Commentary(BaseModel):
+    public: str = ""
+    scholarly: str = ""
+    claims: list[CommentaryClaim] = []
+
+
+class ProcessingInfo(BaseModel):
+    model_id: str
+    model_display_name: str
+    prompt_version: str
+    raw_response_path: str
+    processed_at: datetime
+    cost_estimate_usd: float | None = None
+
+
+class EditorialStatus(str, Enum):
+    MACHINE_DRAFT = "machine_draft"
+    NEEDS_REVIEW = "needs_review"
+    REVIEWED = "reviewed"
+    VALIDATED = "validated"
+    PUBLISHED = "published"
+
+
+class EditorialInfo(BaseModel):
+    status: EditorialStatus = EditorialStatus.MACHINE_DRAFT
+    validated: bool = False
+    validated_by: str | None = None
+    version: int = 1
+    notes: list[str] = []
+
+
+class PageMaster(BaseModel):
+    schema_version: str = "1.0"
+    page_id: str
+    corpus_profile: str
+    manuscript_id: str
+    folio_label: str
+    sequence: int
+
+    image: dict
+    layout: dict
+    ocr: OCRResult | None = None
+    translation: Translation | None = None
+    summary: dict | None = None
+    commentary: Commentary | None = None
+    extensions: dict[str, Any] = {}
+
+    processing: ProcessingInfo | None = None
+    editorial: EditorialInfo = Field(default_factory=EditorialInfo)

backend/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scriptorium-ai-backend"
+version = "0.1.0"
+description = "Backend Scriptorium AI — plateforme générique d'éditions savantes augmentées"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.111",
+    "uvicorn[standard]>=0.29",
+    "pydantic>=2.7",
+    "sqlalchemy>=2.0",
+    "aiosqlite>=0.20",
+    "google-generativeai>=0.3",
+    "lxml>=5.2",
+    "Pillow>=10.3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.2",
+    "pytest-cov>=5.0",
+    "pytest-asyncio>=0.23",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["app*"]

backend/tests/test_profiles.py

@@ -0,0 +1,121 @@
+"""
+Tests de chargement et validation des profils JSON — un test par profil.
+"""
+# 1. stdlib
+import json
+from pathlib import Path
+
+# 2. third-party
+import pytest
+from pydantic import ValidationError
+
+# 3. local
+from app.schemas.corpus_profile import CorpusProfile, LayerType, ScriptType
+
+PROFILES_DIR = Path(__file__).parent.parent.parent / "profiles"
+PROFILE_FILES = [
+    "medieval-illuminated.json",
+    "medieval-textual.json",
+    "early-modern-print.json",
+    "modern-handwritten.json",
+]
+
+
+def load_profile(filename: str) -> CorpusProfile:
+    path = PROFILES_DIR / filename
+    with path.open(encoding="utf-8") as f:
+        data = json.load(f)
+    return CorpusProfile.model_validate(data)
+
+
+# ---------------------------------------------------------------------------
+# Tests de chargement
+# ---------------------------------------------------------------------------
+
+def test_medieval_illuminated_loads():
+    profile = load_profile("medieval-illuminated.json")
+    assert profile.profile_id == "medieval-illuminated"
+    assert profile.script_type == ScriptType.CAROLINE
+
+
+def test_medieval_textual_loads():
+    profile = load_profile("medieval-textual.json")
+    assert profile.profile_id == "medieval-textual"
+    assert profile.script_type == ScriptType.GOTHIC
+
+
+def test_early_modern_print_loads():
+    profile = load_profile("early-modern-print.json")
+    assert profile.profile_id == "early-modern-print"
+    assert profile.script_type == ScriptType.PRINT
+
+
+def test_modern_handwritten_loads():
+    profile = load_profile("modern-handwritten.json")
+    assert profile.profile_id == "modern-handwritten"
+    assert profile.script_type == ScriptType.CURSIVE
+
+
+# ---------------------------------------------------------------------------
+# Tests de cohérence
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("filename", PROFILE_FILES)
+def test_profile_has_required_fields(filename: str):
+    profile = load_profile(filename)
+    assert profile.profile_id
+    assert profile.label
+    assert len(profile.language_hints) >= 1
+    assert len(profile.active_layers) >= 1
+    assert "primary" in profile.prompt_templates
+
+
+@pytest.mark.parametrize("filename", PROFILE_FILES)
+def test_profile_active_layers_are_valid_layer_types(filename: str):
+    profile = load_profile(filename)
+    valid_values = {lt.value for lt in LayerType}
+    for layer in profile.active_layers:
+        assert layer.value in valid_values
+
+
+@pytest.mark.parametrize("filename", PROFILE_FILES)
+def test_profile_uncertainty_config_bounds(filename: str):
+    profile = load_profile(filename)
+    assert 0.0 <= profile.uncertainty_config.flag_below <= 1.0
+    assert 0.0 <= profile.uncertainty_config.min_acceptable <= 1.0
+    assert profile.uncertainty_config.min_acceptable <= profile.uncertainty_config.flag_below
+
+
+@pytest.mark.parametrize("filename", PROFILE_FILES)
+def test_profile_is_frozen(filename: str):
+    profile = load_profile(filename)
+    with pytest.raises((TypeError, ValidationError)):
+        profile.label = "Hacked"  # type: ignore[misc]
+
+
+@pytest.mark.parametrize("filename", PROFILE_FILES)
+def test_profile_prompt_templates_point_to_txt_files(filename: str):
+    profile = load_profile(filename)
+    for key, path in profile.prompt_templates.items():
+        assert path.endswith(".txt"), f"Template '{key}' doit pointer vers un .txt"
+        assert path.startswith("prompts/"), f"Template '{key}' doit être dans prompts/"
+
+
+def test_medieval_illuminated_has_iconography():
+    profile = load_profile("medieval-illuminated.json")
+    assert LayerType.ICONOGRAPHY_DETECTION in profile.active_layers
+
+
+def test_medieval_illuminated_has_iconography_prompt():
+    profile = load_profile("medieval-illuminated.json")
+    assert "iconography" in profile.prompt_templates
+
+
+def test_early_modern_print_no_iconography():
+    profile = load_profile("early-modern-print.json")
+    assert LayerType.ICONOGRAPHY_DETECTION not in profile.active_layers
+
+
+def test_modern_handwritten_no_iconography():
+    profile = load_profile("modern-handwritten.json")
+    assert LayerType.ICONOGRAPHY_DETECTION not in profile.active_layers

backend/tests/test_schemas.py

@@ -0,0 +1,302 @@
+"""
+Tests des schémas Pydantic — corpus_profile, page_master, annotation.
+"""
+# 1. stdlib
+from datetime import datetime, timezone
+
+# 2. third-party
+import pytest
+from pydantic import ValidationError
+
+# 3. local
+from app.schemas.corpus_profile import (
+    CorpusProfile,
+    ExportConfig,
+    LayerType,
+    ScriptType,
+    UncertaintyConfig,
+)
+from app.schemas.page_master import (
+    Commentary,
+    CommentaryClaim,
+    EditorialInfo,
+    EditorialStatus,
+    OCRResult,
+    PageMaster,
+    ProcessingInfo,
+    Region,
+    RegionType,
+    Translation,
+)
+from app.schemas.annotation import AnnotationLayer, LayerStatus
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def minimal_corpus_profile() -> dict:
+    return {
+        "profile_id": "test-profile",
+        "label": "Test Profile",
+        "language_hints": ["la"],
+        "script_type": "caroline",
+        "active_layers": ["ocr_diplomatic", "translation_fr"],
+        "prompt_templates": {"primary": "prompts/test/primary_v1.txt"},
+        "uncertainty_config": {"flag_below": 0.4, "min_acceptable": 0.25},
+        "export_config": {"mets": True, "alto": True, "tei": False},
+    }
+
+
+@pytest.fixture
+def minimal_page_master() -> dict:
+    return {
+        "page_id": "test-corpus-0001r",
+        "corpus_profile": "test-profile",
+        "manuscript_id": "ms-test-001",
+        "folio_label": "0001r",
+        "sequence": 1,
+        "image": {
+            "master": "data/corpora/test/masters/0001r.tif",
+            "derivative_web": "data/corpora/test/derivatives/0001r.jpg",
+            "iiif_base": "",
+            "width": 2000,
+            "height": 3000,
+        },
+        "layout": {"regions": []},
+    }
+
+
+@pytest.fixture
+def valid_region() -> dict:
+    return {
+        "id": "r1",
+        "type": "text_block",
+        "bbox": [10, 20, 300, 400],
+        "confidence": 0.95,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Tests — CorpusProfile
+# ---------------------------------------------------------------------------
+
+def test_corpus_profile_valid(minimal_corpus_profile):
+    profile = CorpusProfile.model_validate(minimal_corpus_profile)
+    assert profile.profile_id == "test-profile"
+    assert profile.script_type == ScriptType.CAROLINE
+    assert LayerType.OCR_DIPLOMATIC in profile.active_layers
+
+
+def test_corpus_profile_is_frozen(minimal_corpus_profile):
+    profile = CorpusProfile.model_validate(minimal_corpus_profile)
+    with pytest.raises((TypeError, ValidationError)):
+        profile.label = "Modified"  # type: ignore[misc]
+
+
+def test_corpus_profile_all_script_types(minimal_corpus_profile):
+    for script in ScriptType:
+        data = {**minimal_corpus_profile, "script_type": script.value}
+        profile = CorpusProfile.model_validate(data)
+        assert profile.script_type == script
+
+
+def test_corpus_profile_all_layer_types(minimal_corpus_profile):
+    all_layers = [lt.value for lt in LayerType]
+    data = {**minimal_corpus_profile, "active_layers": all_layers}
+    profile = CorpusProfile.model_validate(data)
+    assert len(profile.active_layers) == len(LayerType)
+
+
+def test_uncertainty_config_defaults():
+    config = UncertaintyConfig()
+    assert config.flag_below == 0.4
+    assert config.min_acceptable == 0.25
+
+
+def test_uncertainty_config_bounds():
+    with pytest.raises(ValidationError):
+        UncertaintyConfig(flag_below=1.5)
+    with pytest.raises(ValidationError):
+        UncertaintyConfig(min_acceptable=-0.1)
+
+
+def test_export_config_defaults():
+    config = ExportConfig()
+    assert config.mets is True
+    assert config.alto is True
+    assert config.tei is False
+
+
+def test_corpus_profile_missing_required_field():
+    with pytest.raises(ValidationError):
+        CorpusProfile.model_validate({"profile_id": "x"})
+
+
+# ---------------------------------------------------------------------------
+# Tests — Region / bbox
+# ---------------------------------------------------------------------------
+
+def test_region_valid_bbox(valid_region):
+    region = Region.model_validate(valid_region)
+    assert region.bbox == [10, 20, 300, 400]
+    assert region.confidence == 0.95
+
+
+def test_region_bbox_negative_x():
+    with pytest.raises(ValidationError):
+        Region.model_validate({
+            "id": "r1", "type": "text_block",
+            "bbox": [-1, 20, 300, 400], "confidence": 0.5,
+        })
+
+
+def test_region_bbox_zero_width():
+    with pytest.raises(ValidationError):
+        Region.model_validate({
+            "id": "r1", "type": "text_block",
+            "bbox": [0, 0, 0, 400], "confidence": 0.5,
+        })
+
+
+def test_region_bbox_zero_height():
+    with pytest.raises(ValidationError):
+        Region.model_validate({
+            "id": "r1", "type": "text_block",
+            "bbox": [0, 0, 300, 0], "confidence": 0.5,
+        })
+
+
+def test_region_bbox_wrong_length():
+    with pytest.raises(ValidationError):
+        Region.model_validate({
+            "id": "r1", "type": "text_block",
+            "bbox": [0, 0, 300], "confidence": 0.5,
+        })
+
+
+def test_region_all_types():
+    for region_type in RegionType:
+        region = Region.model_validate({
+            "id": "r1", "type": region_type.value,
+            "bbox": [0, 0, 100, 100], "confidence": 0.8,
+        })
+        assert region.type == region_type
+
+
+def test_region_optional_polygon():
+    region = Region.model_validate({
+        "id": "r1", "type": "miniature",
+        "bbox": [0, 0, 200, 200], "confidence": 0.9,
+        "polygon": [[0, 0], [200, 0], [200, 200], [0, 200]],
+    })
+    assert region.polygon is not None
+    assert len(region.polygon) == 4
+
+
+# ---------------------------------------------------------------------------
+# Tests — PageMaster
+# ---------------------------------------------------------------------------
+
+def test_page_master_valid(minimal_page_master):
+    page = PageMaster.model_validate(minimal_page_master)
+    assert page.schema_version == "1.0"
+    assert page.page_id == "test-corpus-0001r"
+    assert page.editorial.status == EditorialStatus.MACHINE_DRAFT
+
+
+def test_page_master_schema_version_default(minimal_page_master):
+    page = PageMaster.model_validate(minimal_page_master)
+    assert page.schema_version == "1.0"
+
+
+def test_page_master_with_ocr(minimal_page_master):
+    data = {**minimal_page_master, "ocr": {
+        "diplomatic_text": "In nomine Domini",
+        "language": "la",
+        "confidence": 0.87,
+    }}
+    page = PageMaster.model_validate(data)
+    assert page.ocr is not None
+    assert page.ocr.diplomatic_text == "In nomine Domini"
+
+
+def test_page_master_with_translation(minimal_page_master):
+    data = {**minimal_page_master, "translation": {
+        "fr": "Au nom du Seigneur",
+        "en": "In the name of the Lord",
+    }}
+    page = PageMaster.model_validate(data)
+    assert page.translation is not None
+    assert page.translation.fr == "Au nom du Seigneur"
+
+
+def test_page_master_with_commentary(minimal_page_master):
+    data = {**minimal_page_master, "commentary": {
+        "public": "Description publique.",
+        "scholarly": "Analyse savante.",
+        "claims": [
+            {"claim": "Ce folio date du XIe siècle.", "certainty": "high"}
+        ],
+    }}
+    page = PageMaster.model_validate(data)
+    assert page.commentary is not None
+    assert len(page.commentary.claims) == 1
+    assert page.commentary.claims[0].certainty == "high"
+
+
+def test_page_master_editorial_info_defaults(minimal_page_master):
+    page = PageMaster.model_validate(minimal_page_master)
+    assert page.editorial.validated is False
+    assert page.editorial.version == 1
+    assert page.editorial.validated_by is None
+
+
+def test_commentary_claim_certainty_values():
+    for certainty in ("high", "medium", "low", "speculative"):
+        claim = CommentaryClaim(claim="Test.", certainty=certainty)
+        assert claim.certainty == certainty
+
+
+def test_commentary_claim_invalid_certainty():
+    with pytest.raises(ValidationError):
+        CommentaryClaim(claim="Test.", certainty="unknown")
+
+
+# ---------------------------------------------------------------------------
+# Tests — AnnotationLayer
+# ---------------------------------------------------------------------------
+
+def test_annotation_layer_valid():
+    layer = AnnotationLayer(
+        id="layer-001",
+        page_id="test-corpus-0001r",
+        layer_type=LayerType.OCR_DIPLOMATIC,
+        created_at=datetime(2026, 3, 16, 12, 0, 0, tzinfo=timezone.utc),
+    )
+    assert layer.status == LayerStatus.PENDING
+    assert layer.version == 1
+
+
+def test_annotation_layer_all_statuses():
+    for status in LayerStatus:
+        layer = AnnotationLayer(
+            id="layer-001",
+            page_id="test-corpus-0001r",
+            layer_type=LayerType.TRANSLATION_FR,
+            status=status,
+            created_at=datetime(2026, 3, 16, tzinfo=timezone.utc),
+        )
+        assert layer.status == status
+
+
+def test_annotation_layer_all_layer_types():
+    for layer_type in LayerType:
+        layer = AnnotationLayer(
+            id=f"layer-{layer_type.value}",
+            page_id="test-corpus-0001r",
+            layer_type=layer_type,
+            created_at=datetime(2026, 3, 16, tzinfo=timezone.utc),
+        )
+        assert layer.layer_type == layer_type

profiles/early-modern-print.json

@@ -0,0 +1,26 @@
+{
+  "profile_id": "early-modern-print",
+  "label": "Imprimé de la période moderne",
+  "language_hints": ["la", "fr", "it", "de"],
+  "script_type": "print",
+  "active_layers": [
+    "ocr_diplomatic",
+    "ocr_normalized",
+    "translation_fr",
+    "summary",
+    "public_commentary",
+    "uncertainty"
+  ],
+  "prompt_templates": {
+    "primary": "prompts/early-modern-print/primary_v1.txt"
+  },
+  "uncertainty_config": {
+    "flag_below": 0.3,
+    "min_acceptable": 0.2
+  },
+  "export_config": {
+    "mets": true,
+    "alto": true,
+    "tei": false
+  }
+}

profiles/medieval-illuminated.json

@@ -0,0 +1,34 @@
+{
+  "profile_id": "medieval-illuminated",
+  "label": "Manuscrit médiéval enluminé",
+  "language_hints": ["la", "fr-moyen"],
+  "script_type": "caroline",
+  "active_layers": [
+    "image",
+    "ocr_diplomatic",
+    "ocr_normalized",
+    "translation_fr",
+    "translation_en",
+    "summary",
+    "scholarly_commentary",
+    "public_commentary",
+    "iconography_detection",
+    "material_notes",
+    "uncertainty"
+  ],
+  "prompt_templates": {
+    "primary": "prompts/medieval-illuminated/primary_v1.txt",
+    "translation": "prompts/medieval-illuminated/translation_v1.txt",
+    "commentary": "prompts/medieval-illuminated/commentary_v1.txt",
+    "iconography": "prompts/medieval-illuminated/iconography_v1.txt"
+  },
+  "uncertainty_config": {
+    "flag_below": 0.4,
+    "min_acceptable": 0.25
+  },
+  "export_config": {
+    "mets": true,
+    "alto": true,
+    "tei": false
+  }
+}

profiles/medieval-textual.json

@@ -0,0 +1,31 @@
+{
+  "profile_id": "medieval-textual",
+  "label": "Manuscrit médiéval textuel",
+  "language_hints": ["la", "fr-moyen", "oc"],
+  "script_type": "gothic",
+  "active_layers": [
+    "ocr_diplomatic",
+    "ocr_normalized",
+    "translation_fr",
+    "translation_en",
+    "summary",
+    "scholarly_commentary",
+    "public_commentary",
+    "material_notes",
+    "uncertainty"
+  ],
+  "prompt_templates": {
+    "primary": "prompts/medieval-textual/primary_v1.txt",
+    "translation": "prompts/medieval-textual/translation_v1.txt",
+    "commentary": "prompts/medieval-textual/commentary_v1.txt"
+  },
+  "uncertainty_config": {
+    "flag_below": 0.45,
+    "min_acceptable": 0.3
+  },
+  "export_config": {
+    "mets": true,
+    "alto": true,
+    "tei": false
+  }
+}

profiles/modern-handwritten.json

@@ -0,0 +1,25 @@
+{
+  "profile_id": "modern-handwritten",
+  "label": "Document manuscrit moderne",
+  "language_hints": ["fr", "en", "de"],
+  "script_type": "cursive",
+  "active_layers": [
+    "ocr_diplomatic",
+    "ocr_normalized",
+    "summary",
+    "public_commentary",
+    "uncertainty"
+  ],
+  "prompt_templates": {
+    "primary": "prompts/modern-handwritten/primary_v1.txt"
+  },
+  "uncertainty_config": {
+    "flag_below": 0.5,
+    "min_acceptable": 0.35
+  },
+  "export_config": {
+    "mets": true,
+    "alto": true,
+    "tei": false
+  }
+}

prompts/early-modern-print/primary_v1.txt

@@ -0,0 +1,41 @@
+Tu es un expert en histoire du livre imprimé et en paléographie des imprimés anciens.
+
+Profil du corpus : {{profile_label}}
+Langue(s) attendue(s) : {{language_hints}}
+Type d'écriture : {{script_type}}
+
+Analyse l'image de page fournie et retourne UNIQUEMENT un objet JSON strict, sans texte avant ni après.
+
+Tâches :
+1. Détecte et délimite toutes les régions de la page (blocs de texte, titres, notes marginales, ornements typographiques, colophons).
+2. Transcris le texte visible (respecte l'orthographe originale, y compris les graphies archaïques).
+3. Évalue ta confiance pour chaque région et pour la transcription globale.
+4. Signale les passages illisibles ou incertains dans uncertain_segments.
+
+Format de sortie JSON attendu :
+{
+  "layout": {
+    "regions": [
+      {
+        "id": "r1",
+        "type": "text_block|margin|rubric|decorated_initial|other",
+        "bbox": [x, y, width, height],
+        "confidence": 0.0
+      }
+    ]
+  },
+  "ocr": {
+    "diplomatic_text": "",
+    "blocks": [],
+    "lines": [],
+    "language": "la",
+    "confidence": 0.0,
+    "uncertain_segments": []
+  }
+}
+
+Règles absolues :
+- bbox au format [x, y, largeur, hauteur] en pixels entiers, JAMAIS [x1, y1, x2, y2].
+- x, y >= 0 ; largeur > 0 ; hauteur > 0.
+- confidence entre 0.0 et 1.0.
+- Retourne uniquement le JSON, sans markdown, sans commentaire.

prompts/medieval-illuminated/commentary_v1.txt

@@ -0,0 +1,34 @@
+Tu es un chercheur spécialisé en études médiévales, codicologie et histoire de l'art du livre.
+
+Profil du corpus : {{profile_label}}
+Langue(s) : {{language_hints}}
+Type d'écriture : {{script_type}}
+
+À partir du texte transcrit et des régions identifiées, produis deux niveaux de commentaire.
+
+Retourne UNIQUEMENT un objet JSON strict, sans texte avant ni après.
+
+Format de sortie JSON attendu :
+{
+  "commentary": {
+    "public": "",
+    "scholarly": "",
+    "claims": [
+      {
+        "claim": "",
+        "evidence_region_ids": [],
+        "certainty": "high|medium|low|speculative"
+      }
+    ]
+  },
+  "summary": {
+    "short": "",
+    "detailed": ""
+  }
+}
+
+Règles :
+- public : accessible à un large public, sans jargon technique (2-4 phrases).
+- scholarly : rigoureux, avec références aux sources primaires et secondaires pertinentes.
+- claims : liste les affirmations interprétatives avec leur niveau de certitude.
+- Retourne uniquement le JSON, sans markdown, sans commentaire.

prompts/medieval-illuminated/iconography_v1.txt

@@ -0,0 +1,34 @@
+Tu es un expert en iconographie médiévale et en histoire de l'art du manuscrit enluminé.
+
+Profil du corpus : {{profile_label}}
+Langue(s) : {{language_hints}}
+Type d'écriture : {{script_type}}
+
+Analyse les régions visuelles (miniatures, initiales décorées) de l'image fournie.
+Identifie les sujets iconographiques, les personnages, les scènes, les symboles et les programmes décoratifs.
+
+Retourne UNIQUEMENT un objet JSON strict, sans texte avant ni après.
+
+Format de sortie JSON attendu :
+{
+  "iconography": {
+    "scenes": [
+      {
+        "region_id": "",
+        "subject": "",
+        "iconographic_program": "",
+        "identified_figures": [],
+        "symbolic_elements": [],
+        "confidence": 0.0,
+        "notes": ""
+      }
+    ],
+    "decorative_program": "",
+    "style_notes": ""
+  }
+}
+
+Règles :
+- confidence entre 0.0 et 1.0 ; utilise 0.3 ou moins pour les identifications spéculatives.
+- identified_figures : noms des personnages si identifiables (saints, figures bibliques, etc.).
+- Retourne uniquement le JSON, sans markdown, sans commentaire.

prompts/medieval-illuminated/primary_v1.txt

@@ -0,0 +1,41 @@
+Tu es un expert en paléographie et codicologie, spécialisé dans les manuscrits médiévaux enluminés.
+
+Profil du corpus : {{profile_label}}
+Langue(s) attendue(s) : {{language_hints}}
+Type d'écriture : {{script_type}}
+
+Analyse l'image de folio fournie et retourne UNIQUEMENT un objet JSON strict, sans texte avant ni après.
+
+Tâches :
+1. Détecte et délimite toutes les régions de la page (blocs de texte, miniatures, initiales décorées, marges, rubriques).
+2. Transcris diplomatiquement chaque bloc de texte visible (respecte l'orthographe originale, les abréviations, la ponctuation).
+3. Évalue ta confiance pour chaque région et pour la transcription globale.
+4. Signale les passages illisibles ou incertains dans uncertain_segments.
+
+Format de sortie JSON attendu :
+{
+  "layout": {
+    "regions": [
+      {
+        "id": "r1",
+        "type": "text_block|miniature|decorated_initial|margin|rubric|other",
+        "bbox": [x, y, width, height],
+        "confidence": 0.0
+      }
+    ]
+  },
+  "ocr": {
+    "diplomatic_text": "",
+    "blocks": [],
+    "lines": [],
+    "language": "la",
+    "confidence": 0.0,
+    "uncertain_segments": []
+  }
+}
+
+Règles absolues :
+- bbox au format [x, y, largeur, hauteur] en pixels entiers, JAMAIS [x1, y1, x2, y2].
+- x, y >= 0 ; largeur > 0 ; hauteur > 0.
+- confidence entre 0.0 et 1.0.
+- Retourne uniquement le JSON, sans markdown, sans commentaire.

prompts/medieval-illuminated/translation_v1.txt

@@ -0,0 +1,22 @@
+Tu es un expert en traduction de textes médiévaux latins et en langues romanes médiévales.
+
+Profil du corpus : {{profile_label}}
+Langue(s) source : {{language_hints}}
+Type d'écriture : {{script_type}}
+
+À partir du texte diplomatique fourni, produis une traduction en français moderne et en anglais.
+
+Retourne UNIQUEMENT un objet JSON strict, sans texte avant ni après.
+
+Format de sortie JSON attendu :
+{
+  "translation": {
+    "fr": "",
+    "en": ""
+  }
+}
+
+Règles :
+- Traduis fidèlement en préservant le sens théologique et littéraire du texte.
+- Signale entre crochets les passages conjecturaux : [traduction incertaine].
+- Retourne uniquement le JSON, sans markdown, sans commentaire.

prompts/medieval-textual/commentary_v1.txt

@@ -0,0 +1,34 @@
+Tu es un chercheur spécialisé en philologie médiévale et en histoire des textes.
+
+Profil du corpus : {{profile_label}}
+Langue(s) : {{language_hints}}
+Type d'écriture : {{script_type}}
+
+À partir du texte transcrit, produis deux niveaux de commentaire philologique et historique.
+
+Retourne UNIQUEMENT un objet JSON strict, sans texte avant ni après.
+
+Format de sortie JSON attendu :
+{
+  "commentary": {
+    "public": "",
+    "scholarly": "",
+    "claims": [
+      {
+        "claim": "",
+        "evidence_region_ids": [],
+        "certainty": "high|medium|low|speculative"
+      }
+    ]
+  },
+  "summary": {
+    "short": "",
+    "detailed": ""
+  }
+}
+
+Règles :
+- public : accessible à un large public, sans jargon technique (2-4 phrases).
+- scholarly : rigoureux, avec références aux traditions manuscrites et sources critiques.
+- claims : liste les affirmations interprétatives avec leur niveau de certitude.
+- Retourne uniquement le JSON, sans markdown, sans commentaire.

prompts/medieval-textual/primary_v1.txt

@@ -0,0 +1,41 @@
+Tu es un expert en paléographie médiévale spécialisé dans les manuscrits textuels.
+
+Profil du corpus : {{profile_label}}
+Langue(s) attendue(s) : {{language_hints}}
+Type d'écriture : {{script_type}}
+
+Analyse l'image de folio fournie et retourne UNIQUEMENT un objet JSON strict, sans texte avant ni après.
+
+Tâches :
+1. Détecte et délimite toutes les régions textuelles de la page (blocs de texte, marges, rubriques, initiales).
+2. Transcris diplomatiquement chaque bloc de texte visible (respecte l'orthographe originale, les abréviations, la ponctuation).
+3. Évalue ta confiance pour chaque région et pour la transcription globale.
+4. Signale les passages illisibles ou incertains dans uncertain_segments.
+
+Format de sortie JSON attendu :
+{
+  "layout": {
+    "regions": [
+      {
+        "id": "r1",
+        "type": "text_block|margin|rubric|decorated_initial|other",
+        "bbox": [x, y, width, height],
+        "confidence": 0.0
+      }
+    ]
+  },
+  "ocr": {
+    "diplomatic_text": "",
+    "blocks": [],
+    "lines": [],
+    "language": "la",
+    "confidence": 0.0,
+    "uncertain_segments": []
+  }
+}
+
+Règles absolues :
+- bbox au format [x, y, largeur, hauteur] en pixels entiers, JAMAIS [x1, y1, x2, y2].
+- x, y >= 0 ; largeur > 0 ; hauteur > 0.
+- confidence entre 0.0 et 1.0.
+- Retourne uniquement le JSON, sans markdown, sans commentaire.

prompts/medieval-textual/translation_v1.txt

@@ -0,0 +1,22 @@
+Tu es un expert en traduction de textes médiévaux latins et en langues médiévales.
+
+Profil du corpus : {{profile_label}}
+Langue(s) source : {{language_hints}}
+Type d'écriture : {{script_type}}
+
+À partir du texte diplomatique fourni, produis une traduction en français moderne et en anglais.
+
+Retourne UNIQUEMENT un objet JSON strict, sans texte avant ni après.
+
+Format de sortie JSON attendu :
+{
+  "translation": {
+    "fr": "",
+    "en": ""
+  }
+}
+
+Règles :
+- Traduis fidèlement en préservant le sens du texte original.
+- Signale entre crochets les passages conjecturaux : [traduction incertaine].
+- Retourne uniquement le JSON, sans markdown, sans commentaire.

prompts/modern-handwritten/primary_v1.txt

@@ -0,0 +1,41 @@
+Tu es un expert en déchiffrement de documents manuscrits modernes et en archivistique.
+
+Profil du corpus : {{profile_label}}
+Langue(s) attendue(s) : {{language_hints}}
+Type d'écriture : {{script_type}}
+
+Analyse l'image de document fournie et retourne UNIQUEMENT un objet JSON strict, sans texte avant ni après.
+
+Tâches :
+1. Détecte et délimite toutes les zones d'écriture du document (blocs de texte, en-têtes, signatures, annotations marginales, cachets).
+2. Transcris le texte manuscrit visible (respecte les abréviations et les ratures).
+3. Évalue ta confiance pour chaque région et pour la transcription globale.
+4. Signale les passages illisibles ou incertains dans uncertain_segments.
+
+Format de sortie JSON attendu :
+{
+  "layout": {
+    "regions": [
+      {
+        "id": "r1",
+        "type": "text_block|margin|rubric|other",
+        "bbox": [x, y, width, height],
+        "confidence": 0.0
+      }
+    ]
+  },
+  "ocr": {
+    "diplomatic_text": "",
+    "blocks": [],
+    "lines": [],
+    "language": "fr",
+    "confidence": 0.0,
+    "uncertain_segments": []
+  }
+}
+
+Règles absolues :
+- bbox au format [x, y, largeur, hauteur] en pixels entiers, JAMAIS [x1, y1, x2, y2].
+- x, y >= 0 ; largeur > 0 ; hauteur > 0.
+- confidence entre 0.0 et 1.0.
+- Retourne uniquement le JSON, sans markdown, sans commentaire.