indice 0.3.0__py3-none-any.whl

indice/__init__.py

@@ -0,0 +1 @@
+"""Indice — investigation assistance engine (package)."""

indice/audio_transcriber.py

@@ -0,0 +1,167 @@
+"""
+audio_transcriber.py — audio acquisition + transcription for Indice Voice Analyzer.
+
+Three sources, one async interface (`stream_transcriptions`):
+
+  * MICROPHONE            — sounddevice capture -> energy VAD gating -> faster-whisper.
+  * FILE                  — transcribe a recorded file with faster-whisper.
+
+CRITICAL FIX vs. the original spec: VAD and Whisper are synchronous, CPU-heavy
+calls. Running them directly inside the asyncio event loop blocks every WebSocket on the
+server. Here, every model call is dispatched with `asyncio.to_thread(...)` so the event
+loop stays responsive.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import queue
+import time
+from typing import Any, AsyncGenerator, Dict, Optional
+
+
+class AudioStreamTranscriber:
+    def __init__(self, config: Dict[str, Any], use_microphone: bool = False):
+        p = config.get("pipeline", {})
+        self.config = config
+        self.use_microphone = use_microphone
+        self.sample_rate = int(p.get("sample_rate", 16000))
+        self.model_size = p.get("model_size", "base.en")
+        self.device = p.get("device", "cpu")
+        self.compute_type = p.get("compute_type", "int8")
+        self.vad_threshold = float(p.get("vad_threshold", 0.5))
+        self.energy_threshold = float(p.get("energy_threshold", 0.01))
+        self.silence_frames_limit = int(p.get("silence_frames", 18))
+        self.chunk_samples = int(p.get("chunk_samples", 512))
+        self.sim_interval = float(p.get("simulation_interval_seconds", 1.1))
+        self.beam_size = int(p.get("beam_size", 1))
+        lang = p.get("language", "auto")
+        # None lets faster-whisper auto-detect the language (FR or EN) per source.
+        self.language = None if lang in ("", "auto", None) else lang
+
+        self.audio_queue: "queue.Queue" = queue.Queue()
+        self.whisper_model = None
+        self.vad_model = None
+
+    # ------------------------------------------------------------------ #
+    def _load_models(self) -> None:
+        """Blocking Whisper load -- always called via asyncio.to_thread (no torch)."""
+        from faster_whisper import WhisperModel  # type: ignore
+
+        self.whisper_model = WhisperModel(
+            self.model_size, device=self.device, compute_type=self.compute_type
+        )
+
+    @staticmethod
+    def _now_ts() -> str:
+        return time.strftime("%H:%M:%S")
+
+    # ------------------------------------------------------------------ #
+    async def stream_transcriptions(self) -> AsyncGenerator[Dict[str, str], None]:
+        """Yield {'ts', 'text'} dicts as speech is transcribed (live capture)."""
+        async for item in self._stream_microphone():
+            yield item
+
+    # ------------------------------------------------------------------ #
+    def _audio_callback(self, indata, frames, time_info, status):  # pragma: no cover
+        self.audio_queue.put(indata[:, 0].copy())
+
+    def _reset_segmenter(self) -> None:
+        self._speech_buffer: list = []
+        self._silence_frames: int = 0
+
+    async def _ingest_chunk(self, chunk, vad_fn, transcribe_fn):
+        """Feed one audio chunk through the VAD-gated segmenter.
+
+        `vad_fn(chunk) -> float` and `transcribe_fn(audio) -> str` are injected so this
+        state machine can be exercised with real models (mic path) or stubs (tests),
+        and both are dispatched OFF the event loop via asyncio.to_thread. Returns a
+        transcribed string when a speech segment completes, else None.
+        """
+        import numpy as np  # type: ignore
+
+        # VAD inference OFF the event loop.
+        speech_prob = await asyncio.to_thread(vad_fn, chunk)
+
+        if speech_prob > self.vad_threshold:
+            self._speech_buffer.append(chunk)
+            self._silence_frames = 0
+        elif self._speech_buffer:
+            self._speech_buffer.append(chunk)
+            self._silence_frames += 1
+            if self._silence_frames > self.silence_frames_limit:
+                full_audio = np.concatenate(self._speech_buffer)
+                self._reset_segmenter()
+                # Transcription OFF the event loop.
+                text = await asyncio.to_thread(transcribe_fn, full_audio)
+                return text or None
+        return None
+
+    async def _stream_microphone(self) -> AsyncGenerator[Dict[str, str], None]:  # pragma: no cover
+        import sounddevice as sd  # type: ignore
+        import numpy as np  # type: ignore
+
+        if self.whisper_model is None:
+            await asyncio.to_thread(self._load_models)
+
+        self._reset_segmenter()
+
+        def vad_fn(chunk):
+            # Energy-based VAD (RMS) -- deterministic, offline, no torch/Silero.
+            rms = float(np.sqrt(np.mean(np.square(chunk)))) if len(chunk) else 0.0
+            return 1.0 if rms >= self.energy_threshold else 0.0
+
+        with sd.InputStream(
+            samplerate=self.sample_rate,
+            channels=1,
+            dtype="float32",
+            blocksize=self.chunk_samples,
+            callback=self._audio_callback,
+        ):
+            while True:
+                await asyncio.sleep(0.01)
+                while not self.audio_queue.empty():
+                    chunk = self.audio_queue.get_nowait()
+                    text = await self._ingest_chunk(chunk, vad_fn, self._transcribe_array)
+                    if text:
+                        yield {"ts": self._now_ts(), "text": text}
+
+    # ------------------------------------------------------------------ #
+    def _transcribe_array(self, audio) -> str:  # pragma: no cover
+        """Blocking Whisper call — always dispatched via asyncio.to_thread."""
+        segments, _ = self.whisper_model.transcribe(
+            audio, beam_size=self.beam_size, language=self.language, vad_filter=False
+        )
+        return " ".join(seg.text.strip() for seg in segments).strip()
+
+    async def transcribe_file(self, path: str) -> AsyncGenerator[Dict[str, str], None]:
+        """Transcribe a recorded file, yielding each segment as it is decoded."""
+        if self.whisper_model is None:
+            await asyncio.to_thread(self._load_models_whisper_only)
+
+        segments = await asyncio.to_thread(self._file_segments, path)
+        for seg in segments:
+            yield {"ts": self._fmt_seconds(seg["start"]), "text": seg["text"]}
+
+    def _load_models_whisper_only(self) -> None:  # pragma: no cover
+        from faster_whisper import WhisperModel  # type: ignore
+
+        self.whisper_model = WhisperModel(
+            self.model_size, device=self.device, compute_type=self.compute_type
+        )
+
+    def _file_segments(self, path: str):  # pragma: no cover
+        segments, _ = self.whisper_model.transcribe(
+            path, beam_size=self.beam_size, language=self.language, vad_filter=True
+        )
+        out = []
+        for seg in segments:
+            txt = seg.text.strip()
+            if txt:
+                out.append({"start": seg.start, "text": txt})
+        return out
+
+    @staticmethod
+    def _fmt_seconds(s: float) -> str:
+        s = int(s or 0)
+        return f"{s // 60:02d}:{s % 60:02d}"

indice/auth.py

@@ -0,0 +1,67 @@
+"""
+auth.py — token authentication for the Indice access gate.
+
+One operator credential. The passphrase comes from the INDICE_PASSPHRASE env var when
+set, otherwise from config.json. It is verified with a salted PBKDF2-HMAC-SHA256 hash
+(per-process random salt) and a constant-time compare, issuing an opaque in-memory
+bearer token with a TTL. Running on the shipped default is reported so the server can
+warn the operator before the app is exposed.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import os
+import secrets
+import time
+from typing import Any, Dict, Optional
+
+_DEFAULT_PASSPHRASE = "indice"
+_PBKDF2_ROUNDS = 200_000
+
+
+def _derive(passphrase: str, salt: bytes) -> bytes:
+    return hashlib.pbkdf2_hmac("sha256", (passphrase or "").encode("utf-8"), salt, _PBKDF2_ROUNDS)
+
+
+class AuthManager:
+    def __init__(self, config: Dict[str, Any]):
+        auth = config.get("auth", {})
+        self.operator_id = os.environ.get("INDICE_OPERATOR", auth.get("operator_id", "OPERATOR"))
+        env_pass = os.environ.get("INDICE_PASSPHRASE")
+        config_pass = auth.get("passphrase", _DEFAULT_PASSPHRASE)
+        passphrase = env_pass if env_pass is not None else config_pass
+        # True when no INDICE_PASSPHRASE is set and config still ships the default.
+        self.using_default_credentials = env_pass is None and config_pass == _DEFAULT_PASSPHRASE
+        self._salt = secrets.token_bytes(16)
+        self._hash = _derive(passphrase, self._salt)
+        self.ttl = int(auth.get("token_ttl_seconds", 3600))
+        self._tokens: Dict[str, float] = {}
+
+    def login(self, operator_id: str, passphrase: str) -> Optional[str]:
+        """Return a bearer token on success, else None."""
+        ok_pass = hmac.compare_digest(self._hash, _derive(passphrase or "", self._salt))
+        ok_op = bool(operator_id) and operator_id.strip().upper().startswith(
+            self.operator_id.split("//")[0].strip().upper()
+        )
+        if ok_pass and ok_op:
+            token = secrets.token_urlsafe(32)
+            self._tokens[token] = time.time() + self.ttl
+            return token
+        return None
+
+    def validate(self, token: Optional[str]) -> bool:
+        if not token:
+            return False
+        expiry = self._tokens.get(token)
+        if expiry is None:
+            return False
+        if time.time() > expiry:
+            self._tokens.pop(token, None)
+            return False
+        return True
+
+    def logout(self, token: Optional[str]) -> None:
+        if token:
+            self._tokens.pop(token, None)

indice/cli.py

@@ -0,0 +1,113 @@
+"""
+cli.py -- command-line entry point for Indice.
+
+    indice serve   [--host H] [--port P] [--reload] [--open]
+    indice analyze <path> [--subject "a, b"] [--format md|pdf] [--out FILE]
+
+`serve` launches the local web app; `analyze` runs the deterministic engine over a
+file or folder and prints (or writes) a report -- no browser, no LLM.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+
+def _cmd_serve(args):
+    import uvicorn
+    if args.host not in ("127.0.0.1", "localhost", ""):
+        print("WARNING: host %s exposes Indice beyond this machine. Set "
+              "INDICE_PASSPHRASE and put it behind a reverse proxy / TLS." % args.host,
+              file=sys.stderr)
+    if args.open:
+        import threading
+        import webbrowser
+        host = "127.0.0.1" if args.host in ("0.0.0.0", "") else args.host
+        url = "http://%s:%d" % (host, args.port)
+        threading.Timer(1.5, lambda: webbrowser.open(url)).start()
+    uvicorn.run("indice.server:app", host=args.host, port=args.port, reload=args.reload)
+
+
+def _collect_files(path):
+    if os.path.isfile(path):
+        return [path]
+    out = []
+    if os.path.isdir(path):
+        for root, _dirs, names in os.walk(path):
+            for n in sorted(names):
+                out.append(os.path.join(root, n))
+    return out
+
+
+def _cmd_analyze(args):
+    from . import doc_ingest, dossier_analyze, dossier_export
+    files = _collect_files(args.path)
+    if not files:
+        print("Aucun fichier a analyser dans : %s" % args.path, file=sys.stderr)
+        return 2
+    sources = []
+    for i, f in enumerate(files):
+        if not doc_ingest.is_text_like(f):
+            continue
+        try:
+            text = doc_ingest.extract_text(f)
+        except Exception as exc:
+            print("  (ignore) %s : %s" % (os.path.basename(f), exc), file=sys.stderr)
+            continue
+        sources.append({
+            "id": "s%d" % (i + 1), "title": os.path.basename(f), "url": "",
+            "published_date": "", "platform": "fichier local",
+            "orientation": "source", "raw_text": text,
+        })
+    if not sources:
+        print("Aucun texte exploitable (formats : txt, md, csv, pdf, docx, images).",
+              file=sys.stderr)
+        return 2
+    dossier = {"id": "CLI", "name": os.path.basename(os.path.abspath(args.path)) or "dossier",
+               "operator": "cli", "sources": sources}
+    analysis = dossier_analyze.analyze(dossier, args.subject or "")
+    if args.format == "pdf":
+        data = dossier_export.to_pdf(dossier, analysis)
+        out = args.out or (dossier["name"] + ".pdf")
+        with open(out, "wb") as fh:
+            fh.write(data)
+        print("Rapport PDF ecrit : %s" % out)
+    else:
+        md = dossier_export.to_markdown(dossier, analysis)
+        if args.out:
+            with open(args.out, "w", encoding="utf-8") as fh:
+                fh.write(md)
+            print("Rapport Markdown ecrit : %s" % args.out)
+        else:
+            print(md)
+    return 0
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="indice", description="Indice - du cas au dossier.")
+    sub = p.add_subparsers(dest="cmd")
+
+    ps = sub.add_parser("serve", help="Lancer l'interface web locale.")
+    ps.add_argument("--host", default="127.0.0.1")
+    ps.add_argument("--port", type=int, default=8000)
+    ps.add_argument("--reload", action="store_true")
+    ps.add_argument("--open", action="store_true", help="Ouvrir le navigateur au demarrage.")
+    ps.set_defaults(func=_cmd_serve)
+
+    pa = sub.add_parser("analyze", help="Analyser un fichier/dossier -> rapport.")
+    pa.add_argument("path")
+    pa.add_argument("--subject", default="", help="Sujet / selecteurs (separes par des virgules).")
+    pa.add_argument("--format", choices=["md", "pdf"], default="md")
+    pa.add_argument("--out", help="Fichier de sortie (sinon stdout pour md).")
+    pa.set_defaults(func=_cmd_analyze)
+
+    args = p.parse_args(argv)
+    if not getattr(args, "cmd", None):
+        p.print_help()
+        return 1
+    return args.func(args) or 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

indice/config.json

@@ -0,0 +1,30 @@
+{
+  "auth": {
+    "operator_id": "ANALYSTE",
+    "passphrase": "indice",
+    "token_ttl_seconds": 3600,
+    "_comment": "Demo credential only. Override passphrase with env INDICE_PASSPHRASE. Never ship a real deployment with a plaintext passphrase in config."
+  },
+  "pipeline": {
+    "sample_rate": 16000,
+    "model_size": "base",
+    "device": "cpu",
+    "compute_type": "int8",
+    "vad_threshold": 0.5,
+    "silence_frames": 18,
+    "chunk_samples": 512,
+    "simulation_interval_seconds": 1.1,
+    "beam_size": 1,
+    "language": "auto",
+    "energy_threshold": 0.006
+  },
+  "default_settings": {
+    "vad": true,
+    "diarize": true,
+    "redact": false,
+    "autolock": true,
+    "language": "en",
+    "model_label": "faster-whisper · base.en",
+    "vad_threshold": 0.62
+  }
+}

indice/db.py

@@ -0,0 +1,106 @@
+"""
+db.py — SQLite persistence for Indice Voice Analyzer.
+
+Stores analysis sessions (archive + per-session report), target dossiers, and the live
+settings. Only settings are seeded; sessions and targets start empty and fill as real
+analyses run.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import threading
+import time
+from typing import Any, Dict, List, Optional
+
+DB_PATH = os.environ.get("INDICE_DB", os.path.join(os.environ.get("INDICE_DATA", os.getcwd()), "indice.db"))
+_LOCK = threading.Lock()
+
+
+def _connect() -> sqlite3.Connection:
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def init_db(config: Dict[str, Any]) -> None:
+    with _LOCK, _connect() as conn:
+        conn.executescript(
+            """
+            CREATE TABLE IF NOT EXISTS sessions (
+                id TEXT PRIMARY KEY, subject TEXT, channel TEXT, date TEXT,
+                dur TEXT, status TEXT, status_color TEXT, created_at REAL, report_json TEXT
+            );
+            CREATE TABLE IF NOT EXISTS targets (code TEXT PRIMARY KEY, data_json TEXT);
+            CREATE TABLE IF NOT EXISTS settings (id INTEGER PRIMARY KEY CHECK (id = 1), data_json TEXT);
+            """
+        )
+        # Settings are the only seeded row. Sessions/targets start EMPTY and fill as
+        # real analyses run -- no demo content.
+        if conn.execute("SELECT COUNT(*) AS n FROM settings").fetchone()["n"] == 0:
+            conn.execute("INSERT OR REPLACE INTO settings VALUES (1, ?)",
+                         (json.dumps(config.get("default_settings", {})),))
+
+
+def list_sessions(query: Optional[str] = None) -> List[Dict[str, Any]]:
+    with _LOCK, _connect() as conn:
+        rows = conn.execute("SELECT * FROM sessions ORDER BY created_at DESC").fetchall()
+    out = []
+    for r in rows:
+        if query:
+            q = query.lower()
+            if q not in r["subject"].lower() and q not in r["id"].lower():
+                continue
+        out.append({
+            "id": r["id"], "subject": r["subject"], "channel": r["channel"],
+            "date": r["date"], "dur": r["dur"], "status": r["status"],
+            "statusColor": r["status_color"],
+        })
+    return out
+
+
+def get_session(session_id: str) -> Optional[Dict[str, Any]]:
+    with _LOCK, _connect() as conn:
+        r = conn.execute("SELECT * FROM sessions WHERE id = ?", (session_id,)).fetchone()
+    if not r:
+        return None
+    report = json.loads(r["report_json"] or "{}")
+    return {
+        "id": r["id"], "subject": r["subject"], "channel": r["channel"],
+        "date": r["date"], "dur": r["dur"], "status": r["status"],
+        "statusColor": r["status_color"], "report": report,
+    }
+
+
+def create_session(session: Dict[str, Any]) -> None:
+    with _LOCK, _connect() as conn:
+        conn.execute(
+            "INSERT OR REPLACE INTO sessions VALUES (?,?,?,?,?,?,?,?,?)",
+            (
+                session["id"], session.get("subject", "UNASSIGNED"),
+                session.get("channel", "VOICE · LIVE"), session.get("date", ""),
+                session.get("dur", "—"), session.get("status", "REVIEW"),
+                session.get("statusColor", "#d8b24a"), time.time(),
+                json.dumps(session.get("report", {})),
+            ),
+        )
+
+
+def get_target(code: str) -> Optional[Dict[str, Any]]:
+    with _LOCK, _connect() as conn:
+        r = conn.execute("SELECT data_json FROM targets WHERE code = ?", (code,)).fetchone()
+    return json.loads(r["data_json"]) if r else None
+
+
+def get_settings() -> Dict[str, Any]:
+    with _LOCK, _connect() as conn:
+        r = conn.execute("SELECT data_json FROM settings WHERE id = 1").fetchone()
+    return json.loads(r["data_json"]) if r else {}
+
+
+def save_settings(settings: Dict[str, Any]) -> Dict[str, Any]:
+    with _LOCK, _connect() as conn:
+        conn.execute("INSERT OR REPLACE INTO settings VALUES (1, ?)", (json.dumps(settings),))
+    return settings

indice/doc_ingest.py

@@ -0,0 +1,98 @@
+"""
+doc_ingest.py — extract analyzable text from a source file.
+
+Server-side, offline, deterministic tooling (no LLM):
+  * text (.txt/.md/.csv/.log/.json)  -> read directly
+  * PDF (.pdf)                       -> PyMuPDF text layer; if scanned, OCR pages (RapidOCR)
+  * DOCX (.docx)                     -> python-docx
+  * images (.png/.jpg/...)           -> OCR (RapidOCR)
+
+Optional libs are lazy-loaded with a clear error naming what to install.
+"""
+import os
+import tempfile
+
+TEXT_EXT = {".txt", ".md", ".csv", ".log", ".json"}
+DOC_EXT = {".pdf", ".docx"}
+IMAGE_EXT = {".png", ".jpg", ".jpeg", ".tif", ".tiff", ".bmp", ".webp"}
+
+_OCR = None
+_OCR_TRIED = False
+
+
+def is_text_like(path: str) -> bool:
+    return os.path.splitext(path)[1].lower() in (TEXT_EXT | DOC_EXT | IMAGE_EXT)
+
+
+def _ocr_engine():
+    """Lazy RapidOCR (ONNX, CPU, offline). None if not installed."""
+    global _OCR, _OCR_TRIED
+    if _OCR_TRIED:
+        return _OCR
+    _OCR_TRIED = True
+    try:
+        from rapidocr_onnxruntime import RapidOCR  # type: ignore
+        _OCR = RapidOCR()
+    except Exception:
+        _OCR = None
+    return _OCR
+
+
+def _ocr_file(path: str) -> str:
+    ocr = _ocr_engine()
+    if ocr is None:
+        raise RuntimeError("OCR non disponible : installer rapidocr-onnxruntime "
+                           "(pip install rapidocr-onnxruntime) cote serveur")
+    result, _ = ocr(path)
+    return "\n".join(line[1] for line in (result or []))
+
+
+def extract_text(path: str) -> str:
+    ext = os.path.splitext(path)[1].lower()
+    if ext in TEXT_EXT:
+        with open(path, encoding="utf-8", errors="ignore") as f:
+            return f.read()
+    if ext in IMAGE_EXT:
+        return _ocr_file(path)
+    if ext == ".pdf":
+        try:
+            import fitz  # PyMuPDF
+        except Exception:
+            raise RuntimeError("PDF non lu : installer PyMuPDF (pip install pymupdf) cote serveur")
+        doc = fitz.open(path)
+        text = "\n".join(page.get_text() for page in doc)
+        if len(text.strip()) >= 20:
+            return text  # has a real text layer
+        # scanned PDF -> OCR each page via RapidOCR
+        ocr = _ocr_engine()
+        if ocr is None:
+            if text.strip():
+                return text
+            raise RuntimeError("PDF scanne : installer rapidocr-onnxruntime pour l'OCR")
+        out = []
+        for page in doc:
+            pix = page.get_pixmap(dpi=200)
+            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+            tmp.close()
+            try:
+                pix.save(tmp.name)
+                res, _ = ocr(tmp.name)
+                out.append("\n".join(line[1] for line in (res or [])))
+            finally:
+                try:
+                    os.unlink(tmp.name)
+                except OSError:
+                    pass
+        return "\n".join(out)
+    if ext == ".docx":
+        try:
+            import docx  # python-docx
+        except Exception:
+            raise RuntimeError("DOCX non lu : installer python-docx cote serveur")
+        d = docx.Document(path)
+        return "\n".join(p.text for p in d.paragraphs)
+    raise RuntimeError("Format non supporte : " + ext)
+
+
+def to_lines(text: str):
+    return [ln.strip() for ln in text.splitlines() if ln.strip()]

indice/dossier_analyze.py

@@ -0,0 +1,89 @@
+"""
+dossier_analyze.py -- deterministic analysis of a constituted dossier (no LLM).
+
+Given a dossier's saved sources, it:
+  * extracts the dated passages mentioning the subject / selectors -- the
+    "before/now" juxtaposition the analyst reads to judge coherence, and
+  * runs the open-extraction engine over all source texts for entities.
+
+Indice surfaces and aligns; the human judges.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List
+
+_SENT = re.compile(r"[^.!?\n]+[.!?]?")
+
+
+def _selectors(dossier: Dict[str, Any], extra: str) -> List[str]:
+    raw = (dossier.get("name", "") or "") + " " + (extra or "")
+    out, seen = [], set()
+    for t in re.split(r"[,\s]+", raw):
+        t = t.strip()
+        if len(t) >= 3 and t.lower() not in seen:
+            seen.add(t.lower())
+            out.append(t)
+    return out
+
+
+def _passages_for(text: str, selectors: List[str]) -> List[Dict[str, Any]]:
+    out = []
+    for m in _SENT.finditer(text or ""):
+        s = m.group().strip()
+        if not s:
+            continue
+        low = s.lower()
+        hit = sorted({sel for sel in selectors if sel.lower() in low})
+        if hit:
+            out.append({"passage": s[:400], "matched": hit})
+    return out
+
+
+def _date_key(d: str) -> str:
+    return (d or "").strip() or "9999"  # empty dates sort last
+
+
+def analyze(dossier: Dict[str, Any], extra_selectors: str = "") -> Dict[str, Any]:
+    selectors = _selectors(dossier, extra_selectors)
+    sources = dossier.get("sources", [])
+
+    # 1) dated juxtaposition passages (oldest first = "avant" -> "maintenant")
+    passages: List[Dict[str, Any]] = []
+    for src in sources:
+        for p in _passages_for(src.get("raw_text", ""), selectors):
+            passages.append({
+                "date": src.get("published_date", ""),
+                "title": src.get("title", ""),
+                "url": src.get("url", ""),
+                "platform": src.get("platform", ""),
+                "orientation": src.get("orientation", "unknown"),
+                "passage": p["passage"],
+                "matched": p["matched"],
+            })
+    passages.sort(key=lambda x: _date_key(x["date"]))
+
+    # 2) entities via the open-extraction engine (deterministic, no spaCy)
+    entities: List[Dict[str, Any]] = []
+    try:
+        from .indice_core import CorrelationEngine
+        from . import packs
+        try:
+            profile = packs.load_domains(["justice"])
+        except Exception:
+            profile = {"patterns": [], "lexicon": []}
+        engine = CorrelationEngine(profile, watchlist=selectors, use_ner=False)
+        for src in sources:
+            for line in (src.get("raw_text", "") or "").splitlines():
+                line = line.strip()
+                if line:
+                    engine.analyze_utterance(line)
+        entities = [{"name": k, "category": v.get("category"), "count": v.get("count")}
+                    for k, v in engine.entities.items()]
+        entities.sort(key=lambda e: -(e.get("count") or 0))
+        entities = entities[:40]
+    except Exception:
+        entities = []
+
+    return {"selectors": selectors, "sources": len(sources),
+            "passages": passages, "entities": entities}