@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/harness/harness.test.js

@@ -0,0 +1,296 @@
+/**
+ * Harnais de citations vérifiées — capture des décisions Légifrance lues via
+ * `consulter_decision` et vérification mécanique du bloc `<CITATIONS>`.
+ *
+ * Chaque test utilise un `homeDir` temporaire (`fs.mkdtempSync`) : jamais le
+ * vrai `~/.piecemaker` de la machine.
+ */
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import test from 'node:test';
+
+const require = createRequire(import.meta.url);
+const { captureDecisions } = require('./decisions.cjs');
+const { verifierReponse } = require('./verification.cjs');
+const { createHarnessJuridique } = require('./index.cjs');
+
+function makeHome() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pm-harness-'));
+}
+
+const TEXTE_COMPLET = [
+  'Cour de cassation, arrêt du 12 janvier 2024',
+  '',
+  '=================================',
+  'TEXTE INTÉGRAL:',
+  '=================================',
+  '',
+  "Attendu que le salarié a été licencié sans cause réelle et sérieuse ;",
+  '',
+  'Lien: https://www.legifrance.gouv.fr/juri/id/JURITEXT000012345678',
+].join('\n');
+
+const EXTRAIT_ATTENDU = "Attendu que le salarié a été licencié sans cause réelle et sérieuse ;";
+
+// ---------------------------------------------------------------------------
+// decisions.cjs — captureDecisions
+// ---------------------------------------------------------------------------
+
+test('capture une décision consulter_decision au format Anthropic Messages (appariement tool_use/tool_result)', () => {
+  const homeDir = makeHome();
+  const decisionsDir = path.join(homeDir, 'decisions');
+  const payload = {
+    messages: [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool_use', id: 'toolu_1', name: 'mcp__legifrance__consulter_decision', input: { text_id: 'JURITEXT000012345678' } },
+        ],
+      },
+      {
+        role: 'user',
+        content: [
+          { type: 'tool_result', tool_use_id: 'toolu_1', content: [{ type: 'text', text: TEXTE_COMPLET }] },
+        ],
+      },
+    ],
+  };
+
+  const count = captureDecisions(payload, { decisionsDir, session: 'sess-1' });
+  assert.equal(count, 1);
+
+  const cached = JSON.parse(fs.readFileSync(path.join(decisionsDir, 'JURITEXT000012345678.json'), 'utf8'));
+  assert.equal(cached.kind, 'legifrance-decision');
+  assert.equal(cached.id, 'JURITEXT000012345678');
+  assert.equal(cached.texte, EXTRAIT_ATTENDU);
+  assert.equal(cached.source, 'proxy-piecemaker');
+  assert.equal(cached.session, 'sess-1');
+});
+
+test('capture une décision consulter_decision au format OpenAI Responses (appariement call_id)', () => {
+  const homeDir = makeHome();
+  const decisionsDir = path.join(homeDir, 'decisions');
+  const payload = {
+    input: [
+      {
+        type: 'function_call',
+        call_id: 'call_1',
+        name: 'mcp__legifrance__consulter_decision',
+        arguments: JSON.stringify({ id: 'CETATEXT000098765432' }),
+      },
+      { type: 'function_call_output', call_id: 'call_1', output: TEXTE_COMPLET },
+    ],
+  };
+
+  const count = captureDecisions(payload, { decisionsDir, session: null });
+  assert.equal(count, 1);
+
+  const cached = JSON.parse(fs.readFileSync(path.join(decisionsDir, 'CETATEXT000098765432.json'), 'utf8'));
+  assert.equal(cached.texte, EXTRAIT_ATTENDU);
+  assert.equal(cached.source, 'proxy-piecemaker');
+  assert.equal(cached.session, null);
+});
+
+test('un identifiant invalide (séparateur de chemin) n’écrit jamais hors du cache', () => {
+  const homeDir = makeHome();
+  const decisionsDir = path.join(homeDir, 'decisions');
+  const payload = {
+    messages: [
+      { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'mcp__legifrance__consulter_decision', input: { text_id: '../../etc/passwd' } }] },
+      { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: [{ type: 'text', text: TEXTE_COMPLET }] }] },
+    ],
+  };
+
+  const count = captureDecisions(payload, { decisionsDir, session: null });
+  assert.equal(count, 0);
+  assert.equal(fs.existsSync(decisionsDir), false, 'le dossier de cache n’aurait même pas dû être créé');
+});
+
+test('un résultat d’erreur (is_error) est ignoré', () => {
+  const homeDir = makeHome();
+  const decisionsDir = path.join(homeDir, 'decisions');
+  const payload = {
+    messages: [
+      { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'mcp__legifrance__consulter_decision', input: { text_id: 'JURITEXT000000000001' } }] },
+      { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', is_error: true, content: [{ type: 'text', text: TEXTE_COMPLET }] }] },
+    ],
+  };
+
+  assert.equal(captureDecisions(payload, { decisionsDir, session: null }), 0);
+  assert.equal(fs.existsSync(path.join(decisionsDir, 'JURITEXT000000000001.json')), false);
+});
+
+test('un texte plus court que le cache existant n’écrase pas la version en cache', () => {
+  const homeDir = makeHome();
+  const decisionsDir = path.join(homeDir, 'decisions');
+  fs.mkdirSync(decisionsDir, { recursive: true });
+  const id = 'JURITEXT000011112222';
+  fs.writeFileSync(path.join(decisionsDir, `${id}.json`), JSON.stringify({
+    kind: 'legifrance-decision', id, texte: EXTRAIT_ATTENDU.repeat(5), caracteres: EXTRAIT_ATTENDU.repeat(5).length,
+    source: 'consulter_decision', session: null, at: '2026-01-01T00:00:00.000Z',
+  }));
+
+  const payload = {
+    messages: [
+      { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'mcp__legifrance__consulter_decision', input: { text_id: id } }] },
+      { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: [{ type: 'text', text: TEXTE_COMPLET }] }] },
+    ],
+  };
+
+  const count = captureDecisions(payload, { decisionsDir, session: null });
+  assert.equal(count, 0);
+  const stillCached = JSON.parse(fs.readFileSync(path.join(decisionsDir, `${id}.json`), 'utf8'));
+  assert.equal(stillCached.texte, EXTRAIT_ATTENDU.repeat(5), 'le texte plus long déjà en cache a été dégradé');
+});
+
+test('captureDecisions ne jette jamais sur une charge utile absurde', () => {
+  const homeDir = makeHome();
+  const decisionsDir = path.join(homeDir, 'decisions');
+  assert.equal(captureDecisions(null, { decisionsDir }), 0);
+  assert.equal(captureDecisions({ messages: 'pas un tableau' }, { decisionsDir }), 0);
+  assert.equal(captureDecisions({ input: [{ type: 'function_call_output', call_id: 'x' }] }, { decisionsDir }), 0);
+  assert.equal(captureDecisions({}, {}), 0, 'sans decisionsDir, renvoie 0 plutôt que de jeter');
+});
+
+// ---------------------------------------------------------------------------
+// verification.cjs — verifierReponse
+// ---------------------------------------------------------------------------
+
+function resolversFixes({ decisionText = '', sourceText = '' } = {}) {
+  return {
+    getDecisionText: async () => decisionText,
+    getSourceText: async () => sourceText,
+  };
+}
+
+test('absence de bloc <CITATIONS> : silence total, rien n’est écrit', async () => {
+  const homeDir = makeHome();
+  const result = await verifierReponse('Voici une réponse sans aucune citation structurée.', { homeDir, resolvers: resolversFixes() });
+  assert.deepEqual(result, { analysee: false, citations: 0, nonVerifiees: 0, details: [] });
+  assert.equal(fs.existsSync(path.join(homeDir, 'citations-verifiees.jsonl')), false);
+});
+
+test('une citation trouvée exactement dans la source est vérifiée', async () => {
+  const homeDir = makeHome();
+  const source = "Le contrat prévoit une clause de non-concurrence de deux ans.";
+  const texte = `Voici l'analyse.\n<CITATIONS>[{"ref":1,"doc_id":"piece1.md","page":1,"quote":"clause de non-concurrence de deux ans"}]</CITATIONS>`;
+
+  const result = await verifierReponse(texte, { homeDir, session: 'sess-2', resolvers: resolversFixes({ sourceText: source }) });
+  assert.equal(result.analysee, true);
+  assert.equal(result.citations, 1);
+  assert.equal(result.nonVerifiees, 0);
+  assert.equal(result.details.length, 1);
+  assert.equal(result.details[0].verified, true);
+  assert.equal(result.details[0].motif, null);
+});
+
+test('une citation introuvable dans la source compte comme non vérifiée', async () => {
+  const homeDir = makeHome();
+  const source = "Le contrat ne prévoit aucune clause particulière.";
+  const texte = `<CITATIONS>[{"ref":1,"doc_id":"piece1.md","page":1,"quote":"clause de non-concurrence de deux ans"}]</CITATIONS>`;
+
+  const result = await verifierReponse(texte, { homeDir, resolvers: resolversFixes({ sourceText: source }) });
+  assert.equal(result.analysee, true);
+  assert.equal(result.nonVerifiees, 1);
+  assert.equal(result.details[0].verified, false);
+  assert.equal(result.details[0].motif, 'introuvable dans la source');
+});
+
+test('une citation dérivée (espaces/casse/ponctuation) est corrigée et n’est pas une faute', async () => {
+  const homeDir = makeHome();
+  const source = "Le contrat prévoit une clause de non-concurrence de deux ans.";
+  // Quote du modèle : casse différente + espace en trop, doit être retrouvée au niveau 2.
+  const texte = `<CITATIONS>[{"ref":1,"doc_id":"piece1.md","page":1,"quote":"Clause de  non-concurrence de deux ans"}]</CITATIONS>`;
+
+  const result = await verifierReponse(texte, { homeDir, resolvers: resolversFixes({ sourceText: source }) });
+  assert.equal(result.nonVerifiees, 0, 'une citation seulement dérivée ne doit jamais compter comme non vérifiée');
+  assert.equal(result.details[0].verified, true);
+});
+
+test('le journal ne contient jamais le texte de la citation ni de la source', async () => {
+  const homeDir = makeHome();
+  const source = "Une phrase confidentielle du dossier qui ne doit jamais fuiter.";
+  const quoteIntrouvable = "Une phrase qui n'existe pas dans la source.";
+  const texte = `<CITATIONS>[{"ref":1,"doc_id":"piece1.md","page":1,"quote":"${quoteIntrouvable}"}]</CITATIONS>`;
+
+  await verifierReponse(texte, { homeDir, session: 'sess-confidentiel', resolvers: resolversFixes({ sourceText: source }) });
+
+  const logPath = path.join(homeDir, 'citations-verifiees.jsonl');
+  assert.equal(fs.existsSync(logPath), true);
+  const raw = fs.readFileSync(logPath, 'utf8');
+  assert.ok(!raw.includes(source), 'le texte de la source a fuité dans le journal');
+  assert.ok(!raw.includes(quoteIntrouvable), 'le texte de la citation a fuité dans le journal');
+
+  const line = JSON.parse(raw.trim().split('\n')[0]);
+  assert.equal(line.session_id, 'sess-confidentiel');
+  assert.equal(line.non_verifiees, 1);
+  assert.deepEqual(Object.keys(line.details[0]).sort(), ['id', 'motif', 'verified']);
+});
+
+test('verifierReponse ne jette jamais sur un bloc malformé', async () => {
+  const homeDir = makeHome();
+  const texte = '<CITATIONS>ceci n\'est pas du JSON</CITATIONS>';
+  const result = await verifierReponse(texte, { homeDir, resolvers: resolversFixes() });
+  assert.equal(result.nonVerifiees, 0);
+});
+
+// ---------------------------------------------------------------------------
+// index.cjs — createHarnessJuridique (façade + interrupteur)
+// ---------------------------------------------------------------------------
+
+test('observerRequete n’agit que sur un corps JSON et capture la décision', () => {
+  const homeDir = makeHome();
+  const harnais = createHarnessJuridique({ homeDir });
+  const payload = {
+    messages: [
+      { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'mcp__legifrance__consulter_decision', input: { text_id: 'JURITEXT000099998888' } }] },
+      { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: [{ type: 'text', text: TEXTE_COMPLET }] }] },
+    ],
+  };
+  const body = Buffer.from(JSON.stringify(payload), 'utf8');
+
+  assert.equal(harnais.observerRequete(body, 'text/plain', { session: 'sess-3' }), 0, 'un content-type non JSON ne doit rien capturer');
+  const count = harnais.observerRequete(body, 'application/json; charset=utf-8', { session: 'sess-3' });
+  assert.equal(count, 1);
+  assert.equal(harnais.stats.decisions, 1);
+  assert.equal(fs.existsSync(path.join(homeDir, 'decisions', 'JURITEXT000099998888.json')), true);
+});
+
+test('observerReponse retourne la forme de verifierReponse et met à jour les stats', async () => {
+  const homeDir = makeHome();
+  const harnais = createHarnessJuridique({ homeDir });
+
+  const sansBloc = await harnais.observerReponse('Réponse ordinaire, sans citations.', { session: 'sess-4' });
+  assert.equal(sansBloc.analysee, false);
+  assert.equal(harnais.stats.tours, 0);
+});
+
+test('PIECEMAKER_CITATIONS=off neutralise les deux observateurs', async () => {
+  const homeDir = makeHome();
+  const previous = process.env.PIECEMAKER_CITATIONS;
+  process.env.PIECEMAKER_CITATIONS = 'off';
+  try {
+    const harnais = createHarnessJuridique({ homeDir });
+    const payload = {
+      messages: [
+        { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'mcp__legifrance__consulter_decision', input: { text_id: 'JURITEXT000011119999' } }] },
+        { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: [{ type: 'text', text: TEXTE_COMPLET }] }] },
+      ],
+    };
+    const body = Buffer.from(JSON.stringify(payload), 'utf8');
+
+    assert.equal(harnais.observerRequete(body, 'application/json', { session: null }), 0);
+    assert.equal(fs.existsSync(path.join(homeDir, 'decisions')), false, 'la capture a eu lieu malgré l’interrupteur');
+
+    const texte = `<CITATIONS>[{"ref":1,"doc_id":"piece1.md","page":1,"quote":"peu importe"}]</CITATIONS>`;
+    const result = await harnais.observerReponse(texte, { session: null });
+    assert.deepEqual(result, { analysee: false, citations: 0, nonVerifiees: 0, details: [] });
+    assert.equal(fs.existsSync(path.join(homeDir, 'citations-verifiees.jsonl')), false, 'la vérification a eu lieu malgré l’interrupteur');
+  } finally {
+    if (previous === undefined) delete process.env.PIECEMAKER_CITATIONS;
+    else process.env.PIECEMAKER_CITATIONS = previous;
+  }
+});

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/proxy-harness.test.js

@@ -0,0 +1,226 @@
+/**
+ * Câblage du harnais de citations vérifiées sur le proxy PII — bout en bout,
+ * contre un faux amont, comme `../anonymizer/anonymizer.test.js`.
+ *
+ * Ce que ces tests vérifient, au-delà de ce que couvre déjà `harness.test.js`
+ * (la logique du harnais isolée) : que le proxy observe le bon texte au bon
+ * moment (corps brut du client à l'aller, texte livré au client au retour,
+ * y compris sur le chemin `current.empty`), et que rien de tout cela ne peut
+ * jamais dégrader ni retarder ce qui est réellement délivré au client — même
+ * quand le harnais fourni est défaillant.
+ *
+ * Le mapping utilisé est fictif et créé dans un dossier temporaire ; il n'a
+ * aucun rapport avec le mapping central de la machine, pas plus que le
+ * `homeDir` du harnais (décisions, journal de vérification).
+ */
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import http from 'node:http';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+const require = createRequire(import.meta.url);
+const { createDictionaryLoader } = require('../anonymizer/dictionary.cjs');
+const { createAnonymizerProxy } = require('../anonymizer/proxy.cjs');
+const { createHarnessJuridique } = require('./index.cjs');
+
+const CODE = 'PERSONNE_PHYSIQUE_01';
+const NAME = 'Jean Dupont';
+
+const DECISION_ID = 'JURITEXT000099990001';
+const TEXTE_COMPLET = [
+  'Cour de cassation, arrêt du 12 janvier 2024',
+  '',
+  '=================================',
+  'TEXTE INTÉGRAL:',
+  '=================================',
+  '',
+  "Attendu que le salarié a été licencié sans cause réelle et sérieuse ;",
+  '',
+  `Lien: https://www.legifrance.gouv.fr/juri/id/${DECISION_ID}`,
+].join('\n');
+
+/** Requête Anthropic Messages portant un aller-retour `consulter_decision`. */
+function decisionRequestBody({ stream = true } = {}) {
+  return JSON.stringify({
+    stream,
+    messages: [
+      {
+        role: 'assistant',
+        content: [{ type: 'tool_use', id: 't1', name: 'mcp__legifrance__consulter_decision', input: { text_id: DECISION_ID } }],
+      },
+      {
+        role: 'user',
+        content: [{ type: 'tool_result', tool_use_id: 't1', content: [{ type: 'text', text: TEXTE_COMPLET }] }],
+      },
+    ],
+  });
+}
+
+function makeHome() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pm-proxyharness-'));
+  fs.writeFileSync(path.join(dir, 'central-mapping.json'), JSON.stringify({
+    version: 1,
+    updated_at: '2026-01-01T00:00:00.000Z',
+    mapping: { [NAME]: CODE },
+    reverse_mapping: { [CODE]: [NAME] },
+  }));
+  return dir;
+}
+
+function makeEmptyHome() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pm-proxyharness-vide-'));
+}
+
+/** Faux amont : renvoie ce qu'il a reçu, plus une réponse du type demandé. */
+function startUpstream(respond) {
+  const seen = [];
+  const server = http.createServer((req, res) => {
+    const chunks = [];
+    req.on('data', (chunk) => chunks.push(chunk));
+    req.on('end', () => {
+      seen.push({ url: req.url, body: Buffer.concat(chunks).toString('utf8') });
+      respond(res);
+    });
+  });
+  return new Promise((resolve) => {
+    server.listen(0, '127.0.0.1', () => resolve({ seen, server, port: server.address().port }));
+  });
+}
+
+async function withProxy(homeDir, respond, run, { harness = null } = {}) {
+  const upstream = await startUpstream(respond);
+  const proxy = createAnonymizerProxy({
+    dictionary: createDictionaryLoader({ homeDir }),
+    port: 0,
+    routes: [{ provider: 'claude', prefix: '/anthropic', upstream: `http://127.0.0.1:${upstream.port}` }],
+    harness,
+  });
+  const { origin } = await proxy.listen();
+  try {
+    return await run({ origin, seen: upstream.seen });
+  } finally {
+    await proxy.close();
+    await new Promise((resolve) => upstream.server.close(resolve));
+  }
+}
+
+function post(origin, body, route = '/anthropic/v1/messages') {
+  return new Promise((resolve, reject) => {
+    const request = http.request(`${origin}${route}`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+    }, (response) => {
+      let text = '';
+      response.setEncoding('utf8');
+      response.on('data', (chunk) => { text += chunk; });
+      response.on('end', () => resolve(text));
+    });
+    request.on('error', reject);
+    request.end(body);
+  });
+}
+
+/** Écrit un événement `content_block_delta` Anthropic portant du texte visible. */
+function sseDelta(text) {
+  return `event: content_block_delta\ndata: ${JSON.stringify({
+    type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text },
+  })}\n\n`;
+}
+
+/** Réponse SSE Anthropic minimale portant les fragments de texte donnés. */
+function respondSse(res, fragments) {
+  res.writeHead(200, { 'content-type': 'text/event-stream' });
+  for (const text of fragments) res.write(sseDelta(text));
+  res.write('event: content_block_stop\ndata: {"type":"content_block_stop","index":0}\n\n');
+  res.end();
+}
+
+/** Attend qu'un prédicat devienne vrai — pour l'écriture asynchrone, fire-and-forget, du harnais. */
+async function waitFor(predicate, { timeout = 2000, interval = 20 } = {}) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    if (predicate()) return true;
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+  return predicate();
+}
+
+const CITATIONS_LOG = (homeDir) => path.join(homeDir, 'citations-verifiees.jsonl');
+const DECISION_FILE = (homeDir) => path.join(homeDir, 'decisions', `${DECISION_ID}.json`);
+
+test('une décision consulter_decision dans une requête Anthropic streamée est capturée', async () => {
+  const homeDir = makeHome();
+  const harness = createHarnessJuridique({ homeDir });
+
+  await withProxy(homeDir, (res) => respondSse(res, ['Bonjour.']), ({ origin }) => post(origin, decisionRequestBody()), { harness });
+
+  assert.equal(fs.existsSync(DECISION_FILE(homeDir)), true, 'la décision consultée n’a pas été mise en cache');
+  const cached = JSON.parse(fs.readFileSync(DECISION_FILE(homeDir), 'utf8'));
+  assert.equal(cached.id, DECISION_ID);
+});
+
+test('une réponse SSE portant un bloc <CITATIONS> est journalisée', async () => {
+  const homeDir = makeHome();
+  const harness = createHarnessJuridique({ homeDir });
+  const fragments = ['Analyse.\n', '<CITATIONS>[{"ref":1,"doc_id":"piece1.md","page":1,"quote":"une phrase"}]</CITATIONS>'];
+
+  await withProxy(homeDir, (res) => respondSse(res, fragments), ({ origin }) => post(origin, JSON.stringify({ stream: true, messages: [] })), { harness });
+
+  const written = await waitFor(() => fs.existsSync(CITATIONS_LOG(homeDir)));
+  assert.equal(written, true, 'le journal de vérification n’a jamais été écrit');
+  const line = JSON.parse(fs.readFileSync(CITATIONS_LOG(homeDir), 'utf8').trim().split('\n')[0]);
+  assert.equal(line.citations, 1);
+});
+
+test('même cas avec un mapping vide (chemin current.empty) : la journalisation fonctionne aussi', async () => {
+  const homeDir = makeEmptyHome();
+  const harness = createHarnessJuridique({ homeDir });
+  const fragments = ['Analyse.\n', '<CITATIONS>[{"ref":1,"doc_id":"piece1.md","page":1,"quote":"une phrase"}]</CITATIONS>'];
+
+  await withProxy(homeDir, (res) => respondSse(res, fragments), ({ origin }) => post(origin, JSON.stringify({ stream: true, messages: [] })), { harness });
+
+  const written = await waitFor(() => fs.existsSync(CITATIONS_LOG(homeDir)));
+  assert.equal(written, true, 'le chemin current.empty n’observe pas la réponse');
+});
+
+test('une réponse SSE sans bloc <CITATIONS> n’écrit rien', async () => {
+  const homeDir = makeHome();
+  const harness = createHarnessJuridique({ homeDir });
+
+  await withProxy(homeDir, (res) => respondSse(res, ['Réponse ordinaire, sans citations structurées.']), ({ origin }) => post(origin, JSON.stringify({ stream: true, messages: [] })), { harness });
+
+  // Le harnais est fire-and-forget : une courte attente laisse le temps à une
+  // écriture éventuelle de se produire avant de constater son absence.
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  assert.equal(fs.existsSync(CITATIONS_LOG(homeDir)), false, 'un journal a été écrit alors qu’aucune citation n’était présente');
+});
+
+test('la présence du harnais ne modifie jamais ce qui est livré au client', async () => {
+  const fragments = ['Le client ', 'PERSONNE_', 'PHYSIQUE', '_01', ' a signé.\n', '<CITATIONS>[{"ref":1,"doc_id":"piece1.md","page":1,"quote":"peu importe"}]</CITATIONS>'];
+  const homeSansHarnais = makeHome();
+  const homeAvecHarnais = makeHome();
+
+  const sansHarnais = await withProxy(homeSansHarnais, (res) => respondSse(res, fragments), ({ origin }) => post(origin, JSON.stringify({ stream: true, messages: [] })));
+  const avecHarnais = await withProxy(homeAvecHarnais, (res) => respondSse(res, fragments), ({ origin }) => post(origin, JSON.stringify({ stream: true, messages: [] })), { harness: createHarnessJuridique({ homeDir: homeAvecHarnais }) });
+
+  assert.equal(avecHarnais, sansHarnais, 'la sortie livrée au client diffère selon la présence du harnais');
+});
+
+test('une erreur du harnais ne casse ni la requête ni la réponse', async () => {
+  const homeDir = makeHome();
+  const fakeHarness = {
+    observerRequete() { throw new Error('harnais défaillant (requête)'); },
+    observerReponse() { throw new Error('harnais défaillant (réponse)'); },
+  };
+  const json = { content: [{ type: 'text', text: `Réponse sur ${CODE}.` }] };
+
+  const answer = await withProxy(homeDir, (res) => {
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify(json));
+  }, ({ origin }) => post(origin, JSON.stringify({ messages: [{ role: 'user', content: `Analyse le dossier de ${NAME}.` }] })), { harness: fakeHarness });
+
+  assert.ok(answer.includes(NAME), 'la réponse n’a pas été dé-anonymisée malgré l’erreur du harnais');
+});

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;
+}