@piecemaker-legal/piecemaker 1.0.6

package/server/piecemaker/harness/decisions.cjs

@@ -0,0 +1,302 @@
+'use strict';
+
+/**
+ * Capture des décisions Légifrance lues via l'outil MCP `consulter_decision`,
+ * repérées dans un corps de requête SORTANTE déjà analysé en JSON par le
+ * proxy PII (`server/piecemaker/anonymizer/proxy.cjs`).
+ *
+ * Équivalent serveur du hook `decision-cache.mjs` de l'autre dépôt
+ * (`piecemaker-plugin/scripts/decision-cache.mjs`, PostToolUse Claude Code) :
+ * ce dépôt n'a pas de hook, tout le trafic IA (chat et terminal) traverse ce
+ * proxy, qui est donc la position équivalente pour intercepter le même appel
+ * d'outil. `consulter_decision` est la seule des trois façons dont le MCP
+ * Légifrance restitue une décision à ne jamais l'écrire sur disque — sans
+ * cette capture, une citation portant sur une décision lue par cet outil
+ * resterait invérifiable (voir `citation-sources.cjs` côté vendor).
+ *
+ * Deux formes de charge utile à couvrir, selon le fournisseur :
+ *  - **Anthropic Messages** (`payload.messages[]`) : un bloc assistant
+ *    `{type:'tool_use', id, name, input}` porte le nom de l'outil et ses
+ *    arguments, un bloc user `{type:'tool_result', tool_use_id, content}`
+ *    porte la réponse — appariés par `tool_use_id` -> `id`.
+ *  - **OpenAI Responses** (`payload.input[]`) : `{type:'function_call',
+ *    call_id, name, arguments}` (arguments = JSON en chaîne) et
+ *    `{type:'function_call_output', call_id, output}`, appariés par
+ *    `call_id`.
+ *
+ * Extraction du texte intégral (ancrage sur la bannière `TEXTE INTÉGRAL:`
+ * entre lignes de `=`, coupure avant la ligne finale `Lien:`), validation de
+ * l'identifiant et règle de non-régression (on n'écrit que si le texte
+ * capturé est strictement plus long que celui déjà en cache) : copiées à
+ * l'identique de `decision-cache.mjs`. Seul le champ `source` change
+ * (`proxy-piecemaker` au lieu de `consulter_decision`), pour qu'on distingue
+ * dans le cache lequel des deux canaux a écrit l'entrée.
+ *
+ * Fail-open comme tout le reste du harnais : `captureDecisions` ne jette
+ * jamais, quelle que soit la charge utile reçue.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Un identifiant de décision Légifrance ne contient jamais de séparateur de
+// chemin ni de point : cette forme fermée interdit toute évasion du dossier
+// de cache, quelle que soit la valeur renvoyée par l'outil.
+const ID_RE = /^[A-Za-z0-9_-]{1,80}$/;
+
+const ANCHOR_RE = /TEXTE INTÉGRAL\s*:/;
+const SEPARATOR_LINE_RE = /^=+[ \t]*$/m;
+const LIEN_LINE_RE = /^Lien\s*:.*$/m;
+const TITRE_LINE_RE = /^D\u00c9CISION\s*:[ \t]*(.+)$/m;
+const ARTICLE_NUM_RE = /^\*\*(.+?)\*\*[ \t]*$/m;
+const ARTICLE_CODE_RE = /^Code\s*:[ \t]*(.+)$/m;
+const ARTICLE_ID_LINE_RE = /^Identifiant\s*:[ \t]*(.+)$/m;
+const MAX_TITRE_LENGTH = 300;
+
+/** `true` seulement pour le suffixe `consulter_decision` d'un outil MCP. */
+function isConsulterDecisionTool(toolName) {
+  return typeof toolName === 'string' && toolName.startsWith('mcp__') && toolName.endsWith('__consulter_decision');
+}
+
+/** `true` pour un résultat d'outil marqué en erreur, sous ses graphies usuelles. */
+function isErrorResult(result) {
+  if (!result || typeof result !== 'object') return false;
+  return result.is_error === true || result.isError === true || result.success === false;
+}
+
+/**
+ * Aplatit le contenu d'un résultat d'outil en une seule chaîne, quelle que
+ * soit la forme reçue : un tableau de blocs `{type:'text', text}`, un objet
+ * `{text}`, ou une chaîne brute.
+ */
+function flattenContent(value) {
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) {
+    return value
+      .filter((block) => block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string')
+      .map((block) => block.text)
+      .join('\n');
+  }
+  if (value && typeof value === 'object' && typeof value.text === 'string') return value.text;
+  return '';
+}
+
+/**
+ * Extrait le texte intégral encadré par le second séparateur `=` (celui qui
+ * suit la ligne `TEXTE INTÉGRAL:`) jusqu'à la ligne `Lien:` finale (exclue),
+ * trimé. Si l'ancre `TEXTE INTÉGRAL:` est absente, conserve le texte complet
+ * reçu tel quel — une source plus large qu'aucune source, la vérification
+ * reste exacte dans les deux cas.
+ */
+function extractFullText(raw) {
+  if (typeof raw !== 'string' || !raw) return '';
+
+  const anchorMatch = ANCHOR_RE.exec(raw);
+  if (!anchorMatch) return raw;
+
+  const afterAnchor = raw.slice(anchorMatch.index + anchorMatch[0].length);
+  const sepMatch = SEPARATOR_LINE_RE.exec(afterAnchor);
+  if (!sepMatch) return raw;
+
+  let body = afterAnchor.slice(sepMatch.index + sepMatch[0].length);
+  const lienMatch = LIEN_LINE_RE.exec(body);
+  if (lienMatch) body = body.slice(0, lienMatch.index);
+
+  return body.trim();
+}
+
+/**
+ * Renvoie le titre lisible d'un article de code (« Code civil, article 1103 »)
+ * à partir de l'entête de `consulter_article` : la ligne `**<num>**`, la
+ * ligne `Code:` et la ligne `Identifiant:` qui atteste de cette forme.
+ * Chaîne vide si l'entête n'est pas celui d'un article.
+ */
+function extractArticleTitle(raw) {
+  if (typeof raw !== 'string' || !raw) return '';
+  const header = raw.slice(0, 2000);
+  if (!ARTICLE_ID_LINE_RE.test(header)) return '';
+  const numero = ARTICLE_NUM_RE.exec(header)?.[1].trim();
+  if (!numero) return '';
+  const code = ARTICLE_CODE_RE.exec(header)?.[1].trim();
+  const article = /^article\b/i.test(numero) ? numero : `article ${numero}`;
+  return (code ? `${code}, ${article}` : article.charAt(0).toUpperCase() + article.slice(1)).slice(0, MAX_TITRE_LENGTH);
+}
+
+/**
+ * Titre lisible d'une source Légifrance, quelle que soit sa nature : décision
+ * (`consulter_decision`) ou article de code (`consulter_article`).
+ */
+function extractSourceTitle(raw) {
+  return extractDecisionTitle(raw) || extractArticleTitle(raw);
+}
+
+/**
+ * Renvoie le titre lisible de la décision (« Cour de cassation, civile,
+ * Chambre commerciale, 23 janvier 2016, … ») porté par la ligne `DÉCISION:`
+ * en tête du résultat d'outil, avant la bannière `TEXTE INTÉGRAL:`.
+ * Chaîne vide si l'entête est absent : l'appelant retombe sur l'identifiant.
+ */
+function extractDecisionTitle(raw) {
+  if (typeof raw !== 'string' || !raw) return '';
+  const anchorMatch = ANCHOR_RE.exec(raw);
+  const header = anchorMatch ? raw.slice(0, anchorMatch.index) : raw;
+  const match = TITRE_LINE_RE.exec(header);
+  if (!match) return '';
+  return match[1].trim().slice(0, MAX_TITRE_LENGTH);
+}
+
+function cacheFile(decisionsDir, id) {
+  return path.join(decisionsDir, `${id}.json`);
+}
+
+function existingCachedLength(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return typeof parsed?.texte === 'string' ? parsed.texte.length : -1;
+  } catch {
+    return -1;
+  }
+}
+
+/** mkdir -p qui ne jette jamais — l'appelant vérifie la valeur de retour. */
+function ensureDirSafe(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Écrit le cache pour une décision reconnue (identifiant + contenu brut du
+ * résultat d'outil déjà appariés par l'appelant). Renvoie `true` si une
+ * écriture a eu lieu.
+ */
+function writeDecisionCache(rawId, rawContent, { decisionsDir, session }) {
+  const id = typeof rawId === 'string' ? rawId.trim() : '';
+  if (!id || !ID_RE.test(id)) return false;
+
+  const raw = flattenContent(rawContent);
+  const texte = extractFullText(raw).trim();
+  if (!texte) return false;
+  const titre = extractDecisionTitle(raw);
+
+  const file = cacheFile(decisionsDir, id);
+  // Ne réécrit que si le texte capturé est strictement plus long que celui
+  // déjà en cache : un appel ultérieur plus pauvre (erreur, troncature) ne
+  // doit jamais dégrader une source déjà meilleure.
+  if (texte.length <= existingCachedLength(file)) return false;
+
+  if (!ensureDirSafe(decisionsDir)) return false;
+  fs.writeFileSync(
+    file,
+    `${JSON.stringify(
+      {
+        kind: 'legifrance-decision',
+        id,
+        titre: titre || undefined,
+        texte,
+        caracteres: texte.length,
+        source: 'proxy-piecemaker',
+        session: session || null,
+        at: new Date().toISOString(),
+      },
+      null,
+      2,
+    )}\n`,
+    'utf8',
+  );
+  return true;
+}
+
+/** Forme Anthropic Messages : `payload.messages[].content[]`. */
+function captureFromAnthropicMessages(payload, options) {
+  const messages = Array.isArray(payload.messages) ? payload.messages : [];
+
+  // Le nom de l'outil n'est porté que par le bloc `tool_use` (assistant) :
+  // on l'indexe par `id` pour l'apparier au `tool_result` (user) correspondant.
+  const toolUseInputs = new Map();
+  for (const message of messages) {
+    const blocks = Array.isArray(message?.content) ? message.content : [];
+    for (const block of blocks) {
+      if (!block || typeof block !== 'object' || block.type !== 'tool_use') continue;
+      if (!isConsulterDecisionTool(block.name)) continue;
+      toolUseInputs.set(block.id, block.input);
+    }
+  }
+  if (!toolUseInputs.size) return 0;
+
+  let count = 0;
+  for (const message of messages) {
+    const blocks = Array.isArray(message?.content) ? message.content : [];
+    for (const block of blocks) {
+      if (!block || typeof block !== 'object' || block.type !== 'tool_result') continue;
+      const input = toolUseInputs.get(block.tool_use_id);
+      if (!input) continue; // pas un appel `consulter_decision` reconnu
+      if (isErrorResult(block)) continue;
+      const rawId = input?.text_id ?? input?.id;
+      if (writeDecisionCache(rawId, block.content, options)) count += 1;
+    }
+  }
+  return count;
+}
+
+/** Forme OpenAI Responses : `payload.input[]`. */
+function captureFromResponsesInput(payload, options) {
+  const items = Array.isArray(payload.input) ? payload.input : [];
+
+  const callInputs = new Map();
+  for (const item of items) {
+    if (!item || typeof item !== 'object' || item.type !== 'function_call') continue;
+    if (!isConsulterDecisionTool(item.name)) continue;
+    let input = {};
+    try {
+      input = JSON.parse(item.arguments);
+    } catch {
+      input = {};
+    }
+    callInputs.set(item.call_id, input);
+  }
+  if (!callInputs.size) return 0;
+
+  let count = 0;
+  for (const item of items) {
+    if (!item || typeof item !== 'object' || item.type !== 'function_call_output') continue;
+    const input = callInputs.get(item.call_id);
+    if (!input) continue; // pas un appel `consulter_decision` reconnu
+    if (isErrorResult(item)) continue;
+    const rawId = input?.text_id ?? input?.id;
+    if (writeDecisionCache(rawId, item.output, options)) count += 1;
+  }
+  return count;
+}
+
+/**
+ * Repère les résultats de l'outil `consulter_decision` dans `payload` (déjà
+ * analysé en JSON) et écrit leur texte intégral dans
+ * `<decisionsDir>/<id>.json`. Renvoie le nombre de décisions effectivement
+ * écrites. Ne jette jamais : une charge utile inattendue renvoie simplement 0.
+ */
+function captureDecisions(payload, options = {}) {
+  try {
+    const { decisionsDir } = options;
+    if (!payload || typeof payload !== 'object' || !decisionsDir) return 0;
+    return (
+      captureFromAnthropicMessages(payload, options) +
+      captureFromResponsesInput(payload, options)
+    );
+  } catch {
+    return 0;
+  }
+}
+
+module.exports = {
+  ID_RE,
+  isConsulterDecisionTool,
+  extractFullText,
+  extractDecisionTitle,
+  extractArticleTitle,
+  extractSourceTitle,
+  captureDecisions,
+};

package/server/piecemaker/harness/flux-sse.cjs

@@ -0,0 +1,111 @@
+'use strict';
+
+/**
+ * Collecteur du texte visible d'un flux SSE, pour le harnais de citations
+ * (`verification.cjs` vérifie le dernier message de l'assistant, jamais un
+ * fragment isolé) — un bloc `<CITATIONS>` n'existe qu'une fois le message
+ * entièrement reconstitué.
+ *
+ * Mêmes trois formats de fil que `rewrite.cjs` (`createSseRewriter`), lus à
+ * l'identique plutôt que devinés : Anthropic (`content_block_delta`, champ
+ * `delta.text`), Responses d'OpenAI (`response.output_text.delta`, champ
+ * `delta`) et Chat Completions (`choices[].delta.content`). Volontairement
+ * exclus : `delta.thinking` et `delta.partial_json` côté Anthropic (le
+ * raisonnement et les arguments d'outil ne sont pas le texte de réponse), et
+ * `reasoning_content`/`refusal` côté Chat Completions pour la même raison.
+ *
+ * Ce collecteur lit exactement ce qui est ÉCRIT AU CLIENT (donc après le
+ * rewriter de `rewrite.cjs` quand il y en a un) : il ne refait aucune
+ * substitution, il ne fait qu'observer un texte déjà en clair.
+ *
+ * Ne jette jamais : un événement illisible (JSON invalide, forme inattendue)
+ * est simplement ignoré, jamais une exception qui remonterait au proxy.
+ */
+
+/**
+ * Plafond de mémoire, en caractères accumulés. Un bloc `<CITATIONS>` se
+ * trouve toujours en fin de réponse : au-delà de ce plafond, on cesse
+ * d'accumuler plutôt que de laisser grossir la mémoire sans fin sur une
+ * réponse anormalement longue — la vérification portera alors sur un texte
+ * tronqué (donc un bloc `<CITATIONS>` absent, silence total côté harnais),
+ * ce qui est le sens de la marche sûr plutôt qu'une fuite mémoire.
+ */
+const MAX_CARACTERES_COLLECTES = 2 * 1024 * 1024;
+
+/** Texte visible porté par un événement déjà analysé en JSON, ou `''`. */
+function texteVisible(parsed) {
+  if (!parsed || typeof parsed !== 'object') return '';
+
+  if (parsed.type === 'content_block_delta' && typeof parsed.delta?.text === 'string') {
+    return parsed.delta.text;
+  }
+
+  if (parsed.type === 'response.output_text.delta' && typeof parsed.delta === 'string') {
+    return parsed.delta;
+  }
+
+  if (Array.isArray(parsed.choices)) {
+    let out = '';
+    for (const choice of parsed.choices) {
+      if (choice && typeof choice.delta?.content === 'string') out += choice.delta.content;
+    }
+    return out;
+  }
+
+  return '';
+}
+
+/**
+ * @returns {{ push: (chunk: string) => void, texte: () => string }}
+ */
+function createCollecteurTexte() {
+  let pending = '';
+  let texte = '';
+  let plein = false;
+
+  function absorbeLigne(line) {
+    if (!line.startsWith('data: ')) return;
+    const payload = line.slice(6).trim();
+    if (!payload || payload === '[DONE]') return;
+
+    let parsed;
+    try {
+      parsed = JSON.parse(payload);
+    } catch {
+      return; // ligne SSE illisible : ignorée, jamais une exception.
+    }
+
+    const fragment = texteVisible(parsed);
+    if (!fragment) return;
+    texte += fragment;
+    if (texte.length >= MAX_CARACTERES_COLLECTES) plein = true;
+  }
+
+  return {
+    push(chunk) {
+      if (plein) return;
+      try {
+        pending += typeof chunk === 'string' ? chunk : String(chunk);
+        // On ne traite que les lignes complètes ; la dernière (peut-être
+        // coupée par la frontière de ce fragment) attend le prochain appel.
+        const lines = pending.split('\n');
+        pending = lines.pop();
+        for (const line of lines) {
+          if (plein) break;
+          absorbeLigne(line);
+        }
+      } catch {
+        // Un fragment illisible ne doit jamais interrompre la collecte.
+      }
+    },
+
+    texte() {
+      return texte;
+    },
+  };
+}
+
+module.exports = {
+  MAX_CARACTERES_COLLECTES,
+  createCollecteurTexte,
+};

package/server/piecemaker/harness/index.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+/**
+ * Façade du harnais de citations vérifiées, à brancher sur le proxy PII
+ * local (`server/piecemaker/anonymizer/proxy.cjs`) — câblage laissé à une
+ * tâche ultérieure, ce module ne modifie rien de `proxy.cjs`.
+ *
+ * Deux observateurs, symétriques au sens et au retour du proxy lui-même :
+ *  - `observerRequete` regarde ce qui PART vers le fournisseur (avant
+ *    anonymisation) pour y capter une éventuelle lecture de décision
+ *    Légifrance via `consulter_decision` (`decisions.cjs`).
+ *  - `observerReponse` regarde le dernier message produit par le modèle
+ *    (après dé-anonymisation) pour y vérifier mécaniquement un éventuel bloc
+ *    `<CITATIONS>` (`verification.cjs`).
+ *
+ * Les deux ne jettent jamais : une erreur d'observation ne doit jamais faire
+ * échouer une requête ou une réponse qui, elle, doit continuer son chemin.
+ *
+ * Interrupteur `PIECEMAKER_CITATIONS=off` : les deux observateurs deviennent
+ * des no-op, à l'image de `PIECEMAKER_CITATIONS_VERIFY=off` dans l'autre
+ * dépôt (hook `verify-citations.mjs`).
+ */
+
+const path = require('node:path');
+
+const { captureDecisions } = require('./decisions.cjs');
+const { verifierReponse } = require('./verification.cjs');
+
+function isJsonLike(contentType) {
+  return /\bjson\b/i.test(String(contentType || ''));
+}
+
+function parseJsonBody(body) {
+  if (body === null || body === undefined) return null;
+  const text = typeof body === 'string' ? body : body.toString('utf8');
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function isOff() {
+  return process.env.PIECEMAKER_CITATIONS === 'off';
+}
+
+function emptyVerification() {
+  return { analysee: false, citations: 0, nonVerifiees: 0, details: [] };
+}
+
+/**
+ * @param {object} options
+ * @param {string} options.homeDir Dossier PieceMaker (`~/.piecemaker` en
+ *   production) — les décisions vont dans `<homeDir>/decisions/`, le journal
+ *   de vérification dans `<homeDir>/citations-verifiees.jsonl`.
+ */
+function createHarnessJuridique({ homeDir, verifyResponses = true } = {}) {
+  const decisionsDir = typeof homeDir === 'string' && homeDir ? path.join(homeDir, 'decisions') : null;
+  const stats = { decisions: 0, tours: 0, nonVerifiees: 0 };
+
+  return {
+    stats,
+
+    /**
+     * N'agit que sur un corps JSON. Renvoie le nombre de décisions capturées
+     * (0 si l'interrupteur est coupé, si le content-type n'est pas JSON, si
+     * le corps ne s'analyse pas, ou en cas d'erreur quelconque).
+     */
+    observerRequete(body, contentType, { session } = {}) {
+      try {
+        if (isOff() || !decisionsDir || !isJsonLike(contentType)) return 0;
+        const payload = parseJsonBody(body);
+        if (!payload) return 0;
+        const count = captureDecisions(payload, { decisionsDir, session });
+        stats.decisions += count;
+        return count;
+      } catch {
+        return 0;
+      }
+    },
+
+    /**
+     * Vérifie le dernier message du modèle. Renvoie toujours la forme de
+     * `verifierReponse`, jamais une exception.
+     */
+    async observerReponse(texteAssistant, { session } = {}) {
+      try {
+        if (isOff() || !verifyResponses) return emptyVerification();
+        const result = await verifierReponse(texteAssistant, { homeDir, session });
+        if (result?.analysee) {
+          stats.tours += 1;
+          stats.nonVerifiees += result.nonVerifiees;
+        }
+        return result;
+      } catch {
+        return emptyVerification();
+      }
+    },
+  };
+}
+
+module.exports = { createHarnessJuridique };

package/server/piecemaker/harness/source-passages.ts

@@ -0,0 +1,21 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+import { findApplicationRoot, getModuleDirectory } from '@/shared/utils.js';
+
+const root = findApplicationRoot(getModuleDirectory(import.meta.url));
+const { locateQuote, verifyQuoteAgainstSource } = createRequire(import.meta.url)(
+  path.join(root, 'server/piecemaker/vendor/piecemaker-plugin/scripts/lib/verify-citations.cjs'),
+);
+
+export function locateSourcePassages(source: string, quotes: Array<{ quote: string }>) {
+  const ranges: Array<{ start: number; end: number; quoteIndex: number }> = [];
+  quotes.forEach((quote, quoteIndex) => {
+    if (!verifyQuoteAgainstSource(source, quote.quote).verified) return;
+    for (const segment of quote.quote.split(/\[\[PAGE_BREAK\]\]|\.{3}|…/).map((part) => part.trim()).filter(Boolean)) {
+      const location = locateQuote(source, segment);
+      if (location) ranges.push({ start: location.start, end: location.end, quoteIndex });
+    }
+  });
+  return ranges;
+}

package/server/piecemaker/harness/verification.cjs

@@ -0,0 +1,159 @@
+'use strict';
+
+/**
+ * Vérification mécanique des citations d'un tour de chat — équivalent
+ * serveur du hook Stop `verify-citations.mjs` de l'autre dépôt
+ * (`piecemaker-plugin/scripts/verify-citations.mjs`).
+ *
+ * Ce dépôt n'a pas de hook Claude Code : tout le trafic IA passe par le
+ * proxy PII local (`server/piecemaker/anonymizer/proxy.cjs`), qui est donc
+ * l'unique point d'observation possible pour un texte produit par le modèle.
+ * Contrairement au hook d'origine, ce module n'a pas le pouvoir de bloquer
+ * un tour (il n'y a pas de conversation Claude Code à interrompre côté
+ * proxy) : il se contente d'observer, de vérifier mécaniquement et de
+ * journaliser — le blocage éventuel reste une décision de l'appelant
+ * (câblage laissé à une tâche ultérieure).
+ *
+ * Enchaînement, fidèle à Mike et au hook d'origine : détection du bloc
+ * `<CITATIONS>` (cas de très loin le plus fréquent : absent, silence total)
+ * → parse (`citations.cjs`) → résolution des sources (`citation-sources.cjs`,
+ * décisions Légifrance + pièces du dossier) → vérification mécanique
+ * (`verify-citations.cjs`) → journalisation dans
+ * `<homeDir>/citations-verifiees.jsonl`.
+ *
+ * Garantie de confidentialité : le journal ne contient JAMAIS le texte d'une
+ * citation ni celui d'une source — seulement des identifiants et un motif
+ * d'échec parmi trois valeurs fixes (« source inconnue », « source
+ * illisible », « introuvable dans la source »).
+ *
+ * Ne jette jamais : toute erreur inattendue (bloc malformé compris) retombe
+ * sur `{ analysee: false, citations: 0, nonVerifiees: 0, details: [] }`.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { parseCitationsWithDiagnostics } = require('../vendor/piecemaker-plugin/scripts/lib/citations.cjs');
+const { verifyCitations, UNREADABLE_SOURCES } = require('../vendor/piecemaker-plugin/scripts/lib/verify-citations.cjs');
+const {
+  createDecisionTextResolver,
+  createDocumentTextResolver,
+} = require('../vendor/piecemaker-plugin/scripts/lib/citation-sources.cjs');
+
+const LOG_FILE_NAME = 'citations-verifiees.jsonl';
+
+function emptyResult() {
+  return { analysee: false, citations: 0, nonVerifiees: 0, details: [] };
+}
+
+/** mkdir -p qui ne jette jamais. */
+function ensureDirSafe(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Identifiant lisible d'une citation pour le journal. */
+function citationIdentifier(citation) {
+  if (citation?.kind === 'case') return `decision:${citation.decision_id ?? '?'}#${citation.ref ?? '?'}`;
+  return `document:${citation?.doc_id ?? '?'}#${citation?.ref ?? '?'}`;
+}
+
+/**
+ * Reclasse l'échec d'une citation en rappelant la source qui a servi (ou pas)
+ * à sa vérification — jamais un LLM, purement mécanique. Trois motifs, sans
+ * jamais exposer de texte : source inconnue (résolveur vide : identifiant
+ * introuvable), source illisible (sentinelle `UNREADABLE_SOURCES`), ou
+ * introuvable dans la source (la source existe mais ne contient pas la
+ * citation, même tolérante aux espaces/casse/ponctuation).
+ */
+async function classifyFailureReason(citation, getSourceText, getDecisionText) {
+  let source = '';
+  try {
+    source = citation.kind === 'case'
+      ? await getDecisionText(citation.decision_id)
+      : await getSourceText(citation.doc_id);
+  } catch {
+    source = '';
+  }
+  const text = typeof source === 'string' ? source : '';
+  if (!text) return 'source inconnue';
+  if (UNREADABLE_SOURCES.has(text)) return 'source illisible';
+  return 'introuvable dans la source';
+}
+
+/** Journalise une ligne — jamais de texte de citation ni de source. */
+function logVerification(homeDir, entry) {
+  if (typeof homeDir !== 'string' || !homeDir) return;
+  try {
+    ensureDirSafe(homeDir);
+    fs.appendFileSync(path.join(homeDir, LOG_FILE_NAME), `${JSON.stringify(entry)}\n`, 'utf8');
+  } catch {
+    // Une panne du journal ne doit jamais faire échouer la vérification.
+  }
+}
+
+/**
+ * Vérifie les citations du bloc `<CITATIONS>` d'un message d'assistant.
+ *
+ * @param {string} texteAssistant Dernier message produit par le modèle.
+ * @param {object} [options]
+ * @param {string} [options.homeDir] Dossier où journaliser (`~/.piecemaker` typiquement).
+ * @param {string|null} [options.session] Identifiant d'session, purement informatif.
+ * @param {{getDecisionText: Function, getSourceText: Function}} [options.resolvers]
+ *   Résolveurs de source injectables (tests) ; par défaut, ceux de
+ *   `citation-sources.cjs` sur le répertoire courant.
+ * @returns {Promise<{analysee: boolean, citations: number, nonVerifiees: number, details: Array}>}
+ */
+async function verifierReponse(texteAssistant, options = {}) {
+  try {
+    if (typeof texteAssistant !== 'string' || !texteAssistant) return emptyResult();
+
+    const { citations, diagnostics } = parseCitationsWithDiagnostics(texteAssistant);
+    if (!diagnostics.hasBlock) return emptyResult(); // cas de très loin le plus fréquent
+
+    const { homeDir, session, resolvers } = options;
+    const getDecisionText = resolvers?.getDecisionText || createDecisionTextResolver([process.cwd()]);
+    const getSourceText = resolvers?.getSourceText || createDocumentTextResolver(process.cwd());
+
+    let verified = [];
+    try {
+      verified = await verifyCitations(citations, getSourceText, getDecisionText);
+    } catch {
+      verified = [];
+    }
+
+    const details = [];
+    let nonVerifiees = 0;
+    for (const citation of verified) {
+      const id = citationIdentifier(citation);
+      if (citation?.verified === false) {
+        nonVerifiees += 1;
+        const motif = await classifyFailureReason(citation, getSourceText, getDecisionText);
+        details.push({ id, verified: false, motif });
+      } else {
+        details.push({ id, verified: true, motif: null });
+      }
+    }
+
+    logVerification(homeDir, {
+      session_id: session || null,
+      at: new Date().toISOString(),
+      citations: verified.length,
+      non_verifiees: nonVerifiees,
+      details,
+    });
+
+    return { analysee: true, citations: verified.length, nonVerifiees, details };
+  } catch {
+    return emptyResult();
+  }
+}
+
+module.exports = {
+  LOG_FILE_NAME,
+  verifierReponse,
+};