feat(sprint6-B): validation éditoriale + recherche plein texte

Backend :
- POST /api/v1/pages/{id}/corrections — corrections partielles avec
versionnement automatique (archive master_v{n}.json, incrémente version)
- GET /api/v1/pages/{id}/history — liste des versions archivées
- GET /api/v1/search?q= — recherche plein texte dans les master.json
(ocr.diplomatic_text, translation.fr, extensions.iconography[].tags),
insensible à la casse et aux accents

Tests : 26 nouveaux tests (13 corrections + 13 search), 503 au total

Frontend :
- Editor.tsx — éditeur 50/50 : visionneuse + 4 panneaux (transcription,
commentaire, régions valider/rejeter, historique avec restauration)
- SearchBar.tsx — barre de recherche debouncée 300ms avec dropdown
- App.tsx — vue editor ajoutée
- Reader.tsx — bouton "Éditer cette page" (prop onEdit)
- Home.tsx — SearchBar dans le header
- api.ts — VersionInfo, CorrectionsInput, SearchResult, fetchPage,
applyCorrections, getHistory, searchPages

https://claude.ai/code/session_018woyEHc8HG2th7V4ewJ4Kg

backend/app/api/v1/pages.py

@@ -1,21 +1,24 @@
 """
-Endpoints lecture des pages et de leur master.json (R10 — préfixe /api/v1/).
+Endpoints lecture et écriture des pages et de leur master.json (R10 — préfixe /api/v1/).
 
 GET  /api/v1/pages/{page_id}
 GET  /api/v1/pages/{page_id}/master-json
 GET  /api/v1/pages/{page_id}/layers
+POST /api/v1/pages/{page_id}/corrections
+GET  /api/v1/pages/{page_id}/history
 
-Règle (R02) : le master.json est la source canonique. Ces endpoints le lisent
-depuis data/ — ils ne reconstruisent jamais une réponse depuis d'autres sources.
+Règle (R02) : le master.json est la source canonique.
 """
 # 1. stdlib
 import json
 import logging
+from datetime import datetime, timezone
 from pathlib import Path
+from typing import Any
 
 # 2. third-party
 from fastapi import APIRouter, Depends, HTTPException
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, ValidationError
 from sqlalchemy.ext.asyncio import AsyncSession
 
 # 3. local
@@ -32,6 +35,27 @@ router = APIRouter(prefix="/pages", tags=["pages"])
 
 # ── Schémas de réponse ────────────────────────────────────────────────────────
 
+class CorrectionsRequest(BaseModel):
+    """Corrections partielles du master.json. Tous les champs sont optionnels.
+
+    Si restore_to_version est fourni, les autres champs sont ignorés et la version
+    indiquée est restaurée (avec incrémentation de editorial.version).
+    """
+
+    ocr_diplomatic_text: str | None = None
+    editorial_status: str | None = None
+    commentary_public: str | None = None
+    commentary_scholarly: str | None = None
+    region_validations: dict[str, str] | None = None
+    restore_to_version: int | None = None
+
+
+class VersionInfo(BaseModel):
+    version: int
+    saved_at: datetime
+    status: str
+
+
 class PageResponse(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 
@@ -82,6 +106,87 @@ async def _load_master(
     return PageMaster.model_validate(raw)
 
 
+# ── Helpers corrections & versioning ──────────────────────────────────────────
+
+async def _get_page_dir(page: PageModel, db: AsyncSession) -> Path | None:
+    """Retourne le répertoire data/corpora/{slug}/pages/{page.id} ou None."""
+    manuscript = await db.get(ManuscriptModel, page.manuscript_id)
+    if manuscript is None:
+        return None
+    corpus = await db.get(CorpusModel, manuscript.corpus_id)
+    if corpus is None:
+        return None
+    return (
+        _config_module.settings.data_dir
+        / "corpora"
+        / corpus.slug
+        / "pages"
+        / page.id
+    )
+
+
+def _archive_master(page_dir: Path, master: PageMaster) -> None:
+    """Archive master.json sous master_v{version}.json avant toute modification."""
+    archive_path = page_dir / f"master_v{master.editorial.version}.json"
+    archive_path.write_text(
+        json.dumps(master.model_dump(mode="json"), ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+
+
+def _write_master(page_dir: Path, master: PageMaster) -> None:
+    """Écrit le master.json validé sur le disque."""
+    master_path = page_dir / "master.json"
+    master_path.write_text(
+        json.dumps(master.model_dump(mode="json"), ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+
+
+def _apply_corrections_to_master(
+    master: PageMaster, req: CorrectionsRequest
+) -> PageMaster:
+    """Applique les corrections partielles et incrémente editorial.version."""
+    data: dict[str, Any] = master.model_dump(mode="json")
+
+    if req.ocr_diplomatic_text is not None:
+        if data.get("ocr") is None:
+            data["ocr"] = {
+                "diplomatic_text": "",
+                "blocks": [],
+                "lines": [],
+                "language": "la",
+                "confidence": 0.0,
+                "uncertain_segments": [],
+            }
+        data["ocr"]["diplomatic_text"] = req.ocr_diplomatic_text
+
+    if req.editorial_status is not None:
+        data["editorial"]["status"] = req.editorial_status
+
+    if req.commentary_public is not None:
+        if data.get("commentary") is None:
+            data["commentary"] = {"public": "", "scholarly": "", "claims": []}
+        data["commentary"]["public"] = req.commentary_public
+
+    if req.commentary_scholarly is not None:
+        if data.get("commentary") is None:
+            data["commentary"] = {"public": "", "scholarly": "", "claims": []}
+        data["commentary"]["scholarly"] = req.commentary_scholarly
+
+    if req.region_validations is not None:
+        existing: dict[str, str] = (
+            data.get("extensions", {}).get("region_validations") or {}
+        )
+        existing.update(req.region_validations)
+        if "extensions" not in data:
+            data["extensions"] = {}
+        data["extensions"]["region_validations"] = existing
+
+    data["editorial"]["version"] += 1
+    return PageMaster.model_validate(data)
+
+
 # ── Endpoints ─────────────────────────────────────────────────────────────────
 
 @router.get("/{page_id}", response_model=PageResponse)
@@ -201,3 +306,97 @@ async def get_page_layers(
         extra={"page_id": page_id, "count": len(layers)},
     )
     return layers
+
+
+@router.post("/{page_id}/corrections")
+async def apply_corrections(
+    page_id: str,
+    body: CorrectionsRequest,
+    db: AsyncSession = Depends(get_db),
+) -> dict:
+    """Applique des corrections partielles au master.json.
+
+    Avant toute modification, l'état courant est archivé sous master_v{n}.json.
+    editorial.version est incrémenté à chaque correction.
+    Si restore_to_version est fourni, restaure la version archivée demandée.
+    """
+    page = await db.get(PageModel, page_id)
+    if page is None:
+        raise HTTPException(status_code=404, detail="Page introuvable")
+
+    master = await _load_master(page, db)
+    if master is None:
+        raise HTTPException(
+            status_code=404,
+            detail="master.json introuvable — la page n'a pas encore été analysée",
+        )
+
+    page_dir = await _get_page_dir(page, db)
+    if page_dir is None:
+        raise HTTPException(status_code=500, detail="Répertoire de page introuvable")
+
+    if body.restore_to_version is not None:
+        archive_path = page_dir / f"master_v{body.restore_to_version}.json"
+        if not archive_path.exists():
+            raise HTTPException(
+                status_code=404,
+                detail=f"Version {body.restore_to_version} introuvable",
+            )
+        _archive_master(page_dir, master)
+        old_data: dict[str, Any] = json.loads(archive_path.read_text(encoding="utf-8"))
+        old_data["editorial"]["version"] = master.editorial.version + 1
+        try:
+            new_master = PageMaster.model_validate(old_data)
+        except ValidationError as exc:
+            raise HTTPException(status_code=422, detail=str(exc)) from exc
+    else:
+        _archive_master(page_dir, master)
+        try:
+            new_master = _apply_corrections_to_master(master, body)
+        except ValidationError as exc:
+            raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+    _write_master(page_dir, new_master)
+    logger.info(
+        "Corrections appliquées",
+        extra={"page_id": page_id, "version": new_master.editorial.version},
+    )
+    return new_master.model_dump(mode="json")
+
+
+@router.get("/{page_id}/history", response_model=list[VersionInfo])
+async def get_page_history(
+    page_id: str,
+    db: AsyncSession = Depends(get_db),
+) -> list[VersionInfo]:
+    """Liste les versions archivées du master.json (master_v*.json).
+
+    Retourne [] si le répertoire de page n'existe pas encore.
+    """
+    page = await db.get(PageModel, page_id)
+    if page is None:
+        raise HTTPException(status_code=404, detail="Page introuvable")
+
+    page_dir = await _get_page_dir(page, db)
+    if page_dir is None:
+        raise HTTPException(status_code=500, detail="Répertoire de page introuvable")
+
+    if not page_dir.exists():
+        return []
+
+    versions: list[VersionInfo] = []
+    for vpath in sorted(page_dir.glob("master_v*.json")):
+        try:
+            data = json.loads(vpath.read_text(encoding="utf-8"))
+            version_num = data.get("editorial", {}).get("version", 0)
+            status = data.get("editorial", {}).get("status", "machine_draft")
+            saved_at = datetime.fromtimestamp(
+                vpath.stat().st_mtime, tz=timezone.utc
+            )
+            versions.append(
+                VersionInfo(version=version_num, saved_at=saved_at, status=status)
+            )
+        except (json.JSONDecodeError, KeyError, OSError):
+            continue
+
+    return sorted(versions, key=lambda v: v.version)

backend/app/api/v1/search.py

@@ -0,0 +1,134 @@
+"""
+Endpoint de recherche plein texte (R10 — préfixe /api/v1/).
+
+GET /api/v1/search?q={query}
+
+Implémentation MVP : scan des fichiers master.json (pas d'index externe).
+Insensible à la casse et aux accents (unicodedata NFD + ASCII).
+"""
+# 1. stdlib
+import json
+import logging
+import unicodedata
+from pathlib import Path
+
+# 2. third-party
+from fastapi import APIRouter, Query
+from pydantic import BaseModel
+
+# 3. local
+from app import config as _config_module
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["search"])
+
+
+# ── Schémas ───────────────────────────────────────────────────────────────────
+
+class SearchResult(BaseModel):
+    page_id: str
+    folio_label: str
+    manuscript_id: str
+    excerpt: str
+    score: int
+    corpus_profile: str
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _normalize(text: str) -> str:
+    """Minuscules + suppression des accents (NFD → ASCII)."""
+    nfd = unicodedata.normalize("NFD", text.lower())
+    return nfd.encode("ascii", "ignore").decode("ascii")
+
+
+def _excerpt(text: str, query_normalized: str, context: int = 120) -> str:
+    """Extrait un contexte autour de la première occurrence de la requête."""
+    text_n = _normalize(text)
+    idx = text_n.find(query_normalized)
+    if idx == -1:
+        return text[: context * 2]
+    start = max(0, idx - context // 2)
+    end = min(len(text), idx + len(query_normalized) + context // 2)
+    result = text[start:end]
+    if start > 0:
+        result = "…" + result
+    if end < len(text):
+        result = result + "…"
+    return result
+
+
+def _score_master(data: dict, query_normalized: str) -> tuple[int, str]:
+    """Retourne (nombre d'occurrences, premier extrait) pour un master.json."""
+    texts: list[str] = []
+
+    if data.get("ocr") and data["ocr"].get("diplomatic_text"):
+        texts.append(data["ocr"]["diplomatic_text"])
+
+    if data.get("translation") and data["translation"].get("fr"):
+        texts.append(data["translation"]["fr"])
+
+    # Extensions : champs iconography[].tags (profils qui les exposent)
+    extensions = data.get("extensions") or {}
+    icono = extensions.get("iconography") or []
+    if isinstance(icono, list):
+        for item in icono:
+            if isinstance(item, dict):
+                tags = item.get("tags") or []
+                if isinstance(tags, list):
+                    texts.extend(str(t) for t in tags)
+
+    count = 0
+    first_excerpt = ""
+    for text in texts:
+        n = _normalize(text)
+        hits = n.count(query_normalized)
+        count += hits
+        if hits > 0 and not first_excerpt:
+            first_excerpt = _excerpt(text, query_normalized)
+
+    return count, first_excerpt
+
+
+# ── Endpoint ──────────────────────────────────────────────────────────────────
+
+@router.get("/search", response_model=list[SearchResult])
+async def search_pages(
+    q: str = Query(..., min_length=2, description="Requête de recherche (min. 2 caractères)"),
+) -> list[SearchResult]:
+    """Recherche plein texte dans les master.json de tous les corpus.
+
+    Cherche dans : ocr.diplomatic_text, translation.fr,
+    extensions.iconography[].tags (si présent).
+    Insensible à la casse et aux accents.
+    """
+    query_normalized = _normalize(q.strip())
+    data_dir = _config_module.settings.data_dir
+
+    results: list[SearchResult] = []
+
+    for master_path in data_dir.glob("corpora/*/pages/*/master.json"):
+        try:
+            raw: dict = json.loads(master_path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            continue
+
+        score, excerpt = _score_master(raw, query_normalized)
+        if score == 0:
+            continue
+
+        results.append(
+            SearchResult(
+                page_id=raw.get("page_id", ""),
+                folio_label=raw.get("folio_label", ""),
+                manuscript_id=raw.get("manuscript_id", ""),
+                excerpt=excerpt,
+                score=score,
+                corpus_profile=raw.get("corpus_profile", ""),
+            )
+        )
+
+    results.sort(key=lambda r: r.score, reverse=True)
+    logger.info("Recherche exécutée", extra={"q": q, "results": len(results)})
+    return results

backend/app/main.py

@@ -17,7 +17,7 @@ from fastapi.responses import FileResponse, RedirectResponse
 
 # 3. local — on importe les modèles pour que Base.metadata les connaisse
 import app.models  # noqa: F401  (enregistrement des modèles SQLAlchemy)
-from app.api.v1 import corpora, export, ingest, jobs, manuscripts, models_api, pages, profiles
+from app.api.v1 import corpora, export, ingest, jobs, manuscripts, models_api, pages, profiles, search
 from app.models.database import Base, engine
 
 logger = logging.getLogger(__name__)
@@ -61,6 +61,7 @@ app.include_router(profiles.router, prefix=_V1_PREFIX)
 app.include_router(jobs.router, prefix=_V1_PREFIX)
 app.include_router(ingest.router, prefix=_V1_PREFIX)
 app.include_router(models_api.router, prefix=_V1_PREFIX)
+app.include_router(search.router, prefix=_V1_PREFIX)
 
 # ── Serving frontend SPA (production) ou redirect /docs (dev) ────────────────
 _STATIC_DIR = Path("/app/static")

backend/tests/test_api_corrections.py

@@ -0,0 +1,353 @@
+"""
+Tests des endpoints corrections et historique (Sprint 6 — Session B).
+
+POST /api/v1/pages/{id}/corrections   → corrections partielles, versionnement
+GET  /api/v1/pages/{id}/history       → liste des versions archivées
+"""
+# 1. stdlib
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+# 2. third-party
+import pytest
+
+# 3. local
+from app.models.corpus import CorpusModel, ManuscriptModel, PageModel
+from tests.conftest_api import async_client, db_session  # noqa: F401
+
+_NOW = datetime.now(timezone.utc)
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────────
+
+async def _create_corpus(db_session, slug: str = "test-corpus") -> CorpusModel:
+    corpus = CorpusModel(
+        id=str(uuid.uuid4()),
+        slug=slug,
+        title="Test Corpus",
+        profile_id="medieval-illuminated",
+        created_at=_NOW,
+        updated_at=_NOW,
+    )
+    db_session.add(corpus)
+    await db_session.commit()
+    await db_session.refresh(corpus)
+    return corpus
+
+
+async def _create_manuscript(db_session, corpus_id: str) -> ManuscriptModel:
+    ms = ManuscriptModel(
+        id=str(uuid.uuid4()),
+        corpus_id=corpus_id,
+        title="Test MS",
+        total_pages=1,
+    )
+    db_session.add(ms)
+    await db_session.commit()
+    await db_session.refresh(ms)
+    return ms
+
+
+async def _create_page(db_session, manuscript_id: str) -> PageModel:
+    page = PageModel(
+        id=str(uuid.uuid4()),
+        manuscript_id=manuscript_id,
+        folio_label="f001r",
+        sequence=1,
+        image_master_path="/data/f001r.jpg",
+        processing_status="ANALYZED",
+    )
+    db_session.add(page)
+    await db_session.commit()
+    await db_session.refresh(page)
+    return page
+
+
+def _make_master(
+    page_id: str, version: int = 1, status: str = "machine_draft"
+) -> str:
+    return json.dumps({
+        "schema_version": "1.0",
+        "page_id": page_id,
+        "corpus_profile": "medieval-illuminated",
+        "manuscript_id": "ms-test",
+        "folio_label": "f001r",
+        "sequence": 1,
+        "image": {"original_url": "https://example.com/f.jpg", "width": 1500, "height": 2000},
+        "layout": {"regions": []},
+        "ocr": {
+            "diplomatic_text": "Incipit liber primus",
+            "blocks": [], "lines": [], "language": "la",
+            "confidence": 0.87, "uncertain_segments": [],
+        },
+        "translation": {"fr": "", "en": ""},
+        "summary": None,
+        "commentary": {
+            "public": "Texte public", "scholarly": "Analyse savante", "claims": [],
+        },
+        "editorial": {
+            "status": status,
+            "validated": False, "validated_by": None,
+            "version": version, "notes": [],
+        },
+    })
+
+
+# ── POST /api/v1/pages/{id}/corrections ───────────────────────────────────────
+
+@pytest.mark.asyncio
+async def test_corrections_page_not_found(async_client):
+    resp = await async_client.post(
+        "/api/v1/pages/nonexistent/corrections",
+        json={"ocr_diplomatic_text": "texte"},
+    )
+    assert resp.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_corrections_no_master_json(async_client, db_session, monkeypatch):
+    corpus = await _create_corpus(db_session)
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    monkeypatch.setattr(Path, "exists", lambda self: False)
+
+    resp = await async_client.post(
+        f"/api/v1/pages/{page.id}/corrections",
+        json={"ocr_diplomatic_text": "texte"},
+    )
+    assert resp.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_corrections_updates_ocr_text(async_client, db_session, monkeypatch):
+    corpus = await _create_corpus(db_session)
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    monkeypatch.setattr(Path, "exists", lambda self: True)
+    monkeypatch.setattr(Path, "read_text", lambda self, **kw: _make_master(page.id))
+    monkeypatch.setattr(Path, "write_text", lambda self, content, **kw: None)
+
+    resp = await async_client.post(
+        f"/api/v1/pages/{page.id}/corrections",
+        json={"ocr_diplomatic_text": "Texte corrigé manuellement"},
+    )
+    assert resp.status_code == 200
+    assert resp.json()["ocr"]["diplomatic_text"] == "Texte corrigé manuellement"
+
+
+@pytest.mark.asyncio
+async def test_corrections_increments_version(async_client, db_session, monkeypatch):
+    corpus = await _create_corpus(db_session)
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    monkeypatch.setattr(Path, "exists", lambda self: True)
+    monkeypatch.setattr(Path, "read_text", lambda self, **kw: _make_master(page.id, version=1))
+    monkeypatch.setattr(Path, "write_text", lambda self, content, **kw: None)
+
+    resp = await async_client.post(
+        f"/api/v1/pages/{page.id}/corrections",
+        json={"editorial_status": "needs_review"},
+    )
+    assert resp.status_code == 200
+    assert resp.json()["editorial"]["version"] == 2
+
+
+@pytest.mark.asyncio
+async def test_corrections_updates_editorial_status(async_client, db_session, monkeypatch):
+    corpus = await _create_corpus(db_session)
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    monkeypatch.setattr(Path, "exists", lambda self: True)
+    monkeypatch.setattr(Path, "read_text", lambda self, **kw: _make_master(page.id))
+    monkeypatch.setattr(Path, "write_text", lambda self, content, **kw: None)
+
+    resp = await async_client.post(
+        f"/api/v1/pages/{page.id}/corrections",
+        json={"editorial_status": "reviewed"},
+    )
+    assert resp.status_code == 200
+    assert resp.json()["editorial"]["status"] == "reviewed"
+
+
+@pytest.mark.asyncio
+async def test_corrections_updates_commentary_public(async_client, db_session, monkeypatch):
+    corpus = await _create_corpus(db_session)
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    monkeypatch.setattr(Path, "exists", lambda self: True)
+    monkeypatch.setattr(Path, "read_text", lambda self, **kw: _make_master(page.id))
+    monkeypatch.setattr(Path, "write_text", lambda self, content, **kw: None)
+
+    resp = await async_client.post(
+        f"/api/v1/pages/{page.id}/corrections",
+        json={"commentary_public": "Commentaire public révisé"},
+    )
+    assert resp.status_code == 200
+    assert resp.json()["commentary"]["public"] == "Commentaire public révisé"
+
+
+@pytest.mark.asyncio
+async def test_corrections_updates_commentary_scholarly(async_client, db_session, monkeypatch):
+    corpus = await _create_corpus(db_session)
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    monkeypatch.setattr(Path, "exists", lambda self: True)
+    monkeypatch.setattr(Path, "read_text", lambda self, **kw: _make_master(page.id))
+    monkeypatch.setattr(Path, "write_text", lambda self, content, **kw: None)
+
+    resp = await async_client.post(
+        f"/api/v1/pages/{page.id}/corrections",
+        json={"commentary_scholarly": "Analyse savante révisée"},
+    )
+    assert resp.status_code == 200
+    assert resp.json()["commentary"]["scholarly"] == "Analyse savante révisée"
+
+
+@pytest.mark.asyncio
+async def test_corrections_region_validations(async_client, db_session, monkeypatch):
+    corpus = await _create_corpus(db_session)
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    monkeypatch.setattr(Path, "exists", lambda self: True)
+    monkeypatch.setattr(Path, "read_text", lambda self, **kw: _make_master(page.id))
+    monkeypatch.setattr(Path, "write_text", lambda self, content, **kw: None)
+
+    resp = await async_client.post(
+        f"/api/v1/pages/{page.id}/corrections",
+        json={"region_validations": {"r001": "validated", "r002": "rejected"}},
+    )
+    assert resp.status_code == 200
+    validations = resp.json().get("extensions", {}).get("region_validations", {})
+    assert validations.get("r001") == "validated"
+    assert validations.get("r002") == "rejected"
+
+
+@pytest.mark.asyncio
+async def test_corrections_archives_old_version(async_client, db_session, monkeypatch):
+    """Vérifie qu'une copie master_v1.json est écrite avant la correction."""
+    corpus = await _create_corpus(db_session)
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    written_paths: list[str] = []
+
+    monkeypatch.setattr(Path, "exists", lambda self: True)
+    monkeypatch.setattr(Path, "read_text", lambda self, **kw: _make_master(page.id, version=1))
+
+    def _capture_write(self: Path, content: str, **kw: object) -> None:
+        written_paths.append(str(self))
+
+    monkeypatch.setattr(Path, "write_text", _capture_write)
+
+    await async_client.post(
+        f"/api/v1/pages/{page.id}/corrections",
+        json={"editorial_status": "needs_review"},
+    )
+
+    # Deux écritures attendues : master_v1.json (archive) + master.json (nouveau)
+    assert len(written_paths) >= 2
+    assert any("master_v1.json" in p for p in written_paths)
+    assert any("master.json" in p and "master_v" not in p for p in written_paths)
+
+
+@pytest.mark.asyncio
+async def test_corrections_multiple_fields(async_client, db_session, monkeypatch):
+    """Plusieurs corrections peuvent être envoyées en un seul appel."""
+    corpus = await _create_corpus(db_session)
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    monkeypatch.setattr(Path, "exists", lambda self: True)
+    monkeypatch.setattr(Path, "read_text", lambda self, **kw: _make_master(page.id))
+    monkeypatch.setattr(Path, "write_text", lambda self, content, **kw: None)
+
+    resp = await async_client.post(
+        f"/api/v1/pages/{page.id}/corrections",
+        json={
+            "ocr_diplomatic_text": "Nouveau texte diplomatique",
+            "editorial_status": "reviewed",
+            "commentary_public": "Nouveau commentaire",
+        },
+    )
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["ocr"]["diplomatic_text"] == "Nouveau texte diplomatique"
+    assert data["editorial"]["status"] == "reviewed"
+    assert data["commentary"]["public"] == "Nouveau commentaire"
+    assert data["editorial"]["version"] == 2
+
+
+# ── GET /api/v1/pages/{id}/history ────────────────────────────────────────────
+
+@pytest.mark.asyncio
+async def test_history_page_not_found(async_client):
+    resp = await async_client.get("/api/v1/pages/nonexistent/history")
+    assert resp.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_history_returns_empty_list_when_no_dir(async_client, db_session, monkeypatch):
+    """Retourne [] si le répertoire de page n'existe pas."""
+    corpus = await _create_corpus(db_session)
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    monkeypatch.setattr(Path, "exists", lambda self: False)
+
+    resp = await async_client.get(f"/api/v1/pages/{page.id}/history")
+    assert resp.status_code == 200
+    assert resp.json() == []
+
+
+@pytest.mark.asyncio
+async def test_history_returns_list(async_client, db_session, monkeypatch):
+    """Le type de retour est une liste (même vide)."""
+    corpus = await _create_corpus(db_session)
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    monkeypatch.setattr(Path, "exists", lambda self: False)
+
+    resp = await async_client.get(f"/api/v1/pages/{page.id}/history")
+    assert resp.status_code == 200
+    assert isinstance(resp.json(), list)
+
+
+@pytest.mark.asyncio
+async def test_history_with_archived_files(async_client, db_session, tmp_path, monkeypatch):
+    """Retourne les versions trouvées dans les fichiers master_v*.json."""
+    corpus = await _create_corpus(db_session, slug="hist-corpus")
+    ms = await _create_manuscript(db_session, corpus.id)
+    page = await _create_page(db_session, ms.id)
+
+    # Crée le répertoire avec des fichiers de version
+    page_dir = tmp_path / "corpora" / corpus.slug / "pages" / page.id
+    page_dir.mkdir(parents=True)
+    (page_dir / "master_v1.json").write_text(_make_master(page.id, version=1, status="machine_draft"))
+    (page_dir / "master_v2.json").write_text(_make_master(page.id, version=2, status="reviewed"))
+
+    import app.api.v1.pages as pages_module
+    import app.config as config_mod
+
+    original_data_dir = config_mod.settings.data_dir
+    config_mod.settings.__dict__["data_dir"] = tmp_path
+    try:
+        resp = await async_client.get(f"/api/v1/pages/{page.id}/history")
+    finally:
+        config_mod.settings.__dict__["data_dir"] = original_data_dir
+
+    assert resp.status_code == 200
+    versions = resp.json()
+    assert len(versions) == 2
+    statuses = [v["status"] for v in versions]
+    assert "machine_draft" in statuses
+    assert "reviewed" in statuses

backend/tests/test_api_search.py

@@ -0,0 +1,280 @@
+"""
+Tests de l'endpoint GET /api/v1/search (Sprint 6 — Session B).
+
+Stratégie :
+  - Fichiers master.json réels dans tmp_path
+  - Override de settings.data_dir pour pointer sur tmp_path
+  - Vérifie : 422 (paramètre manquant / trop court), résultats vides,
+    correspondance OCR, insensibilité casse et accents, tri par score,
+    extrait (excerpt) présent.
+"""
+# 1. stdlib
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+# 2. third-party
+import pytest
+
+# 3. local
+from tests.conftest_api import async_client, db_session  # noqa: F401
+
+_NOW = datetime.now(timezone.utc)
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────────
+
+def _make_master(page_id: str, diplomatic_text: str = "", translation_fr: str = "") -> dict:
+    return {
+        "schema_version": "1.0",
+        "page_id": page_id,
+        "corpus_profile": "medieval-illuminated",
+        "manuscript_id": "ms-test",
+        "folio_label": "f001r",
+        "sequence": 1,
+        "image": {"original_url": "https://example.com/f.jpg", "width": 1500, "height": 2000},
+        "layout": {"regions": []},
+        "ocr": {
+            "diplomatic_text": diplomatic_text,
+            "blocks": [], "lines": [], "language": "la",
+            "confidence": 0.87, "uncertain_segments": [],
+        },
+        "translation": {"fr": translation_fr, "en": ""},
+        "summary": None,
+        "commentary": {"public": "", "scholarly": "", "claims": []},
+        "editorial": {
+            "status": "machine_draft",
+            "validated": False, "validated_by": None,
+            "version": 1, "notes": [],
+        },
+    }
+
+
+def _write_master(tmp_path: Path, corpus_slug: str, page_id: str, data: dict) -> None:
+    page_dir = tmp_path / "corpora" / corpus_slug / "pages" / page_id
+    page_dir.mkdir(parents=True)
+    (page_dir / "master.json").write_text(json.dumps(data), encoding="utf-8")
+
+
+# ── Tests ──────────────────────────────────────────────────────────────────────
+
+@pytest.mark.asyncio
+async def test_search_missing_q(async_client):
+    """q est obligatoire — 422 si absent."""
+    resp = await async_client.get("/api/v1/search")
+    assert resp.status_code == 422
+
+
+@pytest.mark.asyncio
+async def test_search_q_too_short(async_client):
+    """q doit faire au moins 2 caractères — 422 si trop court."""
+    resp = await async_client.get("/api/v1/search?q=a")
+    assert resp.status_code == 422
+
+
+@pytest.mark.asyncio
+async def test_search_empty_results(async_client, tmp_path):
+    """Retourne [] quand aucun master.json ne correspond."""
+    import app.config as config_mod
+    original = config_mod.settings.data_dir
+    config_mod.settings.__dict__["data_dir"] = tmp_path
+    try:
+        resp = await async_client.get("/api/v1/search?q=rien")
+    finally:
+        config_mod.settings.__dict__["data_dir"] = original
+
+    assert resp.status_code == 200
+    assert resp.json() == []
+
+
+@pytest.mark.asyncio
+async def test_search_returns_list(async_client, tmp_path):
+    """Le type de retour est toujours une liste."""
+    import app.config as config_mod
+    original = config_mod.settings.data_dir
+    config_mod.settings.__dict__["data_dir"] = tmp_path
+    try:
+        resp = await async_client.get("/api/v1/search?q=texte")
+    finally:
+        config_mod.settings.__dict__["data_dir"] = original
+
+    assert resp.status_code == 200
+    assert isinstance(resp.json(), list)
+
+
+@pytest.mark.asyncio
+async def test_search_finds_ocr_text(async_client, tmp_path):
+    """Trouve un master.json dont ocr.diplomatic_text contient la requête."""
+    import app.config as config_mod
+
+    page_id = str(uuid.uuid4())
+    _write_master(tmp_path, "corpus-a", page_id, _make_master(page_id, diplomatic_text="Incipit liber primus"))
+
+    original = config_mod.settings.data_dir
+    config_mod.settings.__dict__["data_dir"] = tmp_path
+    try:
+        resp = await async_client.get("/api/v1/search?q=Incipit")
+    finally:
+        config_mod.settings.__dict__["data_dir"] = original
+
+    assert resp.status_code == 200
+    results = resp.json()
+    assert len(results) == 1
+    assert results[0]["page_id"] == page_id
+
+
+@pytest.mark.asyncio
+async def test_search_case_insensitive(async_client, tmp_path):
+    """La recherche est insensible à la casse."""
+    import app.config as config_mod
+
+    page_id = str(uuid.uuid4())
+    _write_master(tmp_path, "corpus-b", page_id, _make_master(page_id, diplomatic_text="INCIPIT LIBER"))
+
+    original = config_mod.settings.data_dir
+    config_mod.settings.__dict__["data_dir"] = tmp_path
+    try:
+        resp = await async_client.get("/api/v1/search?q=incipit")
+    finally:
+        config_mod.settings.__dict__["data_dir"] = original
+
+    assert resp.status_code == 200
+    results = resp.json()
+    assert len(results) >= 1
+    assert any(r["page_id"] == page_id for r in results)
+
+
+@pytest.mark.asyncio
+async def test_search_accent_insensitive(async_client, tmp_path):
+    """La recherche est insensible aux accents."""
+    import app.config as config_mod
+
+    page_id = str(uuid.uuid4())
+    _write_master(tmp_path, "corpus-c", page_id, _make_master(page_id, diplomatic_text="Édition française médiévale"))
+
+    original = config_mod.settings.data_dir
+    config_mod.settings.__dict__["data_dir"] = tmp_path
+    try:
+        resp = await async_client.get("/api/v1/search?q=edition")
+    finally:
+        config_mod.settings.__dict__["data_dir"] = original
+
+    assert resp.status_code == 200
+    results = resp.json()
+    assert len(results) >= 1
+    assert any(r["page_id"] == page_id for r in results)
+
+
+@pytest.mark.asyncio
+async def test_search_finds_translation_fr(async_client, tmp_path):
+    """Trouve également dans translation.fr."""
+    import app.config as config_mod
+
+    page_id = str(uuid.uuid4())
+    _write_master(tmp_path, "corpus-d", page_id, _make_master(page_id, translation_fr="Ici commence le premier livre"))
+
+    original = config_mod.settings.data_dir
+    config_mod.settings.__dict__["data_dir"] = tmp_path
+    try:
+        resp = await async_client.get("/api/v1/search?q=premier")
+    finally:
+        config_mod.settings.__dict__["data_dir"] = original
+
+    assert resp.status_code == 200
+    results = resp.json()
+    assert any(r["page_id"] == page_id for r in results)
+
+
+@pytest.mark.asyncio
+async def test_search_no_match_returns_empty(async_client, tmp_path):
+    """Ne retourne rien quand la requête ne correspond à aucun texte."""
+    import app.config as config_mod
+
+    page_id = str(uuid.uuid4())
+    _write_master(tmp_path, "corpus-e", page_id, _make_master(page_id, diplomatic_text="Incipit liber"))
+
+    original = config_mod.settings.data_dir
+    config_mod.settings.__dict__["data_dir"] = tmp_path
+    try:
+        resp = await async_client.get("/api/v1/search?q=xyznomatch")
+    finally:
+        config_mod.settings.__dict__["data_dir"] = original
+
+    assert resp.status_code == 200
+    assert resp.json() == []
+
+
+@pytest.mark.asyncio
+async def test_search_result_has_excerpt(async_client, tmp_path):
+    """Chaque résultat contient un champ excerpt non vide."""
+    import app.config as config_mod
+
+    page_id = str(uuid.uuid4())
+    _write_master(tmp_path, "corpus-f", page_id, _make_master(page_id, diplomatic_text="Incipit liber primus"))
+
+    original = config_mod.settings.data_dir
+    config_mod.settings.__dict__["data_dir"] = tmp_path
+    try:
+        resp = await async_client.get("/api/v1/search?q=liber")
+    finally:
+        config_mod.settings.__dict__["data_dir"] = original
+
+    assert resp.status_code == 200
+    results = resp.json()
+    assert len(results) >= 1
+    assert results[0]["excerpt"] != ""
+
+
+@pytest.mark.asyncio
+async def test_search_sorted_by_score_desc(async_client, tmp_path):
+    """Les résultats sont triés par score décroissant."""
+    import app.config as config_mod
+
+    page_id_1 = str(uuid.uuid4())
+    page_id_2 = str(uuid.uuid4())
+    # page_id_1 contient 3 occurrences, page_id_2 en contient 1
+    _write_master(tmp_path, "corpus-g", page_id_1, _make_master(
+        page_id_1, diplomatic_text="liber liber liber"
+    ))
+    _write_master(tmp_path, "corpus-g", page_id_2, _make_master(
+        page_id_2, diplomatic_text="liber unus"
+    ))
+
+    original = config_mod.settings.data_dir
+    config_mod.settings.__dict__["data_dir"] = tmp_path
+    try:
+        resp = await async_client.get("/api/v1/search?q=liber")
+    finally:
+        config_mod.settings.__dict__["data_dir"] = original
+
+    assert resp.status_code == 200
+    results = resp.json()
+    assert len(results) == 2
+    assert results[0]["score"] >= results[1]["score"]
+    assert results[0]["page_id"] == page_id_1
+
+
+@pytest.mark.asyncio
+async def test_search_result_fields(async_client, tmp_path):
+    """Chaque résultat expose les champs attendus."""
+    import app.config as config_mod
+
+    page_id = str(uuid.uuid4())
+    _write_master(tmp_path, "corpus-h", page_id, _make_master(page_id, diplomatic_text="Incipit liber"))
+
+    original = config_mod.settings.data_dir
+    config_mod.settings.__dict__["data_dir"] = tmp_path
+    try:
+        resp = await async_client.get("/api/v1/search?q=Incipit")
+    finally:
+        config_mod.settings.__dict__["data_dir"] = original
+
+    assert resp.status_code == 200
+    result = resp.json()[0]
+    assert "page_id" in result
+    assert "folio_label" in result
+    assert "manuscript_id" in result
+    assert "excerpt" in result
+    assert "score" in result
+    assert "corpus_profile" in result

frontend/src/App.tsx

@@ -1,5 +1,6 @@
 import { useState } from 'react'
 import Admin from './pages/Admin.tsx'
+import Editor from './pages/Editor.tsx'
 import Home from './pages/Home.tsx'
 import Reader from './pages/Reader.tsx'
 
@@ -7,6 +8,7 @@ type View =
   | { name: 'home' }
   | { name: 'reader'; manuscriptId: string; profileId: string }
   | { name: 'admin' }
+  | { name: 'editor'; pageId: string }
 
 export default function App() {
   const [view, setView] = useState<View>({ name: 'home' })
@@ -17,6 +19,7 @@ export default function App() {
         manuscriptId={view.manuscriptId}
         profileId={view.profileId}
         onBack={() => setView({ name: 'home' })}
+        onEdit={(pageId) => setView({ name: 'editor', pageId })}
       />
     )
   }
@@ -25,6 +28,15 @@ export default function App() {
     return <Admin onHome={() => setView({ name: 'home' })} />
   }
 
+  if (view.name === 'editor') {
+    return (
+      <Editor
+        pageId={view.pageId}
+        onBack={() => setView({ name: 'home' })}
+      />
+    )
+  }
+
   return (
     <Home
       onOpenManuscript={(manuscriptId, profileId) =>

frontend/src/components/SearchBar.tsx

@@ -0,0 +1,108 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { searchPages, type SearchResult } from '../lib/api.ts'
+
+interface Props {
+  onSelectResult?: (result: SearchResult) => void
+}
+
+export default function SearchBar({ onSelectResult }: Props) {
+  const [query, setQuery] = useState('')
+  const [results, setResults] = useState<SearchResult[]>([])
+  const [open, setOpen] = useState(false)
+  const [loading, setLoading] = useState(false)
+  const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const containerRef = useRef<HTMLDivElement>(null)
+
+  const runSearch = useCallback(async (q: string) => {
+    if (q.trim().length < 2) {
+      setResults([])
+      setOpen(false)
+      return
+    }
+    setLoading(true)
+    try {
+      const res = await searchPages(q.trim())
+      setResults(res)
+      setOpen(true)
+    } catch {
+      setResults([])
+    } finally {
+      setLoading(false)
+    }
+  }, [])
+
+  useEffect(() => {
+    if (debounceRef.current) clearTimeout(debounceRef.current)
+    debounceRef.current = setTimeout(() => {
+      void runSearch(query)
+    }, 300)
+    return () => {
+      if (debounceRef.current) clearTimeout(debounceRef.current)
+    }
+  }, [query, runSearch])
+
+  // Close dropdown on outside click
+  useEffect(() => {
+    const handler = (e: MouseEvent) => {
+      if (containerRef.current && !containerRef.current.contains(e.target as Node)) {
+        setOpen(false)
+      }
+    }
+    document.addEventListener('mousedown', handler)
+    return () => document.removeEventListener('mousedown', handler)
+  }, [])
+
+  return (
+    <div ref={containerRef} className="relative w-72">
+      <div className="relative">
+        <input
+          type="search"
+          value={query}
+          onChange={(e) => setQuery(e.target.value)}
+          onFocus={() => results.length > 0 && setOpen(true)}
+          placeholder="Rechercher dans les manuscrits…"
+          className="w-full bg-stone-800 text-stone-100 placeholder-stone-500 text-sm px-3 py-1.5 pr-8 rounded-md border border-stone-700 focus:outline-none focus:border-amber-500 focus:ring-1 focus:ring-amber-500"
+        />
+        {loading && (
+          <span className="absolute right-2.5 top-1/2 -translate-y-1/2 text-stone-400 text-xs">
+            …
+          </span>
+        )}
+      </div>
+
+      {open && (
+        <div className="absolute top-full left-0 right-0 mt-1 bg-white border border-stone-200 rounded-lg shadow-xl z-50 max-h-80 overflow-y-auto">
+          {results.length === 0 ? (
+            <div className="px-4 py-3 text-sm text-stone-400 italic">Aucun résultat.</div>
+          ) : (
+            <ul>
+              {results.map((r) => (
+                <li key={r.page_id}>
+                  <button
+                    onClick={() => {
+                      setOpen(false)
+                      onSelectResult?.(r)
+                    }}
+                    className="w-full text-left px-4 py-3 hover:bg-amber-50 border-b border-stone-100 last:border-0 transition-colors"
+                  >
+                    <div className="flex items-center justify-between gap-2">
+                      <span className="font-medium text-stone-800 text-sm">
+                        {r.folio_label}
+                      </span>
+                      <span className="text-xs text-stone-400 shrink-0">
+                        score : {r.score}
+                      </span>
+                    </div>
+                    <div className="text-xs text-stone-500 mt-0.5 truncate">
+                      {r.excerpt}
+                    </div>
+                  </button>
+                </li>
+              ))}
+            </ul>
+          )}
+        </div>
+      )}
+    </div>
+  )
+}

frontend/src/lib/api.ts

@@ -293,3 +293,42 @@ export const getJob = (jobId: string): Promise<Job> =>
 
 export const retryJob = (jobId: string): Promise<Job> =>
   post(`/api/v1/jobs/${jobId}/retry`)
+
+export interface VersionInfo {
+  version: number
+  saved_at: string
+  status: string
+}
+
+export interface CorrectionsInput {
+  ocr_diplomatic_text?: string
+  editorial_status?: string
+  commentary_public?: string
+  commentary_scholarly?: string
+  region_validations?: Record<string, string>
+  restore_to_version?: number
+}
+
+export interface SearchResult {
+  page_id: string
+  folio_label: string
+  manuscript_id: string
+  excerpt: string
+  score: number
+  corpus_profile: string
+}
+
+export const fetchPage = (pageId: string): Promise<Page> =>
+  get(`/api/v1/pages/${pageId}`)
+
+export const applyCorrections = (
+  pageId: string,
+  corrections: CorrectionsInput,
+): Promise<PageMaster> =>
+  post(`/api/v1/pages/${pageId}/corrections`, corrections)
+
+export const getHistory = (pageId: string): Promise<VersionInfo[]> =>
+  get(`/api/v1/pages/${pageId}/history`)
+
+export const searchPages = (q: string): Promise<SearchResult[]> =>
+  get(`/api/v1/search?q=${encodeURIComponent(q)}`)

frontend/src/pages/Editor.tsx

@@ -0,0 +1,356 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import {
+  applyCorrections,
+  getHistory,
+  fetchMasterJson,
+  type PageMaster,
+  type VersionInfo,
+} from '../lib/api.ts'
+import Viewer from '../components/Viewer.tsx'
+
+interface Props {
+  pageId: string
+  onBack: () => void
+}
+
+type Panel = 'transcription' | 'commentary' | 'regions' | 'history'
+
+export default function Editor({ pageId, onBack }: Props) {
+  const [master, setMaster] = useState<PageMaster | null>(null)
+  const [history, setHistory] = useState<VersionInfo[]>([])
+  const [activePanel, setActivePanel] = useState<Panel>('transcription')
+  const [loading, setLoading] = useState(true)
+  const [saving, setSaving] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [saveError, setSaveError] = useState<string | null>(null)
+  const [saveSuccess, setSaveSuccess] = useState(false)
+
+  // Editable field values
+  const [ocrText, setOcrText] = useState('')
+  const [commentaryPublic, setCommentaryPublic] = useState('')
+  const [commentaryScholarly, setCommentaryScholarly] = useState('')
+  const [editorialStatus, setEditorialStatus] = useState('')
+  const [regionValidations, setRegionValidations] = useState<Record<string, string>>({})
+
+  const successTimeout = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+  const loadData = useCallback(async () => {
+    setLoading(true)
+    setError(null)
+    try {
+      const [m, h] = await Promise.all([fetchMasterJson(pageId), getHistory(pageId)])
+      setMaster(m)
+      setHistory(h)
+      setOcrText(m.ocr?.diplomatic_text ?? '')
+      setCommentaryPublic(m.commentary?.public ?? '')
+      setCommentaryScholarly(m.commentary?.scholarly ?? '')
+      setEditorialStatus(m.editorial.status)
+      // Restore existing region validations from extensions
+      const ext = (m as unknown as { extensions?: { region_validations?: Record<string, string> } }).extensions
+      setRegionValidations(ext?.region_validations ?? {})
+    } catch (e: unknown) {
+      setError((e as Error).message)
+    } finally {
+      setLoading(false)
+    }
+  }, [pageId])
+
+  useEffect(() => {
+    void loadData()
+  }, [loadData])
+
+  const handleSave = async () => {
+    setSaving(true)
+    setSaveError(null)
+    setSaveSuccess(false)
+    try {
+      const updated = await applyCorrections(pageId, {
+        ocr_diplomatic_text: ocrText !== (master?.ocr?.diplomatic_text ?? '') ? ocrText : undefined,
+        editorial_status: editorialStatus !== master?.editorial.status ? editorialStatus : undefined,
+        commentary_public: commentaryPublic !== (master?.commentary?.public ?? '') ? commentaryPublic : undefined,
+        commentary_scholarly: commentaryScholarly !== (master?.commentary?.scholarly ?? '') ? commentaryScholarly : undefined,
+        region_validations: Object.keys(regionValidations).length > 0 ? regionValidations : undefined,
+      })
+      setMaster(updated)
+      const h = await getHistory(pageId)
+      setHistory(h)
+      setSaveSuccess(true)
+      if (successTimeout.current) clearTimeout(successTimeout.current)
+      successTimeout.current = setTimeout(() => setSaveSuccess(false), 3000)
+    } catch (e: unknown) {
+      setSaveError((e as Error).message)
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  const handleRestore = async (version: number) => {
+    setSaving(true)
+    setSaveError(null)
+    try {
+      const updated = await applyCorrections(pageId, { restore_to_version: version })
+      setMaster(updated)
+      setOcrText(updated.ocr?.diplomatic_text ?? '')
+      setCommentaryPublic(updated.commentary?.public ?? '')
+      setCommentaryScholarly(updated.commentary?.scholarly ?? '')
+      setEditorialStatus(updated.editorial.status)
+      const h = await getHistory(pageId)
+      setHistory(h)
+    } catch (e: unknown) {
+      setSaveError((e as Error).message)
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  const setRegionValidation = (regionId: string, val: string) => {
+    setRegionValidations((prev) => ({ ...prev, [regionId]: val }))
+  }
+
+  if (loading) {
+    return (
+      <div className="flex items-center justify-center h-screen text-stone-500">
+        Chargement…
+      </div>
+    )
+  }
+
+  if (error) {
+    return <div className="p-8 text-red-600">Erreur : {error}</div>
+  }
+
+  const imageUrl = master ? '' : '' // image path not directly stored on PageMaster
+  const regions = master?.layout?.regions ?? []
+
+  return (
+    <div className="flex flex-col h-screen bg-stone-100">
+      {/* ── Header ──────────────────────────────────────────────────────────── */}
+      <header className="flex items-center gap-3 bg-stone-900 text-stone-100 px-5 py-2.5 shrink-0">
+        <button
+          onClick={onBack}
+          className="text-stone-400 hover:text-stone-100 text-sm transition-colors"
+        >
+          ← Retour
+        </button>
+        <span className="text-stone-600">|</span>
+        <span className="text-sm font-medium text-stone-200">
+          Éditeur — {master?.folio_label ?? pageId}
+        </span>
+        {master && (
+          <span className="ml-2 text-xs text-stone-400">
+            v{master.editorial.version} · {master.editorial.status}
+          </span>
+        )}
+
+        <div className="ml-auto flex items-center gap-3">
+          {saveSuccess && (
+            <span className="text-green-400 text-xs">Enregistré</span>
+          )}
+          {saveError && (
+            <span className="text-red-400 text-xs">{saveError}</span>
+          )}
+          <button
+            onClick={() => void handleSave()}
+            disabled={saving}
+            className="px-4 py-1.5 bg-amber-600 hover:bg-amber-500 disabled:opacity-40 text-white text-sm rounded transition-colors"
+          >
+            {saving ? 'Enregistrement…' : 'Enregistrer'}
+          </button>
+        </div>
+      </header>
+
+      {/* ── Layout 50 / 50 ──────────────────────────────────────────────────── */}
+      <div className="flex flex-1 overflow-hidden">
+        {/* Visionneuse gauche */}
+        <div className="relative" style={{ width: '50%' }}>
+          <Viewer imageUrl={imageUrl} onViewerReady={() => {}} />
+          {!imageUrl && (
+            <div className="absolute inset-0 flex items-center justify-center bg-stone-200 text-stone-400 text-sm">
+              Aperçu image non disponible
+            </div>
+          )}
+        </div>
+
+        {/* Panneaux droite */}
+        <div
+          className="flex flex-col border-l border-stone-200 bg-white"
+          style={{ width: '50%' }}
+        >
+          {/* Onglets */}
+          <div className="flex border-b border-stone-200 shrink-0">
+            {(['transcription', 'commentary', 'regions', 'history'] as Panel[]).map((p) => (
+              <button
+                key={p}
+                onClick={() => setActivePanel(p)}
+                className={`flex-1 py-2.5 text-xs font-medium capitalize transition-colors ${
+                  activePanel === p
+                    ? 'border-b-2 border-amber-500 text-amber-700 bg-amber-50'
+                    : 'text-stone-500 hover:text-stone-800'
+                }`}
+              >
+                {p === 'transcription' ? 'Transcription' :
+                 p === 'commentary' ? 'Commentaire' :
+                 p === 'regions' ? 'Régions' : 'Historique'}
+              </button>
+            ))}
+          </div>
+
+          {/* Contenu du panneau actif */}
+          <div className="flex-1 overflow-y-auto p-4">
+
+            {/* ── Transcription ─────────────────────────────────────────── */}
+            {activePanel === 'transcription' && (
+              <div className="space-y-4">
+                <div>
+                  <label className="block text-xs font-semibold text-stone-600 mb-1.5 uppercase tracking-wide">
+                    Texte diplomatique (OCR)
+                  </label>
+                  <textarea
+                    value={ocrText}
+                    onChange={(e) => setOcrText(e.target.value)}
+                    rows={12}
+                    className="w-full border border-stone-300 rounded-md px-3 py-2 text-sm font-mono focus:outline-none focus:ring-2 focus:ring-amber-400 resize-y"
+                  />
+                </div>
+                <div>
+                  <label className="block text-xs font-semibold text-stone-600 mb-1.5 uppercase tracking-wide">
+                    Statut éditorial
+                  </label>
+                  <select
+                    value={editorialStatus}
+                    onChange={(e) => setEditorialStatus(e.target.value)}
+                    className="w-full border border-stone-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-amber-400"
+                  >
+                    <option value="machine_draft">machine_draft</option>
+                    <option value="needs_review">needs_review</option>
+                    <option value="reviewed">reviewed</option>
+                    <option value="validated">validated</option>
+                    <option value="published">published</option>
+                  </select>
+                </div>
+                {master?.ocr && (
+                  <div className="text-xs text-stone-400 space-y-0.5">
+                    <div>Langue : {master.ocr.language}</div>
+                    <div>Confiance : {(master.ocr.confidence * 100).toFixed(0)} %</div>
+                  </div>
+                )}
+              </div>
+            )}
+
+            {/* ── Commentaire ───────────────────────────────────────────── */}
+            {activePanel === 'commentary' && (
+              <div className="space-y-5">
+                <div>
+                  <label className="block text-xs font-semibold text-stone-600 mb-1.5 uppercase tracking-wide">
+                    Commentaire public
+                  </label>
+                  <textarea
+                    value={commentaryPublic}
+                    onChange={(e) => setCommentaryPublic(e.target.value)}
+                    rows={6}
+                    className="w-full border border-stone-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-amber-400 resize-y"
+                  />
+                </div>
+                <div>
+                  <label className="block text-xs font-semibold text-stone-600 mb-1.5 uppercase tracking-wide">
+                    Commentaire savant
+                  </label>
+                  <textarea
+                    value={commentaryScholarly}
+                    onChange={(e) => setCommentaryScholarly(e.target.value)}
+                    rows={8}
+                    className="w-full border border-stone-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-amber-400 resize-y"
+                  />
+                </div>
+              </div>
+            )}
+
+            {/* ── Régions ───────────────────────────────────────────────── */}
+            {activePanel === 'regions' && (
+              <div className="space-y-2">
+                {regions.length === 0 ? (
+                  <p className="text-sm text-stone-400 italic">Aucune région détectée.</p>
+                ) : (
+                  regions.map((region) => {
+                    const validation = regionValidations[region.id]
+                    return (
+                      <div
+                        key={region.id}
+                        className="flex items-center justify-between border border-stone-200 rounded-lg px-3 py-2.5 text-sm"
+                      >
+                        <div>
+                          <span className="font-medium text-stone-800 capitalize">
+                            {region.type.replace(/_/g, ' ')}
+                          </span>
+                          <span className="ml-2 text-xs text-stone-400 font-mono">{region.id}</span>
+                          <div className="text-xs text-stone-400">
+                            confiance : {(region.confidence * 100).toFixed(0)} %
+                          </div>
+                        </div>
+                        <div className="flex gap-2 ml-4 shrink-0">
+                          <button
+                            onClick={() => setRegionValidation(region.id, 'validated')}
+                            className={`px-2.5 py-1 text-xs rounded-md transition-colors ${
+                              validation === 'validated'
+                                ? 'bg-green-600 text-white'
+                                : 'bg-stone-100 text-stone-600 hover:bg-green-100'
+                            }`}
+                          >
+                            Valider
+                          </button>
+                          <button
+                            onClick={() => setRegionValidation(region.id, 'rejected')}
+                            className={`px-2.5 py-1 text-xs rounded-md transition-colors ${
+                              validation === 'rejected'
+                                ? 'bg-red-600 text-white'
+                                : 'bg-stone-100 text-stone-600 hover:bg-red-100'
+                            }`}
+                          >
+                            Rejeter
+                          </button>
+                        </div>
+                      </div>
+                    )
+                  })
+                )}
+              </div>
+            )}
+
+            {/* ── Historique ────────────────────────────────────────────── */}
+            {activePanel === 'history' && (
+              <div className="space-y-2">
+                {history.length === 0 ? (
+                  <p className="text-sm text-stone-400 italic">
+                    Aucune version archivée.
+                  </p>
+                ) : (
+                  history.map((v) => (
+                    <div
+                      key={v.version}
+                      className="flex items-center justify-between border border-stone-200 rounded-lg px-3 py-2.5 text-sm"
+                    >
+                      <div>
+                        <span className="font-medium text-stone-800">v{v.version}</span>
+                        <span className="ml-2 text-xs text-stone-500">{v.status}</span>
+                        <div className="text-xs text-stone-400 mt-0.5">
+                          {new Date(v.saved_at).toLocaleString('fr-FR')}
+                        </div>
+                      </div>
+                      <button
+                        onClick={() => void handleRestore(v.version)}
+                        disabled={saving}
+                        className="ml-4 px-3 py-1 text-xs bg-stone-100 text-stone-600 hover:bg-amber-100 hover:text-amber-700 disabled:opacity-40 rounded-md transition-colors"
+                      >
+                        Restaurer
+                      </button>
+                    </div>
+                  ))
+                )}
+              </div>
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}

frontend/src/pages/Home.tsx

@@ -1,5 +1,6 @@
 import { useEffect, useState } from 'react'
 import AdminNav from '../components/AdminNav.tsx'
+import SearchBar from '../components/SearchBar.tsx'
 import {
   fetchCorpora,
   fetchManuscripts,
@@ -71,7 +72,10 @@ export default function Home({ onOpenManuscript, onAdmin }: Props) {
             Plateforme de génération d'éditions savantes augmentées
           </p>
         </div>
-        <AdminNav onClick={onAdmin} />
+        <div className="flex items-center gap-4">
+          <SearchBar />
+          <AdminNav onClick={onAdmin} />
+        </div>
       </header>
 
       <main className="max-w-3xl mx-auto py-10 px-8">

frontend/src/pages/Reader.tsx

@@ -20,9 +20,10 @@ interface Props {
   manuscriptId: string
   profileId: string
   onBack: () => void
+  onEdit?: (pageId: string) => void
 }
 
-export default function Reader({ manuscriptId, profileId, onBack }: Props) {
+export default function Reader({ manuscriptId, profileId, onBack, onEdit }: Props) {
   const [pages, setPages] = useState<Page[]>([])
   const [currentIndex, setCurrentIndex] = useState(0)
   const [master, setMaster] = useState<PageMaster | null>(null)
@@ -113,6 +114,14 @@ export default function Reader({ manuscriptId, profileId, onBack }: Props) {
           <span className="text-stone-400 text-xs">
             {currentPage.folio_label} — {currentIndex + 1} / {pages.length}
           </span>
+          {onEdit && (
+            <button
+              onClick={() => onEdit(currentPage.id)}
+              className="px-3 py-1 bg-amber-600 hover:bg-amber-500 rounded text-sm text-white transition-colors"
+            >
+              Éditer cette page
+            </button>
+          )}
           <button
             disabled={currentIndex === 0}
             onClick={() => setCurrentIndex((i) => i - 1)}