@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/anonymizer/service.cjs

@@ -0,0 +1,218 @@
+/**
+ * Cycle de vie du proxy PII et point d'injection dans CloudCLI.
+ *
+ * Deux leviers, aucun ne touchant un fichier upstream.
+ *
+ * **L'environnement du serveur.** Les quatre chemins de lancement de CloudCLI —
+ * chat Claude, Codex, Cursor, opencode — étalent `process.env` dans le
+ * sous-processus qu'ils créent, tout comme le terminal intégré. Poser des
+ * variables ici les atteint donc tous les cinq sans ajouter une ligne ailleurs.
+ *
+ * **Les configurations utilisateur des clients.** Codex ne lit pas de variable
+ * de base d'URL, opencode préfère sa configuration ; `providers.cjs` s'en
+ * charge, et pose le garde-fou de Cursor, seul client non interceptable.
+ *
+ * Le proxy vit et meurt avec le serveur : à l'arrêt, les bases écrites sont
+ * retirées pour ne pas laisser les clients pointer un port fermé.
+ */
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { createDictionaryLoader } = require('./dictionary.cjs');
+const { DEFAULT_UPSTREAM, createAnonymizerProxy } = require('./proxy.cjs');
+const { bypassProviders, configureProviders } = require('./providers.cjs');
+const { createHarnessJuridique } = require('../harness/index.cjs');
+
+const ENV_VAR = 'ANTHROPIC_BASE_URL';
+const OPENAI_ENV_VAR = 'OPENAI_BASE_URL';
+
+/** Interrupteur : `PIECEMAKER_ANONYMIZER=off`, ou `anonymizer.enabled: false` dans `config.json`. */
+function isDisabled(homeDir) {
+  const flag = String(process.env.PIECEMAKER_ANONYMIZER || '').toLowerCase();
+  if (flag === 'off' || flag === '0' || flag === 'false') return true;
+  try {
+    const config = JSON.parse(fs.readFileSync(path.join(homeDir, 'config.json'), 'utf8'));
+    return config?.anonymizer?.enabled === false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Cible du relais Anthropic. Une base distante déjà configurée (passerelle
+ * d'entreprise, point de terminaison alternatif) est respectée : on se chaîne
+ * derrière elle. Une base en boucle locale ne peut être qu'une instance
+ * précédente de ce proxy, et serait un relais mort : on l'ignore au profit de
+ * l'API officielle.
+ */
+function resolveUpstream(configured) {
+  if (!configured) return DEFAULT_UPSTREAM;
+  try {
+    const { hostname } = new URL(configured);
+    if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1') return DEFAULT_UPSTREAM;
+    return configured;
+  } catch {
+    return DEFAULT_UPSTREAM;
+  }
+}
+
+/**
+ * Lecture du rapport de `configureProviders` en une couverture par client, la
+ * seule chose que l'interface a besoin de montrer.
+ *
+ * `filtered` : les échanges passent par le proxy et sont anonymisés.
+ * `blocked`  : le client ne peut pas être filtré et est donc empêché de partir.
+ * `unconfigured` : le câblage a échoué ou est en conflit — le client peut
+ * encore parler en direct, et c'est précisément ce que le statut doit crier.
+ */
+function summarizeCoverage(report) {
+  const coverage = {};
+  for (const [name, result] of Object.entries(report || {})) {
+    if (result?.blocked) coverage[name] = { state: 'blocked', detail: result.reason, file: result.file || null };
+    else if (result?.configured) coverage[name] = { state: 'filtered', detail: null, file: result.file || null };
+    else coverage[name] = { state: 'unconfigured', detail: result?.reason || 'unknown', file: result?.file || null };
+  }
+  return coverage;
+}
+
+function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = console, required = false }) {
+  const dictionary = createDictionaryLoader({ homeDir });
+  // Harnais de citations vérifiées (décisions Légifrance + bloc <CITATIONS>) :
+  // son propre interrupteur (`PIECEMAKER_CITATIONS=off`) est géré à
+  // l'intérieur, pas ici.
+  const harness = createHarnessJuridique({ homeDir, verifyResponses: false });
+  // Le shim Cursor vit sous le répertoire de données PieceMaker : il n'a rien à
+  // faire dans un répertoire appartenant à un fournisseur.
+  const binDir = path.join(homeDir, 'bin');
+  const state = {
+    enabled: false,
+    reason: 'not_started',
+    origin: null,
+    upstream: null,
+    startedAt: null,
+    routes: [],
+    coverage: {},
+  };
+  let proxy = null;
+  let previousEnv = null;
+
+  async function start() {
+    if (proxy) return state;
+    if (!required && isDisabled(homeDir)) {
+      state.reason = 'disabled';
+      return state;
+    }
+
+    const claudeUpstream = resolveUpstream(process.env[ENV_VAR]);
+    proxy = createAnonymizerProxy({
+      dictionary,
+      routes: [
+        { provider: 'claude', prefix: '/anthropic', upstream: claudeUpstream },
+        { provider: 'codex', prefix: '/chatgpt', upstream: 'https://chatgpt.com/backend-api/codex' },
+        { provider: 'opencode', prefix: '/openai', upstream: 'https://api.openai.com' },
+      ],
+      harness,
+      onError: (error) => logger.warn?.(`[piecemaker] proxy PII : ${error.message}`),
+    });
+
+    let origin;
+    let listenedPort;
+    try {
+      ({ origin, port: listenedPort } = await proxy.listen());
+    } catch (error) {
+      proxy = null;
+      state.reason = `listen_failed: ${error.message}`;
+      logger.warn?.(`[piecemaker] proxy PII non démarré : ${error.message}`);
+      return state;
+    }
+
+    // Publie le port réellement obtenu (le scan de proxy.cjs peut dévier du
+    // port préféré si une instance précédente n'a pas encore libéré le sien)
+    // dans la config partagée, pour que d'autres consommateurs indépendants
+    // du process serveur (ex. le sous-service Docker "mike") puissent le
+    // retrouver sans le redéduire eux-mêmes ni le coder en dur.
+    try {
+      const configFile = path.join(homeDir, 'config.json');
+      const current = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+      if (current.mikePiiPort !== listenedPort) {
+        fs.writeFileSync(configFile, `${JSON.stringify({ ...current, mikePiiPort: listenedPort }, null, 2)}\n`, 'utf8');
+      }
+    } catch (error) {
+      logger.warn?.(`[piecemaker] impossible de publier mikePiiPort dans config.json : ${error.message}`);
+    }
+
+    previousEnv = {
+      [ENV_VAR]: process.env[ENV_VAR],
+      [OPENAI_ENV_VAR]: process.env[OPENAI_ENV_VAR],
+      PATH: process.env.PATH,
+    };
+    process.env[ENV_VAR] = `${origin}/anthropic`;
+    process.env[OPENAI_ENV_VAR] = `${origin}/openai`;
+    // En tête de chemin : le shim doit être trouvé avant le vrai `cursor-agent`.
+    process.env.PATH = `${binDir}${path.delimiter}${process.env.PATH || ''}`;
+
+    const report = await configureProviders({ origin, userHome, binDir, mappingFile: dictionary.file });
+    Object.assign(state, {
+      enabled: true,
+      reason: 'running',
+      origin,
+      upstream: claudeUpstream,
+      startedAt: new Date().toISOString(),
+      routes: proxy.routes,
+      coverage: summarizeCoverage(report),
+    });
+
+    const uncovered = Object.entries(state.coverage)
+      .filter(([, value]) => value.state === 'unconfigured')
+      .map(([name]) => name);
+    logger.log?.(`[piecemaker] anonymisation active sur ${origin} (claude, codex, opencode ; cursor bloqué)`);
+    if (uncovered.length) {
+      logger.warn?.(`[piecemaker] clients non filtrés, à vérifier : ${uncovered.join(', ')}`);
+    }
+    return state;
+  }
+
+  async function stop() {
+    if (!proxy) return;
+    await proxy.close();
+    await bypassProviders({ userHome, binDir });
+    if (previousEnv) {
+      for (const [key, value] of Object.entries(previousEnv)) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+      }
+      previousEnv = null;
+    }
+    proxy = null;
+    Object.assign(state, { enabled: false, reason: 'stopped', origin: null, routes: [], coverage: {} });
+  }
+
+  function status() {
+    const current = dictionary.get();
+    return {
+      ...state,
+      listening: Boolean(proxy?.listening),
+      dictionary: {
+        file: dictionary.file,
+        exists: dictionary.exists(),
+        entityCount: current.entityCount,
+        codeCount: current.codeCount,
+        updatedAt: current.updatedAt,
+        empty: current.empty,
+      },
+      stats: proxy ? { ...proxy.stats } : null,
+    };
+  }
+
+  return { dictionary, start, status, stop };
+}
+
+module.exports = {
+  ENV_VAR,
+  OPENAI_ENV_VAR,
+  createAnonymizerService,
+  isDisabled,
+  resolveUpstream,
+  summarizeCoverage,
+};

package/server/piecemaker/harness/chat-harness.test.ts

@@ -0,0 +1,131 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import type { NormalizedMessage } from '@/shared/types.js';
+import { createNormalizedMessage } from '@/shared/utils.js';
+
+import { createCitationStore } from './citation-store.js';
+import { installChatCitationHarness } from './chat-harness.js';
+import { withCitationInstructions, withoutCitationInstructions } from './citation-instructions.js';
+
+type Dependencies = Parameters<typeof installChatCitationHarness>[0];
+
+async function setup(t: test.TestContext, messages: NormalizedMessage[]) {
+  const cwd = await mkdtemp(path.join(os.tmpdir(), 'pm-chat-harness-'));
+  t.after(() => rm(cwd, { recursive: true, force: true }));
+  await writeFile(path.join(cwd, 'piece.md'), 'La clause impose un préavis de trois mois.');
+  const store = createCitationStore(cwd);
+  const sent: NormalizedMessage[] = [];
+  const runtime: Dependencies['runtime'] = {
+    run: async (_provider, command, _options, writer) => {
+      assert.match(command, /PIECEMAKER_CITATION_INSTRUCTIONS/);
+      writer.setSessionId?.('native-session');
+      for (const message of messages) writer.send(message);
+    },
+    getRunner: () => async () => {},
+  };
+  const sessions: Dependencies['sessions'] = {
+    fetchHistory: async () => ({ messages, total: messages.length, hasMore: false, offset: 0, limit: null }),
+    getSessionDetailsById: () => ({
+      sessionId: 'session', provider: 'claude', summary: '', createdAt: null, updatedAt: null, lastActivity: null, isArchived: false,
+      project: { projectId: 'project', path: cwd, fullPath: cwd, displayName: 'Dossier', isArchived: false, isStarred: false },
+    }),
+  };
+  installChatCitationHarness({ runtime, sessions, store, ensureProxy: () => {} });
+  return { cwd, runtime, sessions, sent, store };
+}
+
+const content = 'Réponse [1].\n<CITATIONS>[{"ref":1,"doc_id":"piece.md","quote":"un préavis de trois mois"}]</CITATIONS>';
+const message = (fields: Parameters<typeof createNormalizedMessage>[0]) => createNormalizedMessage({ sessionId: 'session', ...fields });
+
+test('Claude : annotations avant complete, pas de bloc JSON visible ni de doublon de texte', async (t) => {
+  const messages = [
+    message({ kind: 'stream_delta', provider: 'claude', content: content.slice(0, 19) }),
+    message({ kind: 'stream_delta', provider: 'claude', content: content.slice(19) }),
+    message({ kind: 'stream_end', provider: 'claude' }),
+    message({ kind: 'text', role: 'assistant', provider: 'claude', id: 'reply', content }),
+    message({ kind: 'permission_request', provider: 'claude', requestId: 'permission' }),
+    message({ kind: 'complete', provider: 'claude', exitCode: 0 }),
+  ];
+  const { runtime, sent, cwd } = await setup(t, messages);
+  let native = '';
+  await runtime.run('claude', 'Question', { cwd, sessionId: 'session' }, { send: (data) => sent.push(data as NormalizedMessage), setSessionId: (id) => { native = id; } });
+  assert.equal(native, 'native-session');
+  assert.equal(sent.at(-1)?.kind, 'complete');
+  const finalIndex = sent.findIndex((event) => (event.citationEvent as { status?: string })?.status === 'final');
+  assert.ok(finalIndex >= 0 && finalIndex < sent.length - 1);
+  assert.ok(sent.find((event) => event.kind === 'permission_request'));
+  const assistant = sent.filter((event) => event.kind === 'text' && event.role === 'assistant');
+  assert.equal(assistant.length, 1);
+  assert.doesNotMatch(assistant[0].content ?? '', /<CITATIONS>|doc_id/);
+  assert.match(assistant[0].content ?? '', /#piecemaker-citation=/);
+  assert.equal(sent.filter((event) => event.kind === 'stream_delta').map((event) => event.content).join(''), assistant[0].content);
+  const log = await readFile(path.join(cwd, 'citations-verifiees.jsonl'), 'utf8');
+  assert.doesNotMatch(log, /préavis|La clause/);
+  assert.equal(JSON.parse(log).session_id, 'session');
+});
+
+test('Codex : même vérification via getRunner, sources accessibles et historique paginé cohérent', async (t) => {
+  const messages = [
+    message({ kind: 'text', role: 'user', provider: 'codex', id: 'user', content: withCitationInstructions('Question') }),
+    message({ kind: 'text', role: 'assistant', provider: 'codex', id: 'reply', content }),
+    message({ kind: 'complete', provider: 'codex', exitCode: 0 }),
+  ];
+  const { runtime, sessions, store, sent, cwd } = await setup(t, messages);
+  await runtime.getRunner('codex')('Question', { cwd, sessionId: 'session' }, { send: (data) => sent.push(data as NormalizedMessage) });
+  const reply = sent.filter((event) => event.id === 'reply').at(-1);
+  assert.equal(sent.find((event) => event.id === 'user')?.content, 'Question');
+  const token = /#piecemaker-citation=([a-f0-9]{64})/.exec(reply?.content ?? '')?.[1];
+  assert.ok(token);
+  assert.equal((await store.read(token))?.citation.verified, true);
+  const history = await sessions.fetchHistory('session', { limit: 2 });
+  assert.equal(history.messages.length, 2);
+  assert.equal(history.hasMore, true);
+  assert.equal(history.messages[0].content, reply?.content);
+  const userPage = await sessions.fetchHistory('session', { limit: 1, offset: 2 });
+  assert.equal(userPage.messages[0].content, 'Question');
+});
+
+test('historique : la lecture d’une décision dans le premier tour ne valide pas le suivant', async (t) => {
+  const citation = '<CITATIONS>[{"ref":1,"decision_id":"JURITEXT1","quote":"Passage lu."}]</CITATIONS>';
+  const messages = [
+    message({ kind: 'text', role: 'user', provider: 'claude', content: 'Premier tour' }),
+    message({ kind: 'tool_use', provider: 'claude', toolId: 'call', toolName: 'mcp__legifrance__consulter_decision', toolInput: { text_id: 'JURITEXT1' } }),
+    message({ kind: 'tool_result', provider: 'claude', toolId: 'call', content: 'Passage lu.' }),
+    message({ kind: 'text', role: 'assistant', provider: 'claude', content: citation }),
+    message({ kind: 'text', role: 'user', provider: 'claude', content: 'Deuxième tour' }),
+    message({ kind: 'text', role: 'assistant', provider: 'claude', content: citation }),
+  ];
+  const { sessions } = await setup(t, messages);
+  const history = await sessions.fetchHistory('session');
+  assert.doesNotMatch(history.messages[3].content ?? '', /non retrouvé/);
+  assert.match(history.messages[5].content ?? '', /non retrouvé/);
+});
+
+test('un tour interrompu ne publie pas des annotations finales', async (t) => {
+  const messages = [
+    message({ kind: 'stream_delta', provider: 'claude', content }),
+    message({ kind: 'stream_end', provider: 'claude' }),
+    message({ kind: 'text', role: 'assistant', provider: 'claude', content }),
+    message({ kind: 'complete', provider: 'claude', aborted: true }),
+  ];
+  const { runtime, sent, cwd } = await setup(t, messages);
+  await runtime.run('claude', 'Question', { cwd, sessionId: 'session' }, { send: (data) => sent.push(data as NormalizedMessage) });
+  assert.equal(sent.at(-1)?.aborted, true);
+  assert.equal(sent.some((event) => (event.citationEvent as { status?: string })?.status === 'final'), false);
+});
+
+test('les instructions ajoutées au lancement sont retirées sans modifier le texte utilisateur', () => {
+  const original = 'Question <PIECEMAKER_CITATION_INSTRUCTIONS> à conserver';
+  assert.equal(withoutCitationInstructions(withCitationInstructions(original)), original);
+  assert.equal(withoutCitationInstructions(original), original);
+});
+
+test('un runtime arrêté sans événement complete ne publie pas des annotations finales', async (t) => {
+  const { runtime, sent, cwd } = await setup(t, [message({ kind: 'text', role: 'assistant', provider: 'codex', content })]);
+  await runtime.run('codex', 'Question', { cwd, sessionId: 'session' }, { send: (data) => sent.push(data as NormalizedMessage) });
+  assert.equal(sent.some((event) => (event.citationEvent as { status?: string })?.status === 'final'), false);
+});

package/server/piecemaker/harness/chat-harness.ts

@@ -0,0 +1,151 @@
+import type { providerRuntimeService, sessionsService } from '@/modules/providers/index.js';
+import type { NormalizedMessage, ProviderRuntimeWriter } from '@/shared/types.js';
+import { createNormalizedMessage } from '@/shared/utils.js';
+
+import { createCitationTurn } from './citation-turn.js';
+import type { createCitationStore } from './citation-store.js';
+import { withCitationInstructions, withoutCitationInstructions } from './citation-instructions.js';
+
+export function installChatCitationHarness(options: {
+  runtime: Pick<typeof providerRuntimeService, 'run' | 'getRunner'>;
+  sessions: Pick<typeof sessionsService, 'fetchHistory' | 'getSessionDetailsById'>;
+  store: ReturnType<typeof createCitationStore>;
+  ensureProxy: () => void;
+}) {
+  const run = options.runtime.run.bind(options.runtime);
+  const getRunner = options.runtime.getRunner.bind(options.runtime);
+  const fetchHistory = options.sessions.fetchHistory.bind(options.sessions);
+
+  options.runtime.run = async (provider, command, runtimeOptions, writer) => {
+    options.ensureProxy();
+    if (provider !== 'claude' && provider !== 'codex') return run(provider, command, runtimeOptions, writer);
+    const sessionId = String(runtimeOptions.sessionId ?? '');
+    const cwd = String(runtimeOptions.cwd ?? runtimeOptions.projectPath ?? '');
+    const turn = createCitationTurn({
+      cwd, sessionId, store: options.store,
+      emit: (citationEvent) => writer.send(createNormalizedMessage({
+        kind: 'status', provider, sessionId, citationEvent,
+      })),
+    });
+    let lastText: NormalizedMessage | undefined;
+    let lastDelta: NormalizedMessage | undefined;
+    let heldStreamEnd: NormalizedMessage | undefined;
+    let interrupted = false;
+    let completionReceived = false;
+    let completion: Promise<void> | undefined;
+    const flush = () => {
+      const content = turn.flush();
+      if (content && lastDelta) writer.send({ ...lastDelta, content });
+    };
+    const finish = () => {
+      if (!completion) completion = (async () => {
+        flush();
+        const suffix = interrupted ? '' : await turn.finish();
+        if (heldStreamEnd) {
+          if (suffix && lastDelta) writer.send({ ...lastDelta, content: suffix });
+          writer.send(heldStreamEnd);
+        }
+        if (lastText && (suffix || heldStreamEnd)) writer.send({ ...lastText, content: `${lastText.content ?? ''}${suffix}` });
+      })();
+      return completion;
+    };
+    const wrapped = new Proxy(writer, {
+      get(target, key) {
+        if (key !== 'send') {
+          const value = Reflect.get(target, key, target);
+          return typeof value === 'function' ? value.bind(target) : value;
+        }
+        return (data: unknown) => {
+          const message = data as NormalizedMessage;
+          if (!message || typeof message.kind !== 'string') return target.send(data);
+          if (message.parentToolUseId) return target.send(data);
+          if (message.kind === 'text' && message.role === 'user') {
+            target.send({ ...message, content: withoutCitationInstructions(message.content ?? '') });
+            return;
+          }
+          turn.observe(message);
+          if (message.kind === 'stream_delta') {
+            lastDelta = message;
+            const content = turn.delta(message.content ?? '');
+            if (content) target.send({ ...message, content });
+            return;
+          }
+          if (message.kind === 'stream_end') {
+            flush();
+            if (turn.hasCitations) { heldStreamEnd = message; return; }
+          }
+          if (message.kind === 'text' && message.role === 'assistant') {
+            flush();
+            lastText = { ...message, content: turn.text(message.content ?? '') };
+            if (!heldStreamEnd) target.send(lastText);
+            return;
+          }
+          if (message.kind === 'complete') {
+            completionReceived = true;
+            interrupted = message.aborted === true || (typeof message.exitCode === 'number' && message.exitCode !== 0);
+            completion = finish().then(() => target.send(message));
+            return;
+          }
+          target.send(message);
+        };
+      },
+    }) as ProviderRuntimeWriter;
+    try {
+      return await run(provider, command.startsWith('/') ? command : withCitationInstructions(command), runtimeOptions, wrapped);
+    } catch (error) {
+      interrupted = true;
+      throw error;
+    } finally {
+      if (!completionReceived) interrupted = true;
+      await finish();
+    }
+  };
+  options.runtime.getRunner = (provider) => (command, runtimeOptions, writer) =>
+    options.runtime.run(provider, command, runtimeOptions, writer);
+
+  options.sessions.fetchHistory = async (sessionId, pageOptions = {}) => {
+    const details = options.sessions.getSessionDetailsById(sessionId);
+    if (details.provider !== 'claude' && details.provider !== 'codex') return fetchHistory(sessionId, pageOptions);
+    const history = await fetchHistory(sessionId, { limit: null, offset: 0 });
+    const messages: NormalizedMessage[] = [];
+    let lastTextIndex = -1;
+    const makeTurn = () => createCitationTurn({
+      cwd: details.project?.fullPath ?? '', sessionId, store: options.store, emit: () => {},
+      recordVerification: false,
+    });
+    let turn = makeTurn();
+    const finish = async () => {
+      const suffix = await turn.finish();
+      if (suffix && lastTextIndex >= 0) {
+        const message = messages[lastTextIndex];
+        messages[lastTextIndex] = { ...message, content: `${message.content ?? ''}${suffix}` };
+      }
+    };
+    for (const message of history.messages) {
+      if (message.kind === 'text' && message.role === 'user') {
+        await finish();
+        turn = makeTurn();
+        lastTextIndex = -1;
+      }
+      turn.observe(message);
+      if (message.kind === 'text' && message.role === 'assistant' && !message.parentToolUseId) {
+        lastTextIndex = messages.length;
+        messages.push({ ...message, content: turn.text(message.content ?? '') });
+      } else if (message.kind === 'text' && message.role === 'user') {
+        messages.push({ ...message, content: withoutCitationInstructions(message.content ?? '') });
+      } else messages.push(message);
+    }
+    await finish();
+    const offset = Math.max(0, pageOptions.offset ?? 0);
+    const limit = pageOptions.limit ?? null;
+    const end = Math.max(0, messages.length - offset);
+    const start = limit === null ? 0 : Math.max(0, end - Math.max(0, limit));
+    return { ...history, messages: messages.slice(start, end), offset, limit, hasMore: start > 0 };
+  };
+
+  return () => {
+    options.runtime.run = run;
+    options.runtime.getRunner = getRunner;
+    options.sessions.fetchHistory = fetchHistory;
+  };
+}

package/server/piecemaker/harness/citation-instructions.ts

@@ -0,0 +1,18 @@
+const OPEN = '<PIECEMAKER_CITATION_INSTRUCTIONS>';
+const CLOSE = '</PIECEMAKER_CITATION_INSTRUCTIONS>';
+const INSTRUCTIONS = `${OPEN}
+Pour les citations de pièces et de jurisprudence : ne citer que des sources lues dans ce tour. Chercher, trier, puis lire les sources retenues avant de citer. Lire les décisions Légifrance avec consulter_decision : un titre, un sommaire ou Download_Query_Results ne vaut pas lecture du texte intégral.
+Copier les extraits littéralement. Au plus 3 extraits par citation, chacun de 25 mots maximum. Utiliser les marqueurs [1], [2], etc., contigus et dans l'ordre de première apparition. Une entrée par référence ; réutiliser la référence pour la même citation.
+Terminer toute réponse comportant ces citations par un bloc <CITATIONS> contenant un tableau JSON strict, puis </CITATIONS>. Sans citation, ne pas ajouter de bloc.
+Décision : {"ref":1,"kind":"case","decision_id":"identifiant Legifrance lu","quotes":[{"quote":"extrait exact"}]}.
+Pièce : {"ref":2,"kind":"document","doc_id":"chemin relatif au dossier du Markdown converti","quotes":[{"page":1,"quote":"extrait exact"}]}.
+Une plage de pages prend la forme "1-2" ; [[PAGE_BREAK]] sépare les segments des deux pages. Les champs sheet et cell peuvent localiser une citation de tableur. Ne pas inventer une source indisponible ; expliquer qu'elle n'a pas pu être lue.
+${CLOSE}`;
+
+export function withCitationInstructions(command: string) {
+  return `${command}\n\n${INSTRUCTIONS}`;
+}
+
+export function withoutCitationInstructions(command: string) {
+  return command.endsWith(`\n\n${INSTRUCTIONS}`) ? command.slice(0, -INSTRUCTIONS.length - 2) : command;
+}

package/server/piecemaker/harness/citation-store.ts

@@ -0,0 +1,80 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { access, appendFile, lstat, mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { locateSourcePassages } from './source-passages.js';
+
+type CitationSnapshot = {
+  sessionId: string;
+  title: string;
+  source: string;
+  sourceOrigin?: 'decision-cache';
+  citation: {
+    ref: number;
+    decision_id?: string;
+    verified?: boolean;
+    quotes: Array<{
+      quote: string;
+      page?: number | string;
+      sheet?: string;
+      cell?: string;
+      verification?: { verified: boolean; start_char?: number; end_char?: number; source_excerpt?: string };
+    }>;
+  };
+  ranges: Array<{ start: number; end: number; quoteIndex: number }>;
+};
+
+export function createCitationStore(homeDir: string) {
+  const directory = path.join(homeDir, 'citation-sources');
+  return {
+    async recordVerification(sessionId: string, citations: Array<{ ref: number; kind: string; doc_id?: string; decision_id?: string; verified?: boolean }>) {
+      try {
+        await mkdir(homeDir, { recursive: true, mode: 0o700 });
+        await appendFile(path.join(homeDir, 'citations-verifiees.jsonl'), `${JSON.stringify({
+          session_id: sessionId, at: new Date().toISOString(), citations: citations.length,
+          non_verifiees: citations.filter((citation) => citation.verified === false).length,
+          details: citations.map((citation) => ({
+            id: `${citation.kind === 'case' ? 'decision' : 'document'}:${citation.decision_id ?? citation.doc_id}#${citation.ref}`,
+            verified: citation.verified === true,
+          })),
+        })}\n`, { mode: 0o600 });
+      } catch {}
+    },
+    async save(snapshot: CitationSnapshot) {
+      const serialized = JSON.stringify(snapshot);
+      const token = createHash('sha256').update(serialized).digest('hex');
+      const file = path.join(directory, `${token}.json`);
+      try { await access(file); return token; } catch {}
+      await mkdir(directory, { recursive: true, mode: 0o700 });
+      const temporary = `${file}.${randomUUID()}.tmp`;
+      try {
+        await writeFile(temporary, serialized, { mode: 0o600 });
+        await rename(temporary, file);
+      } finally {
+        await unlink(temporary).catch(() => {});
+      }
+      return token;
+    },
+    async read(token: string, { forViewing = false } = {}): Promise<CitationSnapshot | null> {
+      if (!/^[a-f0-9]{64}$/.test(token)) return null;
+      try {
+        const snapshot = JSON.parse(await readFile(path.join(directory, `${token}.json`), 'utf8')) as CitationSnapshot;
+        const id = snapshot.citation.decision_id;
+        if (forViewing && !snapshot.source && typeof id === 'string' && /^(JURITEXT|CETATEXT)\d{12}$/.test(id)) {
+          try {
+            const file = path.join(homeDir, 'decisions', `${id}.json`);
+            const info = await lstat(file);
+            if (!info.isFile() || info.size > 8 * 1024 * 1024) return snapshot;
+            const cached = JSON.parse(await readFile(file, 'utf8')) as { id?: string; titre?: string; texte?: string };
+            if (cached.id !== id || typeof cached.texte !== 'string' || !cached.texte) return snapshot;
+            const title = snapshot.title === id && typeof cached.titre === 'string' && cached.titre ? cached.titre : snapshot.title;
+            return { ...snapshot, title, source: cached.texte, sourceOrigin: 'decision-cache', ranges: locateSourcePassages(cached.texte, snapshot.citation.quotes) };
+          } catch { return snapshot; }
+        }
+        return snapshot;
+      } catch {
+        return null;
+      }
+    },
+  };
+}