@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/protection.cjs

@@ -0,0 +1,419 @@
+/**
+ * Protection des pièces d'un dossier juridique — par fichier, pas par dossier.
+ *
+ * L'ancienne règle protégeait le contenu d'un sous-dossier « Pièces
+ * originales ». Elle ne protégeait donc rien dans un dossier organisé
+ * autrement, ce qui est le cas courant : les PDF et DOCX y côtoient le Markdown
+ * qu'on en a tiré. La protection est désormais une propriété du fichier,
+ * décidée dans l'administration.
+ *
+ * **Protégés par défaut : les PDF et les images** (`PROTECTED_EXTENSIONS`), qui
+ * sont les formats dont on tire un Markdown converti. Tout le reste est
+ * accessible à l'IA, anonymisé à la lecture par le proxy PII. Le fichier
+ * `.piecemaker/protection.json` d'un dossier n'enregistre que les *exceptions* —
+ * ce que l'utilisateur a explicitement libéré : une pièce PDF déposée entre deux
+ * passages dans l'administration est donc protégée sans action de sa part.
+ *
+ * Deux familles échappent à ce classement et sont interdites à l'IA en toute
+ * circonstance, quelle que soit leur extension : le mapping du dossier et les
+ * scans PII (`isMappingFile`), les secrets d'environnement (`isSecretFile`).
+ * Elles ne passent pas par `isProtectedFile` — l'historique du cabinet doit
+ * continuer à versionner le mapping (`commits.cjs`) — mais par des refus dédiés
+ * dans `protect-originals.mjs`.
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+const { structuredMarkdownCounterpart } = require('./case-folder-structure.cjs');
+
+const PROTECTION_DIR = '.piecemaker';
+const PROTECTION_FILE = 'protection.json';
+const PROTECTION_BYPASS_FILE = 'protection-bypass.json';
+
+/**
+ * Sous-dossier technique historique et emplacement du `mapping_default.json`.
+ * Le Markdown courant vit dans les sous-dossiers de conversion de
+ * Correspondance et Data Room ; ce repli reste nécessaire aux anciens dossiers
+ * et aux espaces de travail OOXML. `mapping.cjs` et `commits.cjs` l'importent.
+ */
+const WORKSPACE_SUBDIR = 'Fichiers convertis PieceMaker';
+
+/**
+ * Suffixe d'un sous-dossier de travail OOXML : une copie extraite d'un `.docx`
+ * (`unzip`), rangée sous `WORKSPACE_SUBDIR`. Ses parties (`word/document.xml`,
+ * `_rels`, médias…) ne sont ni `.md` ni `.json` : sans règle dédiée elles
+ * tomberaient dans le coffre-fort et l'édition OOXML serait impossible. On les
+ * classe donc d'office en espace de travail (voir `isOoxmlWorkspacePath`).
+ */
+const OOXML_WORKDIR_SUFFIX = '-ooxml';
+
+/** Extensions lisibles par l'IA, sous réserve du mapping appliqué à la lecture. */
+const READABLE_EXTENSIONS = new Set(['.md', '.json']);
+
+/**
+ * Seules extensions protégées : les PDF et les images. Ce sont les pièces dont
+ * la lecture directe livrerait l'original non pseudonymisé et pour lesquelles un
+ * Markdown converti existe. Toute autre extension est accessible à l'IA.
+ */
+const PROTECTED_EXTENSIONS = new Set([
+  '.pdf',
+  '.png',
+  '.jpg',
+  '.jpeg',
+  '.gif',
+  '.bmp',
+  '.webp',
+  '.tif',
+  '.tiff',
+  '.heic',
+  '.heif',
+  '.avif',
+]);
+
+/**
+ * JSON qui trahiraient la frontière s'ils étaient lus :
+ *  - `mapping*.json` fait correspondre chaque code au nom réel — le lire, c'est
+ *    dé-anonymiser le dossier entier d'un seul appel d'outil ;
+ *  - `*_sensitive_map.json` est une ancienne sortie brute de GLiNER/Presidio.
+ *    Le pipeline actuel la garde en espace temporaire, mais un ancien dossier
+ *    peut encore en porter pendant sa migration.
+ *
+ * Appliquer le mapping à leur lecture ne suffirait pas : les entités trop courtes,
+ * celles rangées sous `ignored` et les variantes d'`extracted_data` ressortiraient
+ * telles quelles. Le seul traitement correct est le refus.
+ */
+const FORBIDDEN_JSON_PATTERNS = [/^mapping.*\.json$/i, /_sensitive_map\.json$/i, /^central-mapping\.json$/i];
+
+/** Vrai pour un mapping de dossier ou un scan PII, où qu'il soit rangé. */
+function isMappingFile(filePath) {
+  const base = path.basename(String(filePath || ''));
+  return FORBIDDEN_JSON_PATTERNS.some((pattern) => pattern.test(base));
+}
+
+/**
+ * Fichiers d'environnement : clés d'API, identifiants de base, jetons. Ils ne
+ * sont pas des pièces, aucune anonymisation ne les rend inoffensifs, et une
+ * seule lecture suffit à les exfiltrer. Refus sans exception possible, comme le
+ * mapping. `.env.example` est écarté : il ne porte que des noms de variables.
+ */
+const SECRET_FILE_PATTERNS = [/^\.env$/i, /^\.env\.(?!example$|sample$|template$)/i, /\.env$/i];
+
+/** Vrai pour un fichier de secrets d'environnement, où qu'il soit rangé. */
+function isSecretFile(filePath) {
+  const base = path.basename(String(filePath || ''));
+  return SECRET_FILE_PATTERNS.some((pattern) => pattern.test(base));
+}
+
+function normalizeOriginalName(value) {
+  return String(value || '')
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[\s_-]+/g, ' ')
+    .trim();
+}
+
+/** Clé stable reliant une pièce à son Markdown et à son scan PII. */
+function documentKey(filePath) {
+  return normalizeOriginalName(path.basename(filePath, path.extname(filePath))).replaceAll(' ', '-');
+}
+
+function protectionFile(caseRoot) {
+  return path.join(caseRoot, PROTECTION_DIR, PROTECTION_FILE);
+}
+
+function protectionBypassFile(caseRoot) {
+  return path.join(caseRoot, PROTECTION_DIR, PROTECTION_BYPASS_FILE);
+}
+
+/**
+ * Levée de protection à l'échelle du dossier : un fichier présent suffit, et
+ * couvre les pièces déposées après coup. `protection.json` n'est pas touché,
+ * le classement pièce par pièce revient dès que le fichier disparaît.
+ */
+function isProtectionBypassed(caseRoot) {
+  try {
+    return fs.statSync(protectionBypassFile(caseRoot)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Résout les liens symboliques en remontant jusqu'au premier ancêtre existant,
+ * puis en rattachant le reste du chemin. Un chemin qui n'existe pas encore (le
+ * Markdown attendu d'une pièce, un sous-dossier à créer) doit se comparer à une
+ * racine résolue, sinon `/var/…` et `/private/var/…` ne se recouvrent jamais
+ * sur macOS et le dossier passe pour hors racine.
+ */
+function realpathOrParent(target) {
+  let current = target;
+  const tail = [];
+  for (let depth = 0; depth < 64; depth += 1) {
+    try {
+      return path.join(fs.realpathSync(current), ...tail);
+    } catch {
+      const parent = path.dirname(current);
+      if (parent === current) return target;
+      tail.unshift(path.basename(current));
+      current = parent;
+    }
+  }
+  return target;
+}
+
+/**
+ * Chemin relatif au dossier, séparateurs POSIX — la forme stockée et échangée.
+ * Les deux côtés sont résolus : comparer un `/var/…` à un `/private/var/…`
+ * (macOS) donnait un chemin remontant hors du dossier, donc « non protégé ».
+ */
+function relativeKey(absolutePath, caseRoot) {
+  const relative = path.relative(realpathOrParent(path.resolve(caseRoot)), realpathOrParent(path.resolve(absolutePath)));
+  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return null;
+  return relative.split(path.sep).join('/');
+}
+
+/**
+ * Situe un chemin dans la racine PieceMaker : chaque enfant direct de cette
+ * racine est un dossier juridique indépendant. Retourne `null` hors racine, ce
+ * qui est le cas de la grande majorité des appels d'outil — c'est le chemin
+ * rapide des hooks.
+ */
+function locateCase(casesRoot, target) {
+  if (!casesRoot || !target) return null;
+  let root;
+  try {
+    root = fs.realpathSync(path.resolve(String(casesRoot)));
+  } catch {
+    return null;
+  }
+  // Les deux côtés doivent être résolus : sur macOS `/var/…` est un lien vers
+  // `/private/var/…`, si bien qu'une racine résolue et une cible qui ne l'est
+  // pas ne se recouvrent jamais — le dossier passait alors pour hors racine et
+  // rien n'était protégé.
+  const absolute = realpathOrParent(path.resolve(String(target)));
+  if (absolute === root || !absolute.startsWith(`${root}${path.sep}`)) return null;
+  const [caseName, ...rest] = path.relative(root, absolute).split(path.sep);
+  if (!caseName || caseName.startsWith('.')) return null;
+  const caseRoot = path.join(root, caseName);
+  try {
+    if (!fs.statSync(caseRoot).isDirectory()) return null;
+  } catch {
+    return null;
+  }
+  return { casesRoot: root, caseName, caseRoot, absolute, relative: rest.join('/') };
+}
+
+/** Normalise une liste de chemins relatifs en Set de clés POSIX. */
+function normalizeKeySet(list) {
+  return new Set(
+    (Array.isArray(list) ? list : [])
+      .map((entry) => String(entry || '').replaceAll('\\', '/').trim())
+      .filter(Boolean)
+  );
+}
+
+/**
+ * Trois états possibles pour une pièce, encodés comme deux listes d'exceptions
+ * dans `protection.json` (le défaut, liste vide, est le coffre-fort) :
+ *  - **Coffre-fort** : hors des deux listes — protégé, l'IA ne lit que le `.md` ;
+ *  - **Espace de travail** : dans `unprotected` — accessible, anonymisé à la
+ *    lecture par les hooks ;
+ *  - **Ressource** : dans `resources` — accessible, et exclu du scan GLiNER et de
+ *    la conversion Markdown (documents publics sans donnée personnelle).
+ */
+function readProtection(caseRoot) {
+  const file = protectionFile(caseRoot);
+  let raw = null;
+  try {
+    raw = JSON.parse(fs.readFileSync(file, 'utf8').replace(/^/, ''));
+  } catch {
+    raw = null;
+  }
+  return {
+    file,
+    exists: raw !== null,
+    bypass: isProtectionBypassed(caseRoot),
+    unprotected: normalizeKeySet(raw?.unprotected),
+    resources: normalizeKeySet(raw?.resources),
+  };
+}
+
+/**
+ * Écrit les deux listes d'exceptions. Une liste laissée à `undefined` est
+ * *préservée* (relue depuis le disque) : un appelant historique qui ne connaît
+ * que `unprotected` — l'initialisation d'un dossier — n'efface pas les
+ * ressources déjà déclarées.
+ */
+function writeProtection(caseRoot, { unprotected, resources } = {}) {
+  const file = protectionFile(caseRoot);
+  const existing = readProtection(caseRoot);
+  const clean = (list, fallback) => [...new Set(
+    (Array.isArray(list) ? list : [...fallback])
+      .map((entry) => String(entry || '').replaceAll('\\', '/').trim())
+      .filter((entry) => entry && !entry.startsWith('../') && !path.isAbsolute(entry))
+  )].sort((a, b) => a.localeCompare(b, 'fr'));
+  // Une pièce ne peut être à la fois « espace de travail » et « ressource » :
+  // `resources` a priorité, on la retire donc de `unprotected`.
+  const resourcesList = clean(resources, existing.resources);
+  const resourceSet = new Set(resourcesList);
+  const unprotectedList = clean(unprotected, existing.unprotected).filter((key) => !resourceSet.has(key));
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(
+    file,
+    `${JSON.stringify({ version: 1, unprotected: unprotectedList, resources: resourcesList }, null, 2)}\n`,
+    'utf8'
+  );
+  return { file, unprotected: new Set(unprotectedList), resources: resourceSet };
+}
+
+/** Vrai pour un chemin recevable dans une des deux listes d'exceptions. */
+function exceptionKey(absolutePath, caseRoot) {
+  const key = relativeKey(absolutePath, caseRoot);
+  if (!key) return null;
+  // Les dotfiles sont de la configuration du dossier, jamais des pièces —
+  // `.piecemaker/protection.json` inclus, qui doit rester lisible par l'admin.
+  if (key.split('/').some((segment) => segment.startsWith('.'))) return null;
+  if (READABLE_EXTENSIONS.has(path.extname(key).toLowerCase())) return null;
+  return key;
+}
+
+/**
+ * Vrai pour un chemin situé dans un sous-dossier de travail OOXML — la copie
+ * extraite d'un `.docx`, rangée sous `WORKSPACE_SUBDIR` dans un sous-dossier
+ * dont le nom finit par `OOXML_WORKDIR_SUFFIX`. Tout son sous-arbre est classé
+ * espace de travail (accessible, filtré à la lecture) sans inscription dans
+ * `protection.json`. Le `.docx` original n'est pas dans ce sous-dossier : il
+ * reste protégé. Seul un *dossier* intermédiaire compte — un fichier isolé
+ * nommé `…-ooxml` sous `WORKSPACE_SUBDIR` reste, lui, protégé.
+ */
+function isOoxmlWorkspacePath(absolutePath, caseRoot) {
+  const key = relativeKey(absolutePath, caseRoot);
+  if (!key) return false;
+  const segments = key.split('/');
+  if (segments[0] !== WORKSPACE_SUBDIR) return false;
+  return segments.slice(1, -1).some((segment) => segment.toLowerCase().endsWith(OOXML_WORKDIR_SUFFIX));
+}
+
+/**
+ * Un fichier est protégé s'il est dans le dossier, que son extension est celle
+ * d'un PDF ou d'une image (`PROTECTED_EXTENSIONS`), et qu'il ne figure dans
+ * *aucune* des deux listes d'exceptions (espace de travail ou ressource, toutes
+ * deux accessibles à l'IA). `state` évite de relire le fichier d'exceptions à
+ * chaque appel dans une boucle.
+ */
+function isProtectedFile(absolutePath, caseRoot, state = null) {
+  if (!absolutePath || !caseRoot) return false;
+  const key = exceptionKey(absolutePath, caseRoot);
+  if (!key) return false;
+  if (!PROTECTED_EXTENSIONS.has(path.extname(key).toLowerCase())) return false;
+  // Copie extraite d'un .docx : espace de travail implicite, jamais coffre-fort.
+  if (isOoxmlWorkspacePath(absolutePath, caseRoot)) return false;
+  const current = state || readProtection(caseRoot);
+  if (current.bypass) return false;
+  const { unprotected, resources } = current;
+  return !unprotected.has(key) && !(resources && resources.has(key));
+}
+
+/**
+ * Vrai pour une pièce marquée « ressource » : accessible à l'IA et exclue du
+ * scan GLiNER comme de la conversion Markdown.
+ */
+function isResourceFile(absolutePath, caseRoot, state = null) {
+  if (!absolutePath || !caseRoot) return false;
+  const key = exceptionKey(absolutePath, caseRoot);
+  if (!key) return false;
+  const { resources } = state || readProtection(caseRoot);
+  return Boolean(resources && resources.has(key));
+}
+
+/**
+ * Le Markdown à lire à la place d'une pièce protégée. Les dossiers structurés
+ * l'écrivent dans la zone de conversion de Correspondance ou Data Room ; les
+ * anciens dossiers utilisent encore `WORKSPACE_SUBDIR`, la racine ou le dossier
+ * de la pièce. À défaut, le chemin attendu rend le refus actionnable.
+ */
+function markdownCounterpart(absolutePath, caseRoot) {
+  const stem = path.basename(absolutePath, path.extname(absolutePath));
+  const structured = structuredMarkdownCounterpart(absolutePath, caseRoot);
+  const workspaceMarkdown = path.join(caseRoot, WORKSPACE_SUBDIR, `${stem}.md`);
+  const candidates = [
+    ...(structured ? [structured.path] : []),
+    workspaceMarkdown,
+    path.join(path.dirname(absolutePath), `${stem}.md`),
+    path.join(caseRoot, `${stem}.md`),
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return { path: candidate, exists: true };
+  }
+  // Repli : une conversion antérieure a pu normaliser le nom (accents, casse).
+  const key = documentKey(absolutePath);
+  for (const dir of [path.join(caseRoot, WORKSPACE_SUBDIR), caseRoot]) {
+    try {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isFile() || path.extname(entry.name).toLowerCase() !== '.md') continue;
+        if (documentKey(entry.name) === key) return { path: path.join(dir, entry.name), exists: true };
+      }
+    } catch {
+      // dossier illisible : on essaie l'emplacement suivant
+    }
+  }
+  return structured || { path: workspaceMarkdown, exists: false };
+}
+
+/**
+ * Classe une pièce en « espace de travail » : accessible à l'IA, anonymisée à
+ * la lecture. C'est l'écriture ciblée dont a besoin le hook
+ * `classify-ai-documents.mjs` — un document produit par l'IA n'a aucune raison
+ * de naître au coffre-fort, elle ne pourrait plus se relire.
+ *
+ * Ne fait rien, et retourne pourquoi, quand le chemin n'est pas une pièce
+ * classable : hors dossier, `.md`/`.json` (déjà lisibles), dotfile, mapping ou
+ * scan PII (jamais déclassés), espace de travail OOXML implicite, ou clé déjà
+ * inscrite. `resources` est prioritaire : une ressource n'est jamais
+ * rétrogradée en espace de travail. Idempotent, ne lève jamais.
+ */
+function classifyAsWorkspace(absolutePath, caseRoot) {
+  try {
+    if (!absolutePath || !caseRoot) return { classified: false, key: null, reason: 'arguments' };
+    if (isMappingFile(absolutePath)) return { classified: false, key: null, reason: 'mapping' };
+    const key = exceptionKey(absolutePath, caseRoot);
+    if (!key) return { classified: false, key: null, reason: 'non-classable' };
+    if (isOoxmlWorkspacePath(absolutePath, caseRoot)) return { classified: false, key, reason: 'ooxml' };
+    const { unprotected, resources } = readProtection(caseRoot);
+    if (resources.has(key)) return { classified: false, key, reason: 'ressource' };
+    if (unprotected.has(key)) return { classified: false, key, reason: 'déjà classée' };
+    writeProtection(caseRoot, { unprotected: [...unprotected, key] });
+    return { classified: true, key, reason: null };
+  } catch (error) {
+    return { classified: false, key: null, reason: error?.message || 'erreur' };
+  }
+}
+
+module.exports = {
+  classifyAsWorkspace,
+  documentKey,
+  exceptionKey,
+  isMappingFile,
+  isSecretFile,
+  locateCase,
+  isProtectedFile,
+  isProtectionBypassed,
+  isOoxmlWorkspacePath,
+  isResourceFile,
+  markdownCounterpart,
+  normalizeOriginalName,
+  protectionFile,
+  protectionBypassFile,
+  readProtection,
+  relativeKey,
+  writeProtection,
+  PROTECTION_DIR,
+  PROTECTION_FILE,
+  PROTECTION_BYPASS_FILE,
+  READABLE_EXTENSIONS,
+  PROTECTED_EXTENSIONS,
+  FORBIDDEN_JSON_PATTERNS,
+  SECRET_FILE_PATTERNS,
+  WORKSPACE_SUBDIR,
+  OOXML_WORKDIR_SUFFIX,
+};

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/recherche-report.cjs

@@ -0,0 +1,177 @@
+'use strict';
+
+/**
+ * Rendu déterministe d'un rapport de recherche juridique.
+ *
+ * Ce module est *pur* : il transforme un « payload » produit par
+ * l'orchestrateur de recherche en un document Markdown au gabarit fixe. Aucun
+ * LLM n'intervient — c'est exactement la partie que l'utilisateur veut sortir
+ * de la main d'un agent. Il vit dans `scripts/lib/` parce que le hook
+ * `compile-recherche.mjs` ne peut requérir que depuis là (le plugin est livré
+ * autonome).
+ */
+
+/** Retire les accents et normalise en minuscules pour un slug de fichier. */
+function slugify(value, { maxLength = 60 } = {}) {
+  const base = String(value || '')
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, maxLength)
+    .replace(/-+$/g, '');
+  return base || 'recherche';
+}
+
+/** `2026-08-18-clause-penale` — préfixe daté pour un classement chronologique. */
+function reportSlug(payload, { date } = {}) {
+  const day = (date || payload.date || new Date().toISOString().slice(0, 10)).slice(0, 10);
+  const explicit = payload.slug ? slugify(payload.slug) : null;
+  const derived = explicit || slugify(payload.titre || payload.question || 'recherche');
+  return `${day}-${derived}`;
+}
+
+function asArray(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+function escapeCell(value) {
+  return String(value == null ? '' : value).replace(/\|/g, '\\|').replace(/\n+/g, ' ').trim();
+}
+
+function decisionRow(entry) {
+  if (typeof entry === 'string') {
+    return `| ${escapeCell(entry)} | | | | |`;
+  }
+  const titre = escapeCell(entry.titre || entry.title || entry.intitule);
+  const juridiction = escapeCell(entry.juridiction || entry.jurisdiction);
+  const date = escapeCell(entry.date);
+  const reference = escapeCell(entry.reference || entry.numero || entry.ref);
+  const lien = entry.lien || entry.url || entry.legifrance;
+  const lienCell = lien ? `[Legifrance](${escapeCell(lien)})` : '';
+  return `| ${titre} | ${juridiction} | ${date} | ${reference} | ${lienCell} |`;
+}
+
+function integer(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.max(0, Math.trunc(parsed)) : null;
+}
+
+function metricLine(label, value) {
+  const count = integer(value);
+  return count == null ? null : `- **${label}** : ${count.toLocaleString('fr-FR')}`;
+}
+
+function renderMetrics(metrics) {
+  if (!metrics || typeof metrics !== 'object') return [];
+  const lines = ['## Couverture et coût', ''];
+  const counts = [
+    metricLine('Décisions identifiées (dédupliquées)', metrics.decisionsIdentifiees ?? metrics.identified),
+    metricLine('Décisions scannées en texte intégral', metrics.decisionsScannees ?? metrics.scanned),
+    metricLine('Fiches validées', metrics.fichesValidees ?? metrics.validCards),
+    metricLine('Échecs', metrics.echecs ?? metrics.failed),
+  ].filter(Boolean);
+  lines.push(...counts);
+
+  const input = integer(metrics.tokensEntree ?? metrics.inputTokens);
+  const output = integer(metrics.tokensSortie ?? metrics.outputTokens);
+  const exact = metrics.tokensExacts === true || metrics.exact === true;
+  if (input != null) lines.push(`- **Tokens d'entrée ${exact ? 'exacts' : 'estimés'}** : ${input.toLocaleString('fr-FR')}`);
+  if (output != null) lines.push(`- **Tokens de sortie ${exact ? 'exacts' : 'estimés'}** : ${output.toLocaleString('fr-FR')}`);
+  if (metrics.reasoningTokens != null) {
+    const reasoning = integer(metrics.reasoningTokens);
+    if (reasoning != null) lines.push(`- **Tokens de raisonnement exacts** : ${reasoning.toLocaleString('fr-FR')}`);
+  }
+  if (!exact && metrics.methodeEstimation) {
+    lines.push(`- **Méthode d'estimation** : ${String(metrics.methodeEstimation).trim()}`);
+  }
+  if (metrics.tronquee === true || metrics.truncated === true) {
+    lines.push('- **Couverture** : ⚠️ corpus tronqué par un plafond explicite');
+  }
+  if (!counts.length && input == null && output == null) return [];
+  lines.push('');
+  return lines;
+}
+
+/**
+ * Construit le Markdown final. L'ordre des sections suit la spécification :
+ * question initiale → décision(s)/texte(s) trouvé(s) → citation retenue →
+ * rapport de tri (Haiku) → liens Legifrance.
+ */
+function renderMarkdown(payload, { date, caseName } = {}) {
+  const day = (date || payload.date || new Date().toISOString().slice(0, 10)).slice(0, 10);
+  const titre = payload.titre || payload.slug || 'Recherche juridique';
+  const decisions = asArray(payload.decisions || payload.textes);
+  const liens = asArray(payload.liens || payload.links).filter(Boolean);
+
+  const lines = [];
+  lines.push(`# Recherche juridique — ${titre}`);
+  lines.push('');
+  lines.push(`- **Date de la recherche** : ${day}`);
+  if (caseName) lines.push(`- **Dossier** : ${caseName}`);
+  if (payload.citation) lines.push(`- **Citation retenue** : ${payload.citation}`);
+  lines.push('');
+
+  lines.push('## Question initiale');
+  lines.push('');
+  lines.push(String(payload.question || '_Non renseignée._').trim());
+  lines.push('');
+
+  lines.push('## Décision(s) / texte(s) trouvé(s)');
+  lines.push('');
+  if (decisions.length) {
+    lines.push('| Titre | Juridiction | Date | Référence | Legifrance |');
+    lines.push('| --- | --- | --- | --- | --- |');
+    for (const entry of decisions) lines.push(decisionRow(entry));
+  } else {
+    lines.push('_Aucune décision ou texte retenu._');
+  }
+  lines.push('');
+
+  lines.push('## Citation retenue');
+  lines.push('');
+  lines.push(payload.citation ? `> ${String(payload.citation).trim()}` : '_Aucune citation vérifiée._');
+  lines.push('');
+
+  lines.push(`## ${String(payload.analyseLabel || 'Rapport de tri (Haiku)').trim()}`);
+  lines.push('');
+  lines.push(String(payload.rapport || '_Non renseigné._').trim());
+  lines.push('');
+
+  if (payload.methodologie) {
+    lines.push('## Méthodologie');
+    lines.push('');
+    lines.push(String(payload.methodologie).trim());
+    lines.push('');
+  }
+
+  lines.push(...renderMetrics(payload.metriques || payload.metrics));
+
+  lines.push('## Liens Legifrance');
+  lines.push('');
+  if (liens.length) {
+    for (const lien of liens) lines.push(`- ${lien}`);
+  } else {
+    lines.push('_Aucun lien fourni._');
+  }
+  lines.push('');
+
+  lines.push('---');
+  lines.push('');
+  lines.push(
+    '_Document compilé automatiquement par PieceMaker (hook `compile-recherche`). '
+      + 'Références à vérifier indépendamment par l\'avocat avant toute citation dans un acte._',
+  );
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  slugify,
+  reportSlug,
+  renderMetrics,
+  renderMarkdown,
+};

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/session-timing.cjs

@@ -0,0 +1,80 @@
+/**
+ * Session timing helpers shared by the commit and billing hooks.
+ *
+ * A hook runs once per event with no memory of the session's start. The
+ * transcript is the only durable clock: its first entry's `timestamp` is the
+ * session start. `commit-track.mjs` needs that start on every Write/Edit to
+ * stamp the elapsed session time into the commit, so reading the whole
+ * transcript on each tool call would be wasteful — we only need the first
+ * timestamp, so we scan a bounded head of the file.
+ *
+ * Everything here fails soft: an unreadable/empty/malformed transcript yields
+ * `null`, and the caller simply omits the time trailer.
+ */
+const fs = require('node:fs');
+
+// Enough to comfortably contain the first JSONL record even with a large
+// system prompt echoed into it; we stop at the first line that parses.
+const HEAD_BYTES = 256 * 1024;
+
+/** First ISO timestamp in the transcript (session start), or null. */
+function readSessionStartTimestamp(transcriptPath) {
+  if (!transcriptPath) return null;
+  let fd;
+  try {
+    fd = fs.openSync(transcriptPath, 'r');
+    const stat = fs.fstatSync(fd);
+    const length = Math.min(stat.size, HEAD_BYTES);
+    if (length === 0) return null;
+    const buffer = Buffer.allocUnsafe(length);
+    const bytesRead = fs.readSync(fd, buffer, 0, length, 0);
+    const text = buffer.subarray(0, bytesRead).toString('utf8');
+    for (const line of text.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      // The last line of a partial head read may be truncated; ignore parse
+      // failures and keep looking for the first fully-formed record.
+      let entry;
+      try {
+        entry = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      const ts = entry?.timestamp || entry?.message?.timestamp;
+      if (ts && Number.isFinite(Date.parse(ts))) return ts;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch {}
+    }
+  }
+}
+
+/** Milliseconds elapsed between the session's first entry and `now`. */
+function sessionElapsedMs(transcriptPath, now = Date.now()) {
+  const start = readSessionStartTimestamp(transcriptPath);
+  if (!start) return null;
+  const ms = now - Date.parse(start);
+  return Number.isFinite(ms) && ms >= 0 ? ms : null;
+}
+
+/** Compact French duration, e.g. "12 min 30 s", "1 h 05 min", "8 s". */
+function formatDurationFr(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return null;
+  const totalSeconds = Math.round(ms / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours} h ${String(minutes).padStart(2, '0')} min`;
+  if (minutes > 0) return `${minutes} min ${String(seconds).padStart(2, '0')} s`;
+  return `${seconds} s`;
+}
+
+module.exports = {
+  formatDurationFr,
+  readSessionStartTimestamp,
+  sessionElapsedMs,
+};