@piecemaker-legal/piecemaker 1.0.6

package/server/piecemaker/vendor/piecemaker-plugin/scripts/statusline.mjs

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+/**
+ * statusLine Claude Code — bandeau permanent d'état de l'anonymisation PieceMaker.
+ *
+ * Contrat statusLine (type "command") : JSON sur stdin décrivant la session
+ * (workspace, model...), une seule ligne sur stdout, exit 0. Appelé très
+ * souvent (à chaque rendu de l'interface) : ce script doit rester rapide et
+ * ne jamais bloquer ni jeter.
+ *
+ * Le badge reflète les deux mêmes conditions que `proxy-guard.mjs` (routage
+ * + proxy vivant), mais sans autostart ni journalisation : une statusLine
+ * n'est pas le bon endroit pour une action de fond, seulement pour un
+ * affichage. Le sondage réseau est borné à 400 ms et son résultat est mis en
+ * cache 5 s dans ~/.piecemaker/proxy-statusline.json pour éviter une requête
+ * à chaque frappe.
+ */
+
+import fs from 'node:fs';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import { HOME_DIR, loadPieceMakerConfig, readHookPayload } from './lib/hook-io.mjs';
+
+const CACHE_FILE = path.join(HOME_DIR, 'proxy-statusline.json');
+const CACHE_TTL_MS = 5000;
+const PROBE_TIMEOUT_MS = 400;
+const STDIN_TIMEOUT_MS = 1000;
+const DEFAULT_PORT = 4000;
+const FLUSH_TIMEOUT_MS = 1000;
+
+const SETTINGS_FILE = path.join(os.homedir(), '.claude', 'settings.json');
+
+function validPort(value) {
+  const port = Number(value);
+  return Number.isInteger(port) && port >= 1024 && port <= 65535 ? port : DEFAULT_PORT;
+}
+
+/** Même définition du routage que proxy-guard.mjs — lecture directe, jamais de throw. */
+function readRouting() {
+  try {
+    const settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8'));
+    const value = settings?.env?.ANTHROPIC_BASE_URL;
+    if (typeof value !== 'string' || !value) return false;
+    const url = new URL(value);
+    return ['127.0.0.1', 'localhost'].includes(url.hostname)
+      && url.pathname.replace(/\/$/, '') === '/anthropic';
+  } catch {
+    return false;
+  }
+}
+
+/** Cache court entre deux sondages. Un cache illisible/absent n'empêche pas de sonder. */
+function readCache() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
+    if (typeof parsed?.ts !== 'number' || typeof parsed?.actif !== 'boolean') return null;
+    if (Date.now() - parsed.ts > CACHE_TTL_MS) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(actif) {
+  try {
+    fs.mkdirSync(HOME_DIR, { recursive: true });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify({ ts: Date.now(), actif }), 'utf8');
+  } catch {
+    // Le cache est un confort de performance, pas une garantie.
+  }
+}
+
+function probe(port, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (ok) => {
+      if (settled) return;
+      settled = true;
+      resolve(ok);
+    };
+    try {
+      const request = http.get({
+        hostname: '127.0.0.1',
+        port,
+        path: '/health/liveliness',
+        timeout: timeoutMs,
+      }, (response) => {
+        response.resume();
+        finish(response.statusCode === 200);
+      });
+      request.on('timeout', () => { request.destroy(); finish(false); });
+      request.on('error', () => finish(false));
+    } catch {
+      finish(false);
+    }
+  });
+}
+
+/**
+ * Couleur ANSI du badge : vert quand l'anonymisation est effective, rouge
+ * sinon. Claude Code rend les séquences ANSI de la statusLine ; on n'en met
+ * que sur le badge, jamais sur le dossier ni le modèle.
+ */
+const VERT = '\u001b[32m';
+const ROUGE = '\u001b[31m';
+const RESET = '\u001b[0m';
+
+function colore(texte, couleur) {
+  return process.env.NO_COLOR ? texte : `${couleur}${texte}${RESET}`;
+}
+
+function badge(routed, actif) {
+  if (routed && actif) return colore('🔒 Anonymisation PieceMaker active ✓', VERT);
+  if (routed) return colore('⚠️ Anonymisation PieceMaker inactive — proxy arrêté (piecemaker start)', ROUGE);
+  return colore('⚠️ Anonymisation PieceMaker inactive — accès direct', ROUGE);
+}
+
+/** Écrit la ligne et quitte proprement, en attendant le flush comme hook-io.mjs::emit. */
+function printAndExit(text) {
+  const guard = setTimeout(() => process.exit(0), FLUSH_TIMEOUT_MS);
+  guard.unref?.();
+  try {
+    process.stdout.write(`${text}\n`, () => {
+      clearTimeout(guard);
+      process.exit(0);
+    });
+  } catch {
+    clearTimeout(guard);
+    process.exit(0);
+  }
+}
+
+function safeCwdName(cwd) {
+  try {
+    const value = String(cwd || process.cwd());
+    return path.basename(value) || value;
+  } catch {
+    return '';
+  }
+}
+
+async function main() {
+  let payload = null;
+  try {
+    payload = await readHookPayload(STDIN_TIMEOUT_MS);
+  } catch {
+    payload = null;
+  }
+
+  const dirName = safeCwdName(payload?.workspace?.current_dir || payload?.cwd);
+  const modelName = typeof payload?.model?.display_name === 'string' ? payload.model.display_name : '';
+
+  let config = {};
+  try {
+    config = loadPieceMakerConfig();
+  } catch {
+    config = {};
+  }
+  const port = validPort(config.litellmPort);
+  const routed = readRouting();
+
+  const cached = readCache();
+  let actif;
+  if (cached) {
+    actif = cached.actif;
+  } else {
+    actif = await probe(port, PROBE_TIMEOUT_MS);
+    writeCache(actif);
+  }
+
+  const parts = [badge(routed, actif)];
+  if (dirName) parts.push(dirName);
+  if (modelName) parts.push(modelName);
+  printAndExit(parts.join(' · '));
+}
+
+main().catch(() => {
+  printAndExit(safeCwdName(process.cwd()));
+});

package/server/piecemaker/vendor/piecemaker-plugin/scripts/track-legifrance-reads.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse hook (Read) — trace les lectures dans un dossier de résultats
+ * Legifrance téléchargé par l'outil MCP `Download_Query_Results`.
+ *
+ * Purement mécanique (« synthetic & static », jamais un LLM) : si le fichier lu
+ * est sous un dossier portant le marqueur `.legifrance-results.json`, la lecture
+ * est comptabilisée dans `.read-log.json` à la racine de ce dossier. C'est ce
+ * qui permet à l'orchestrateur de savoir quelles décisions l'agent de tri a
+ * réellement ouvertes.
+ *
+ * Fail-open : hors dossier de résultats, ou sur la moindre erreur → exit 0,
+ * stdout vide, la session n'est pas affectée.
+ */
+
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { noop, readHookPayload, runHook } from './lib/hook-io.mjs';
+
+const require = createRequire(import.meta.url);
+const { findResultsRoot, recordRead } = require('./lib/legifrance-reads.cjs');
+
+async function main() {
+  const payload = await readHookPayload(2000);
+  if (!payload || payload.tool_name !== 'Read') return null;
+  if (payload.tool_response?.success === false) return null;
+
+  const cwd = payload.cwd || process.cwd();
+  const target = payload.tool_input?.file_path;
+  if (!target) return null;
+  const absolute = path.isAbsolute(target) ? target : path.resolve(cwd, target);
+
+  const root = findResultsRoot(absolute);
+  if (!root) return null;
+
+  const relFile = path.relative(root, absolute);
+  if (!relFile || relFile.startsWith('..')) return null;
+
+  recordRead(root, relFile, {
+    sessionId: payload.session_id || null,
+    toolUseId: payload.tool_use_id || null,
+  });
+  return null;
+}
+
+runHook(main, { timeoutMs: 4000 }).catch(() => noop());

package/server/piecemaker/vendor/piecemaker-plugin/skills/ajout-de-fonctionnalites/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: ajout-de-fonctionnalites
+description: À utiliser quand l'utilisateur veut ajouter ou modifier ses propres instructions, préférences, gabarits ou une nouvelle capacité personnelle, qui doivent rester disponibles après une mise à jour de PieceMaker. Couvre les instructions globales, une skill personnelle, un gabarit personnel, ou un élément propre à un seul dossier.
+---
+
+# Ajouter ses propres éléments (persistants aux mises à jour)
+
+PieceMaker évolue par mises à jour du dépôt. Ces mises à jour remplacent le
+contenu fourni par PieceMaker — mais jamais ce que l'avocat a ajouté lui-même
+**en dehors** du dépôt. Cette
+skill sert de guide pour ranger un ajout personnel au bon endroit.
+
+## Où vivent les éléments personnels, et pourquoi ils survivent
+
+| Type d'ajout | Emplacement | Portée |
+| --- | --- | --- |
+| Instructions ou préférences globales (style, rappels, habitudes) | `/Users/tsardet/.piecemaker/custom/perso.md` | Toutes les affaires — ce fichier est importé automatiquement dans chaque dossier via `/Users/tsardet/.piecemaker/CLAUDE.md`. |
+| Skill personnelle réutilisable | Nouveau dossier `/Users/tsardet/.claude/skills/<nom>/SKILL.md` | Toutes les sessions Claude Code — découverte automatique, jamais écrasée par PieceMaker (un fichier créé à la main n'est jamais remplacé par l'application). |
+| Gabarit personnel (acte, courrier type…) | `/Users/tsardet/.piecemaker/templates/` | Disponible pour toute rédaction, indépendamment du dépôt de l'application. |
+| Élément propre à une seule affaire (parties, juridiction, échéances) | Section « Ce dossier » du `CLAUDE.md` / `AGENTS.md` de ce dossier | Uniquement ce dossier-là. |
+
+Ces emplacements sont hors du dépôt PieceMaker : une mise à jour de PieceMaker
+ne les touche jamais. Réciproquement, modifier l'un de
+ces fichiers ne modifie ni n'affecte le fonctionnement standard de
+PieceMaker — la garantie va dans les deux sens.
+
+## Format minimal d'une skill personnelle
+
+Un fichier `/Users/tsardet/.claude/skills/<nom>/SKILL.md` avec un en-tête
+puis du texte libre :
+
+```markdown
+---
+name: <nom>
+description: Une phrase expliquant quand cette skill doit se déclencher.
+---
+
+# Titre
+
+Instructions pour l'assistant, en français, centrées sur la tâche.
+```
+
+## Ce que l'assistant doit faire quand cette skill se déclenche
+
+1. **Demander ce que l'avocat veut ajouter** si ce n'est pas déjà clair :
+   une préférence générale, une skill dédiée, un gabarit, ou un élément
+   propre à un dossier en cours.
+2. **Choisir l'emplacement approprié** dans le tableau ci-dessus selon la
+   portée voulue (globale, réutilisable, ou limitée à un dossier).
+3. **Créer ou éditer le fichier correspondant**, en respectant le format
+   attendu (front matter pour une skill, section « Ce dossier » pour un
+   élément local, etc.).
+4. **Pour un nouveau dossier d'affaire** qui n'a pas encore de wrapper : sur
+   demande, proposer et créer `CLAUDE.md` et `AGENTS.md` à la racine du
+   dossier, avec exactement ce contenu (chemin absolu, jamais `~`) :
+
+   ```
+   @/Users/tsardet/.piecemaker/CLAUDE.md
+
+   # Ce dossier
+   <!-- Éléments propres à ce dossier : parties, juridiction, échéances, particularités. À compléter. -->
+   ```
+
+   Si l'un de ces deux fichiers existe déjà dans le dossier, ne jamais
+   l'écraser : le lire, et s'il ne contient pas déjà cette ligne d'import,
+   l'ajouter en tête sans supprimer le contenu existant.

package/server/piecemaker/vendor/piecemaker-plugin/skills/conversion-md/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: conversion-md
+description: Convertir un document (PDF, DOCX, image scannée, etc.) en Markdown avec le smart converter de PieceMaker, y compris choisir entre markitdown et MinerU (OCR). À utiliser dès qu'il faut transformer une pièce en Markdown avant analyse, anonymisation ou insertion dans Word.
+---
+
+# Conversion de documents en Markdown (smart_converter.py)
+
+## Commande
+
+`websocket-server/scripts/smart_converter.py` — arguments réels (argparse) :
+
+```
+python3 websocket-server/scripts/smart_converter.py <file> -o <output_dir> [--engine auto|markitdown|mineru] [--mode MODE] [--lang LANG]
+```
+
+- `file` : positionnel, fichier d'entrée.
+- `-o` / `--output` : **requis**, répertoire de sortie.
+- `--engine` : `auto` (défaut), `markitdown`, ou `mineru`.
+- `--mode` : mode MinerU (`pipeline` / `hybrid` / `vlm`), ignoré si le moteur
+  n'est pas MinerU.
+- `--lang` : code langue OCR pour MinerU.
+
+Exemple :
+```
+python3 websocket-server/scripts/smart_converter.py piece.pdf -o output/
+python3 websocket-server/scripts/smart_converter.py scan.jpg -o output/ --mode hybrid --lang latin
+```
+
+Côté serveur ce script est enregistré dans `PYTHON_SCRIPTS.convert`
+(`websocket-server/server.cjs`, ~ligne 3856) et déclenché via le Python
+Bridge (`taskpane/modules/python-bridge.js` →
+`executePythonScript('convert', file, options, callbacks)`).
+
+## Quand utiliser markitdown vs MinerU
+
+- **`markitdown`** — documents avec une vraie couche de texte : DOCX, PPTX,
+  XLSX, PDF "propre" (texte sélectionnable, pas d'image de page entière).
+  Rapide, pas de modèle OCR à charger.
+- **`mineru`** — PDF scannés ou basés sur image (pas de couche texte), scans
+  papier, photos de documents. Plus lent (OCR + mise en page), mais
+  nécessaire pour en extraire du texte exploitable.
+- **`auto`** (par défaut) — inspecte le fichier et choisit automatiquement
+  entre les deux ; c'est le choix par défaut à laisser tel quel sauf besoin
+  spécifique (ex. forcer `mineru` sur un PDF qui a une couche de texte
+  corrompue ou illisible).
+
+## Enchaînement avec le scan PII
+
+Pour convertir puis scanner en un seul appel, utiliser
+`websocket-server/scripts/convert_and_scan_pipeline.py <file1> [file2 ...] -o <output_dir> [--engine ...] [--mode ...] [--lang ...]`,
+qui appelle `smart_converter.py` puis
+`websocket-server/scripts/presidio-gliner/presidio-gliner.py` pour chaque
+fichier. Sortie persistante : un Markdown par
+fichier et un unique `{output_dir}/mapping_default.json` cumulatif. Dans le
+pipeline d'administration d'un dossier, `-o` vise le sous-dossier
+`Fichiers convertis PieceMaker/` du dossier (racine réservée aux originaux) ;
+le manifeste technique caché `.piecemaker/anonymization-state.json` reste, lui, à
+la racine du dossier, et sa clé est relative à la racine via `--case-root`. Les
+détections brutes par fichier restent temporaires et sont supprimées après leur
+fusion.

package/server/piecemaker/vendor/piecemaker-plugin/skills/recherche-juridique/SKILL.md

@@ -0,0 +1,234 @@
+---
+name: recherche-juridique
+description: "Rechercher un texte de loi ou une jurisprudence via le serveur MCP Légifrance et produire des citations vérifiables (bloc <CITATIONS>) pour une réponse ou un acte PieceMaker. À utiliser dès qu'un texte de loi, un article ou une décision doit être cité — jamais de mémoire. Le hook Stop `verify-citations.mjs` bloque le tour si une citation ne se retrouve pas mot pour mot dans une source réellement lue."
+---
+
+# Recherche juridique et citations vérifiables
+
+## Ce que ce skill garantit
+
+**Une citation n'est acceptée que si elle a été lue dans ce tour, mot pour
+mot.** Le hook Stop `verify-citations.mjs` relit chaque citation du bloc
+`<CITATIONS>` produit en fin de réponse, la localise mécaniquement dans le
+texte source réel, et bloque le tour si l'une d'elles est introuvable — même
+approximativement. Ce n'est jamais un jugement du modèle : c'est une
+recherche de sous-chaîne, tolérante aux espaces/casse/ponctuation mais pas au
+sens. Une citation reformulée, résumée ou inventée est rejetée.
+
+Ce skill décrit le déroulé de recherche avec les outils Légifrance
+effectivement disponibles, puis le format exact que le vérificateur accepte.
+
+## Outils du serveur MCP Légifrance
+
+| Outil | Rôle |
+| --- | --- |
+| `Search_Cour_Cassation` | Recherche ciblée dans la jurisprudence de la Cour de cassation (mots-clés, opérateurs ET/OU, expression exacte, référence d'article), filtrable par matière et publication au bulletin. |
+| `Search_Conseil_Etat` | Même recherche ciblée dans la jurisprudence du Conseil d'État, filtrable par publication au recueil Lebon. |
+| `Search_Cour_Appel` | Même recherche dans les cours d'appel, filtrable par ville — bien cibler (ville + dates), le volume est important. |
+| `Search_CAA` | Même recherche dans les cours administratives d'appel, filtrable par ville. |
+| `Search_Premiere_Instance` | Recherche dans les juridictions de première instance — volume très limité (~50 décisions), opérateur OU par défaut. |
+| `Search_Code` | Recherche dans les codes juridiques français (Code civil, Code du travail…) — référence d'article exacte (`L. 1235-3`), mots-clés ou expression exacte. Renvoie les identifiants `LEGIARTI…` des articles trouvés. |
+| `consulter_article` | Texte intégral et vigueur d'une version précise d'article, à partir de son identifiant `LEGIARTI…` rendu par `Search_Code`. |
+| `consulter_decision` | Rapatrie le texte intégral d'une décision à partir de son identifiant (`JURITEXT…`, `CETATEXT…`). **Rapatrie le texte intégral et le met en cache** (voir plus bas) — c'est le moyen normal de lire une décision avant de la citer. |
+| `Download_Query_Results` | Télécharge en masse tous les résultats d'une requête dans un dossier local, pour trier sans paginer. **Ne rapatrie pas le texte intégral** (voir l'avertissement ci-dessous) — sert au tri, jamais directement à la citation. |
+| `Build_Research_Corpus` | Construit un corpus exhaustif et reproductible sur une question de droit : plusieurs requêtes, déduplication, téléchargement et scan du texte intégral de chaque décision. **Rapatrie le texte intégral.** À utiliser pour une recherche large et systématique plutôt qu'un enchaînement manuel de `Search_*`. |
+| `Validate_Research_Cards` | Valide mécaniquement (sans LLM) le résultat de `Build_Research_Corpus` : une fiche par décision, citations confirmées dans le texte intégral, rapport de couverture. |
+| `Tracking_BODACC` | Situation d'une entreprise (procédures collectives) via son SIREN — hors jurisprudence, utile pour qualifier une partie. |
+
+### Le fait décisif : seuls deux chemins rendent une citation vérifiable
+
+Le vérificateur ne peut confirmer une citation que si le texte intégral de sa
+source est quelque part sur disque. Sur les trois façons dont le MCP restitue
+une décision, **une seule ne rapatrie pas ce texte** :
+
+- **`Build_Research_Corpus`** écrit `decisions.jsonl` (une décision par ligne,
+  champ `texte` = texte intégral réel) — vérifiable.
+- **`consulter_decision`** renvoie le texte intégral dans sa réponse d'outil ;
+  le hook `decision-cache.mjs` le capte au passage et l'écrit dans
+  `~/.piecemaker/decisions/<id>.json` — vérifiable.
+- **`Download_Query_Results`** écrit `results.json`, mais chaque entrée ne
+  contient que `id`, `titre`, `lien`, `date`, `analyse` (un sommaire) et,
+  optionnellement, `solution.dispositif` (le dispositif seul — jamais les
+  motifs). **Pas de texte intégral.** Citer une décision connue uniquement par
+  ce canal produira une citation non vérifiée et bloquera le tour.
+
+**Conséquence pratique** : `Download_Query_Results` sert à trier une liste de
+résultats (lire les titres/sommaires, écarter le hors-sujet). Dès qu'une
+décision de cette liste doit être citée, il faut d'abord la lire avec
+`consulter_decision` (ou l'avoir dans un corpus `Build_Research_Corpus`) —
+jamais citer directement depuis `results.json`.
+
+## Déroulé de recherche
+
+1. **Recherche large** avec l'outil `Search_*` adapté à la juridiction visée
+   (ou `Build_Research_Corpus` pour une question de droit qui mérite un
+   balayage systématique plutôt qu'une requête isolée). Pour un texte de loi,
+   `Search_Code`.
+2. **Tri** des résultats sur les seuls éléments déjà renvoyés (titre, sommaire,
+   date, `analyse`) — sans lire chaque décision en entier. `Download_Query_Results`
+   aide à trier un grand volume hors ligne.
+3. **Lecture** des seules décisions/articles retenus comme potentiellement
+   cite-worthy : `consulter_decision` (jurisprudence) ou `consulter_article`
+   (texte de loi), ou relecture du `decisions.jsonl` d'un corpus déjà construit.
+   Ne lire que ce qui sera effectivement cité ou a de bonnes chances de l'être
+   — pas systématiquement tout ce qui est remonté par la recherche large.
+4. **Citation** : une fois la décision ou l'article lu dans ce tour, en extraire
+   les passages utiles mot pour mot et construire le bloc `<CITATIONS>`
+   (format ci-dessous).
+
+## Discipline de citation
+
+- **Ne jamais citer une source qu'on n'a pas lue dans ce tour.** Une décision
+  connue seulement par son titre, son sommaire, un résumé mémorisé ou un
+  résultat de recherche n'est pas une source de citation valable — elle doit
+  d'abord être lue avec `consulter_decision` ou `consulter_article`.
+- **Une citation est une reproduction littérale**, jamais une reformulation
+  ni un résumé. Copier le texte exact de la source, ponctuation comprise si
+  possible (le vérificateur tolère un léger écart d'espace/casse/ponctuation,
+  pas un écart de sens).
+- **Au plus 3 extraits par citation**, chacun **25 mots maximum**, bien ciblés
+  sur l'affirmation qu'ils appuient.
+- **Références contiguës** : les marqueurs `[N]` dans le texte de la réponse
+  vont de `[1]` à `[N]` sans saut, dans l'ordre de première apparition. Chaque
+  `[N]` a exactement une entrée correspondante `"ref": N` dans le bloc
+  `<CITATIONS>`. Réutiliser un `ref` existant pour citer à nouveau la même
+  source/le même passage plutôt que d'en créer un nouveau.
+- Si une source utile n'a pas encore été lue, la lire avant de la citer — ou,
+  à défaut, dire qu'elle n'a pas pu être lue et ne pas s'appuyer dessus.
+
+## Format du bloc `<CITATIONS>`
+
+Le bloc est ajouté **à la toute fin** de la réponse, tel que parsé par
+`piecemaker-plugin/scripts/lib/citations.cjs` :
+
+```
+<CITATIONS>
+[ ... tableau JSON d'objets citation ... ]
+</CITATIONS>
+```
+
+Le contenu entre les balises doit être un tableau JSON valide (`JSON.parse`
+strict — pas de virgule finale, pas de commentaire). Chaque entrée du tableau
+prend l'une des deux formes suivantes.
+
+### Forme « jurisprudence » (`kind: "case"`)
+
+Identifie la décision par `decision_id` — l'identifiant Légifrance
+(`JURITEXT…`, `CETATEXT…`) tel que rendu par `Search_*`/`Download_Query_Results`/
+`Build_Research_Corpus`, et lu avec `consulter_decision` (ou présent dans un
+`decisions.jsonl`).
+
+```json
+{
+  "ref": 1,
+  "kind": "case",
+  "decision_id": "JURITEXT000012345678",
+  "quotes": [
+    { "quote": "le juge doit rechercher si l'inexécution est suffisamment grave" }
+  ]
+}
+```
+
+Plusieurs extraits de la même décision (jusqu'à 3) :
+
+```json
+{
+  "ref": 2,
+  "kind": "case",
+  "decision_id": "JURITEXT000012345678",
+  "quotes": [
+    { "quote": "premier extrait littéral, vingt-cinq mots au maximum" },
+    { "quote": "second extrait littéral, distinct du premier" }
+  ]
+}
+```
+
+`type` et `author` sont acceptés dans chaque objet `quotes` (facultatifs,
+informatifs, jamais vérifiés). `doc_id`, `page`, `sheet`, `cell` ou un `quote`
+au premier niveau n'ont pas de sens pour une citation de jurisprudence — ne
+pas les utiliser sur une entrée `case`.
+
+### Forme « document » (`kind: "document"`, ou `doc_id` sans `decision_id`)
+
+Identifie une pièce du dossier par `doc_id` (le chemin, absolu ou relatif à la
+racine du dossier, de sa contrepartie Markdown convertie — jamais l'original).
+Chaque extrait porte un localisateur `page` (numéro, ou `"N-M"` pour une plage)
+ou, pour un tableur, `sheet` + `cell` (adresse ou plage A1, ex. `"B7"` ou
+`"B7:C9"`).
+
+```json
+{
+  "ref": 3,
+  "doc_id": "pieces/contrat-bail.md",
+  "quotes": [
+    { "page": 3, "quote": "le preneur s'engage à occuper les lieux en bon père de famille" }
+  ]
+}
+```
+
+Extrait à cheval sur deux pages : `page` prend la forme `"N-M"` et la
+sentinelle `[[PAGE_BREAK]]` sépare, dans le même `quote`, le texte de fin de
+page N du texte de début de page M — chaque segment est vérifié
+indépendamment contre sa propre page.
+
+```json
+{
+  "ref": 4,
+  "doc_id": "pieces/attestation.md",
+  "quotes": [
+    { "page": "41-42", "quote": "texte de fin de page 41 [[PAGE_BREAK]] texte de début de page 42" }
+  ]
+}
+```
+
+Citation dans un tableur (pièce convertie contenant des tableaux `## Sheet:
+<nom>`) : `sheet` + `cell` remplacent `page`.
+
+```json
+{
+  "ref": 5,
+  "doc_id": "pieces/tableau-honoraires.md",
+  "quotes": [
+    { "sheet": "Honoraires", "cell": "B7", "quote": "3 500 €" }
+  ]
+}
+```
+
+Une citation à un seul extrait peut aussi s'écrire sous la forme abrégée
+(niveau supérieur au lieu de `quotes`) — `citations.cjs` l'accepte, elle
+retombe sur un tableau `quotes` d'un seul élément :
+
+```json
+{ "ref": 6, "doc_id": "pieces/mise-en-demeure.md", "page": 1, "quote": "je vous mets en demeure de régulariser sous huitaine" }
+```
+
+## Ce que fait le vérificateur, et quoi faire quand il bloque
+
+À l'arrêt du tour, `verify-citations.mjs` :
+
+1. Parse le bloc `<CITATIONS>` du dernier message.
+2. Pour chaque citation, résout sa source réelle — texte intégral de la
+   décision (corpus `Build_Research_Corpus`, cache `consulter_decision`, ou en
+   dernier recours le sommaire de `Download_Query_Results`) ou pièce
+   Markdown du dossier.
+3. Localise mécaniquement chaque extrait dans ce texte. Un extrait qui a
+   légèrement dérivé (espace, casse, ponctuation) est **corrigé
+   automatiquement** avec l'extrait source exact — ce n'est pas une faute.
+4. Un extrait introuvable, même tolérant, **bloque le tour** : la réponse
+   liste chaque citation fautive avec son identifiant et le motif (source
+   inconnue, source illisible, ou introuvable dans la source).
+
+Quand ça arrive : soit relire la source exacte et reprendre le texte réel de
+l'extrait fautif (jamais le reformuler pour le faire passer), soit retirer la
+citation si elle ne peut pas être justifiée par une source effectivement lue.
+
+## Ce qu'il ne faut pas faire
+
+- Ne jamais citer une décision connue uniquement par un résultat
+  `Download_Query_Results` sans l'avoir d'abord lue avec `consulter_decision`.
+- Ne jamais paraphraser un extrait pour qu'il « sonne » comme la source — le
+  vérificateur tolère l'espace/la casse/la ponctuation, pas le sens.
+- Ne jamais laisser un `ref` sauter un numéro ou repartir en désordre.
+- Ne jamais dépasser 3 extraits par citation ni 25 mots par extrait.
+- Ne jamais inventer un `decision_id` ou un `doc_id` pour combler un manque de
+  source.