@piecemaker-legal/piecemaker 1.0.6

package/server/piecemaker/anonymizer/sqlite-dictionary.cjs

@@ -0,0 +1,121 @@
+const path = require('node:path');
+
+const Database = require('better-sqlite3');
+
+const { buildDictionary, EMPTY_DICTIONARY } = require('./dictionary.cjs');
+
+function codePrefix(code) {
+  const match = /^(.*?)_(\d+)$/.exec(code);
+  return match ? match[1] : code || 'ENTITE';
+}
+
+function codeNumber(code) {
+  const match = /_(\d+)$/.exec(code);
+  return match ? Number(match[1]) : 0;
+}
+
+function allocateCode(localCode, counters, used) {
+  const prefix = codePrefix(localCode);
+  let index = counters.get(prefix) || 0;
+  let candidate;
+  do {
+    index += 1;
+    candidate = `${prefix}_${String(index).padStart(2, '0')}`;
+  } while (used.has(candidate));
+  counters.set(prefix, index);
+  return candidate;
+}
+
+function buildMappingDocument(rows) {
+  const grouped = new Map();
+  let updatedAt = null;
+  for (const row of rows) {
+    const key = `${row.project_id}\u0000${row.node_id}\u0000${row.masked_value}`;
+    const group = grouped.get(key) || { localCode: row.masked_value, label: row.label, variants: [] };
+    if (!group.variants.includes(row.real_value)) group.variants.push(row.real_value);
+    grouped.set(key, group);
+    if (!updatedAt || row.updated_at > updatedAt) updatedAt = row.updated_at;
+  }
+
+  const used = new Set();
+  const counters = new Map();
+  const mapping = {};
+  const reverse_mapping = {};
+  for (const group of grouped.values()) {
+    const desired = group.localCode;
+    const globalCode = used.has(desired) ? allocateCode(desired, counters, used) : desired;
+    used.add(globalCode);
+    const prefix = codePrefix(globalCode);
+    counters.set(prefix, Math.max(counters.get(prefix) || 0, codeNumber(globalCode)));
+    const canonical = group.variants.includes(group.label) ? group.label : group.variants[0];
+    const variants = [canonical, ...group.variants.filter((value) => value !== canonical)];
+    reverse_mapping[globalCode] = variants;
+    for (const variant of variants) if (!mapping[variant]) mapping[variant] = globalCode;
+  }
+  return { mapping, reverse_mapping, updated_at: updatedAt };
+}
+
+function createSqliteDictionaryLoader({ databasePath }) {
+  const file = path.resolve(databasePath);
+  let database = null;
+  let dataVersion = null;
+  let mappingSignature = null;
+  let generation = 0;
+  let current = EMPTY_DICTIONARY;
+
+  function connection() {
+    if (!database) {
+      database = new Database(file, { readonly: true, fileMustExist: true });
+      database.pragma('busy_timeout = 1000');
+    }
+    return database;
+  }
+
+  function hasTable(target) {
+    return Boolean(target.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='piecemaker_mappings'").get());
+  }
+
+  function load(force = false) {
+    try {
+      const target = connection();
+      const nextDataVersion = target.pragma('data_version', { simple: true });
+      if (!force && nextDataVersion === dataVersion) return current;
+      if (!hasTable(target)) {
+        dataVersion = nextDataVersion;
+        mappingSignature = null;
+        current = EMPTY_DICTIONARY;
+        return current;
+      }
+      const stamp = target.prepare('SELECT COUNT(*) AS count, MAX(updated_at) AS updated_at, TOTAL(rowid) AS rowids FROM piecemaker_mappings').get();
+      const nextSignature = `${stamp.count}:${stamp.updated_at || ''}:${stamp.rowids}`;
+      if (!force && nextSignature === mappingSignature) {
+        dataVersion = nextDataVersion;
+        return current;
+      }
+      mappingSignature = nextSignature;
+      const rows = target.prepare('SELECT m.project_id,m.node_id,m.real_value,m.masked_value,m.updated_at,n.label FROM piecemaker_mappings m JOIN piecemaker_nodes n ON n.project_id=m.project_id AND n.id=m.node_id ORDER BY m.project_id,m.masked_value,m.node_id,LENGTH(m.real_value) DESC,m.real_value').all();
+      generation += 1;
+      current = buildDictionary(buildMappingDocument(rows), generation);
+      dataVersion = nextDataVersion;
+      return current;
+    } catch {
+      return current;
+    }
+  }
+
+  return {
+    file,
+    get: () => load(false),
+    refresh: () => load(true),
+    exists: () => !load(false).empty,
+    close: () => {
+      if (database) database.close();
+      database = null;
+    },
+  };
+}
+
+module.exports = {
+  buildMappingDocument,
+  createSqliteDictionaryLoader,
+};

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

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

@@ -0,0 +1,197 @@
+import { createRequire } from 'node:module';
+import { readFile, realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+
+import type { NormalizedMessage } from '@/shared/types.js';
+import { findApplicationRoot, getModuleDirectory } from '@/shared/utils.js';
+
+import type { createCitationStore } from './citation-store.js';
+import { locateSourcePassages } from './source-passages.js';
+
+const root = findApplicationRoot(getModuleDirectory(import.meta.url));
+const require = createRequire(import.meta.url);
+const vendor = path.join(root, 'server/piecemaker/vendor/piecemaker-plugin/scripts/lib');
+const { parseCitationsWithDiagnostics, parsePartialCitationObjects } = require(path.join(vendor, 'citations.cjs'));
+const { verifyCitations } = require(path.join(vendor, 'verify-citations.cjs'));
+const { extractFullText, extractSourceTitle } = require(path.join(root, 'server/piecemaker/harness/decisions.cjs'));
+const SOURCE_TOOLS = ['__consulter_decision', '__consulter_article'];
+const { structuredMarkdownCounterpart } = require(path.join(vendor, 'case-folder-structure.cjs'));
+const OPEN = '<CITATIONS>';
+const MAX_SOURCE_BYTES = 8 * 1024 * 1024;
+const MAX_TURN_CHARACTERS = 32 * 1024 * 1024;
+
+type Citation = Parameters<ReturnType<typeof createCitationStore>['save']>[0]['citation'] & {
+  kind: 'case' | 'document';
+  decision_id?: string;
+  doc_id?: string;
+};
+
+function record(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function toolText(value: unknown): string {
+  if (typeof value === 'string') {
+    try { return toolText(JSON.parse(value)); } catch { return value; }
+  }
+  if (Array.isArray(value)) return value.map(toolText).join('\n');
+  const object = record(value);
+  if (object.isError === true || object.success === false) return '';
+  return typeof object.text === 'string' ? object.text : toolText(object.content ?? '');
+}
+
+function withinRoot(rootPath: string, file: string) {
+  const relative = path.relative(rootPath, file);
+  return Boolean(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+
+function visibleText(text: string) {
+  const index = text.indexOf(OPEN);
+  return index < 0 ? text : text.slice(0, index);
+}
+
+export function createCitationTurn(options: {
+  cwd: string;
+  sessionId: string;
+  store: ReturnType<typeof createCitationStore>;
+  recordVerification?: boolean;
+  emit: (event: { type: 'citations'; status: 'started' | 'partial' | 'final'; citations: Citation[] }) => void;
+}) {
+  const calls = new Map<string, string>();
+  const decisions = new Map<string, string>();
+  const decisionTitles = new Map<string, string>();
+  const documents = new Map<string, Promise<string>>();
+  let sourceCharacters = 0;
+  let fullText = '';
+  let visibleTail = '';
+  let hidden = false;
+  let partialCount = 0;
+  let overflow = false;
+  let finished: Promise<string> | undefined;
+
+  const documentText = (id: string) => {
+    let pending = documents.get(id);
+    if (!pending) {
+      pending = (async () => {
+        try {
+          const caseRoot = await realpath(options.cwd);
+          const requested = path.resolve(options.cwd, id);
+          if (!withinRoot(path.resolve(options.cwd), requested)) return '';
+          const candidate = path.extname(requested).toLowerCase() === '.md'
+            ? requested : structuredMarkdownCounterpart(requested, options.cwd, {})?.path;
+          if (typeof candidate !== 'string') return '';
+          const canonical = await realpath(candidate);
+          if (!withinRoot(caseRoot, canonical) || path.extname(canonical).toLowerCase() !== '.md') return '';
+          if ((await stat(canonical)).size > MAX_SOURCE_BYTES) return '';
+          const text = await readFile(canonical, 'utf8');
+          sourceCharacters += text.length;
+          return sourceCharacters <= MAX_TURN_CHARACTERS ? text : '';
+        } catch { return ''; }
+      })();
+      documents.set(id, pending);
+    }
+    return pending;
+  };
+
+  const partial = () => {
+    const citations = parsePartialCitationObjects(fullText.slice(fullText.indexOf(OPEN) + OPEN.length)) as Citation[];
+    if (citations.length > partialCount) {
+      partialCount = citations.length;
+      options.emit({ type: 'citations', status: 'partial', citations });
+    }
+  };
+
+  return {
+    get hasCitations() { return hidden; },
+    observe(message: NormalizedMessage) {
+      if (message.parentToolUseId) return;
+      if (message.kind === 'tool_use' && message.toolId && SOURCE_TOOLS.some((tool) => message.toolName?.endsWith(tool))) {
+        let input = record(message.toolInput);
+        if (typeof message.toolInput === 'string') {
+          try { input = record(JSON.parse(message.toolInput)); } catch { return; }
+        }
+        const id = input.text_id ?? input.article_id ?? input.id;
+        if (typeof id === 'string' && /^[A-Za-z0-9_-]{1,80}$/.test(id)) calls.set(message.toolId, id);
+      }
+      if (message.kind === 'tool_result' && message.toolId && !message.isError && !message.toolResult?.isError) {
+        const id = calls.get(message.toolId);
+        if (!id) return;
+        const raw = toolText(message.content ?? message.toolResult?.content);
+        const text = extractFullText(raw) as string;
+        if (text.length > MAX_SOURCE_BYTES || text.length <= (decisions.get(id)?.length ?? 0)) return;
+        sourceCharacters += text.length;
+        if (sourceCharacters <= MAX_TURN_CHARACTERS) {
+          decisions.set(id, text);
+          const title = extractSourceTitle(raw) as string;
+          if (title) decisionTitles.set(id, title);
+        }
+      }
+    },
+    delta(delta: string) {
+      if (!overflow && fullText.length + delta.length > MAX_TURN_CHARACTERS) {
+        overflow = true;
+        fullText = '';
+      }
+      if (!overflow) fullText += delta;
+      if (hidden) { if (!overflow) partial(); return ''; }
+      const combined = visibleTail + delta;
+      const marker = combined.indexOf(OPEN);
+      if (marker >= 0) {
+        hidden = true;
+        visibleTail = '';
+        options.emit({ type: 'citations', status: 'started', citations: [] });
+        if (!overflow) partial();
+        return combined.slice(0, marker);
+      }
+      const keep = Math.min(OPEN.length - 1, combined.length);
+      visibleTail = combined.slice(combined.length - keep);
+      return combined.slice(0, combined.length - keep);
+    },
+    flush() {
+      const tail = hidden ? '' : visibleTail;
+      visibleTail = '';
+      return tail;
+    },
+    text(text: string) {
+      if (text.includes(OPEN)) {
+        if (text.length <= MAX_TURN_CHARACTERS) fullText = text;
+        else overflow = true;
+        if (!hidden) options.emit({ type: 'citations', status: 'started', citations: [] });
+        hidden = true;
+        if (!overflow) partial();
+      }
+      return visibleText(text);
+    },
+    finish() {
+      if (finished) return finished;
+      finished = (async () => {
+        const parsed = overflow ? [] : parseCitationsWithDiagnostics(fullText).citations as Citation[];
+        const citations = await verifyCitations(parsed, documentText, async (id: string) => decisions.get(id) ?? '') as Citation[];
+        if (citations.length && options.recordVerification !== false) await options.store.recordVerification(options.sessionId, citations);
+        const decisionTitle = (id?: string) => (id ? decisionTitles.get(id) : undefined);
+        const links: string[] = [];
+        const labels: string[] = [];
+        for (const citation of citations) {
+          const source = citation.kind === 'case'
+            ? decisions.get(citation.decision_id ?? '') ?? '' : await documentText(citation.doc_id ?? '');
+          const ranges = locateSourcePassages(source, citation.quotes);
+          try {
+            const token = await options.store.save({
+              sessionId: options.sessionId,
+              title: decisionTitle(citation.decision_id) ?? citation.decision_id ?? citation.doc_id ?? 'Source',
+              source, citation, ranges,
+            });
+            links.push(`[${citation.ref}]: #piecemaker-citation=${token}`);
+            labels.push(`[${citation.ref}]${citation.verified === false ? ' — extrait non retrouvé dans la source' : ''}`);
+          } catch {
+            labels.push(`Citation ${citation.ref} — source indisponible`);
+          }
+        }
+        options.emit({ type: 'citations', status: 'final', citations });
+        if (!links.length && !labels.length) return '';
+        return `\n\nSources : ${labels.join(' · ')}\n\n${links.join('\n')}`;
+      })();
+      return finished;
+    },
+  };
+}

package/server/piecemaker/harness/citations.routes.ts

@@ -0,0 +1,18 @@
+import { Router } from 'express';
+
+import type { createCitationStore } from './citation-store.js';
+
+export function createCitationsRouter(store: ReturnType<typeof createCitationStore>, sessionExists: (id: string) => boolean) {
+  const router = Router();
+  router.get('/citations/:token', async (request, response) => {
+    const snapshot = await store.read(String(request.params.token), { forViewing: true });
+    response.setHeader('Cache-Control', 'no-store');
+    if (!snapshot || !sessionExists(snapshot.sessionId)) {
+      response.status(404).json({ error: 'Source indisponible.' });
+      return;
+    }
+    const { sessionId: _sessionId, ...source } = snapshot;
+    response.json(source);
+  });
+  return router;
+}