@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/vendor/mike-defaults-fr/tabular-review-workflows/commercial-agreement-tabular-review/table-columns.yaml

@@ -0,0 +1,92 @@
+$schema: "../../workflow-schema/table-columns.schema.yaml"
+columns:
+  - index: 0
+    name: "Parties"
+    format: "bulleted_list"
+    prompt: >-
+      Identifiez toutes les parties à cet accord. Pour chaque partie, indiquez sa dénomination sociale complète, sa juridiction de constitution (si elle est indiquée) et son rôle dans l'accord (par exemple fournisseur, client ou donneur de licence).
+  - index: 1
+    name: "Périmètre des prestations"
+    format: "text"
+    prompt: >-
+      Résumez le périmètre des travaux ou des services à fournir au titre de cet accord. Quels sont les principaux livrables, obligations ou services ? Identifiez toute limitation ou exclusion du périmètre.
+  - index: 2
+    name: "Modifie un accord antérieur"
+    format: "text"
+    prompt: >-
+      Cet accord modifie-t-il, refond-il, complète-t-il ou remplace-t-il un accord antérieur ? Si oui, identifiez l'accord antérieur par son nom et sa date.
+  - index: 3
+    name: "Date d'entrée en vigueur"
+    format: "date"
+    prompt: >-
+      Quelle est la date d'entrée en vigueur ou de commencement de cet accord ? Si aucune date explicite n'est indiquée, précisez à quel moment il est réputé prendre effet.
+  - index: 4
+    name: "Durée"
+    format: "text"
+    prompt: >-
+      Quelle est la durée de cet accord ? Indiquez la durée initiale et toute condition qui en affecte la durée.
+  - index: 5
+    name: "Renouvellement"
+    format: "text"
+    prompt: >-
+      Quelles dispositions de renouvellement s'appliquent ? Précisez si le renouvellement est automatique ou nécessite une notification, sa durée, ainsi que les conditions ou délais de préavis requis pour empêcher un renouvellement automatique.
+  - index: 6
+    name: "Prix"
+    format: "text"
+    prompt: >-
+      Quelle est la structure tarifaire prévue par cet accord ? Identifiez tous les frais, taux, coûts et modalités de paiement, y compris la devise, l'échéancier de paiement et les exigences de facturation.
+  - index: 7
+    name: "Révision des prix"
+    format: "text"
+    prompt: >-
+      L'accord prévoit-il des mécanismes de révision des prix ? Identifiez toute indexation, référence à l'IPC, indice des prix de détail, comparaison de marché, modification liée au volume ou autre mécanisme permettant de modifier les prix pendant la durée.
+  - index: 8
+    name: "Pénalités de retard de paiement"
+    format: "text"
+    prompt: >-
+      Quelles pénalités ou conséquences s'appliquent en cas de retard de paiement ? Incluez tout taux d'intérêt sur les sommes échues, droit de suspension ou autre recours dont dispose le bénéficiaire du paiement.
+  - index: 9
+    name: "Valeur contractuelle estimée"
+    format: "text"
+    prompt: >-
+      Quelle est la valeur contractuelle totale estimée ou indiquée ? Si aucun montant unique n'est donné, calculez ou estimez-le à partir des taux et de la durée indiqués. Indiquez la devise et toutes les hypothèses retenues.
+  - index: 10
+    name: "Limitation de responsabilité"
+    format: "text"
+    prompt: >-
+      Quelles limitations de responsabilité s'appliquent ? Identifiez tout plafond de responsabilité (y compris son mode de calcul), toute exclusion des pertes consécutives ou indirectes et toute exception au plafond (par exemple fraude, décès ou atteinte à la propriété intellectuelle).
+  - index: 11
+    name: "Propriété intellectuelle et licences"
+    format: "text"
+    prompt: >-
+      Comment la propriété intellectuelle et les licences sont-elles traitées ? Identifiez le titulaire des droits préexistants, le titulaire des droits nouvellement créés et les licences accordées à chaque partie. Relevez toute restriction d'utilisation.
+  - index: 12
+    name: "Changement de contrôle"
+    format: "text"
+    prompt: >-
+      L'accord contient-il une clause de changement de contrôle ? Si oui, décrivez ce qui constitue un changement de contrôle, si un consentement est requis et quels droits (par exemple résiliation ou cession) sont déclenchés.
+  - index: 13
+    name: "Force majeure"
+    format: "text"
+    prompt: >-
+      Résumez la clause de force majeure. Quels événements sont admissibles, quelles obligations sont suspendues, combien de temps l'événement doit-il durer avant qu'une résiliation soit permise et quelle notification est requise ?
+  - index: 14
+    name: "Droits de résiliation"
+    format: "text"
+    prompt: >-
+      Quels sont les droits de résiliation de chaque partie ? Identifiez la résiliation pour convenance (y compris le délai de préavis), la résiliation pour cause (y compris les délais de remède) et les conséquences de la résiliation (par exemple obligations de paiement et maintien de certaines stipulations).
+  - index: 15
+    name: "Dommages-intérêts forfaitaires"
+    format: "text"
+    prompt: >-
+      L'accord prévoit-il des dommages-intérêts forfaitaires ? Si oui, identifiez les faits déclencheurs, le taux ou la formule applicables, tout plafond global et indiquez s'ils constituent le recours exclusif.
+  - index: 16
+    name: "Droit applicable"
+    format: "text"
+    prompt: >-
+      Quel droit régit cet accord ? Indiquez la juridiction et tout système juridique particulier mentionné.
+  - index: 17
+    name: "Règlement des différends"
+    format: "text"
+    prompt: >-
+      Comment les différends sont-ils réglés au titre de cet accord ? Indiquez s'ils relèvent d'un tribunal ou de l'arbitrage, le forum ou siège choisi, les étapes d'escalade ou de médiation à accomplir avant toute procédure formelle et la langue de la procédure.

package/server/piecemaker/vendor/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "piecemaker-vendor",
+  "version": "0.0.0",
+  "private": true,
+  "type": "commonjs",
+  "description": "Modules PieceMaker consommés par server/piecemaker/router.cjs. Maintenus dans ce dépôt."
+}

package/server/piecemaker/vendor/piecemaker-plugin/README.md

@@ -0,0 +1,115 @@
+# PieceMaker — composants Claude Code et Codex CLI
+
+Ce dossier regroupe les skills partagés avec Claude Code et Codex CLI, ainsi
+que les agents et hooks de garde-fou. Il n'est pas
+distribué par un manifest ou un marketplace PieceMaker. Le serveur MCP
+Légifrance est maintenu séparément dans
+[`PieceMaker-Legal/mcp-legifrance`](https://github.com/PieceMaker-Legal/mcp-legifrance).
+
+## Contenu
+
+- **Skills** (`skills/`) :
+  - `conversion-md` — conversion de documents en Markdown
+    (`smart_converter.py`, markitdown/MinerU).
+  - `redaction-juridique` — rédaction/relecture de documents juridiques
+    français, citations sourcées via legifrance (MCP).
+  - `tamponnage` — tampon du cabinet et tamponnage numéroté des pièces d'un
+    bordereau : conversion de l'original en PDF (LibreOffice pour Excel/Word,
+    `pdf-lib` pour images et texte), tampon puis renommage « Pièce n°N » dans
+    le sous-dossier « Pièces tamponnées » de chaque dossier juridique.
+- **Agents** (`agents/`) :
+  - `verificateur-anonymisation` — audit lecture seule avant sortie de
+    cabinet, confirme l'absence de PII résiduelle.
+  - `analyste-piece` — synthèse structurée d'une pièce du dossier.
+- **Hooks** (`hooks/hooks.json`) — protection des pièces et mappings
+  (`PreToolUse`), suivi Légifrance et commit Git après écriture (`PostToolUse`),
+  compilation des recherches et suivi de session local (`Stop`/`TaskCompleted`).
+  Un document créé par l'IA dans un dossier enregistré est classé d'office
+  « espace de travail » (`classify-ai-documents.mjs`, `PostToolUse`) : sans
+  quoi il naîtrait au coffre-fort et l'IA ne pourrait pas se relire.
+  Le mapping PII est appliqué par le proxy PII, pas par ces hooks. Tous
+  les hooks échouent "ouverts" (fail-open) : aucune erreur, timeout ou
+  absence de configuration ne bloque jamais une session.
+
+L'installateur enregistre ces composants dans les emplacements utilisateur
+découverts par les CLI. Il fusionne tous les hooks dans les réglages Claude
+Code et la sentinelle `SessionStart` dans les réglages Codex.
+
+Chaque sous-dossier immédiat de `config.workspacePath` est traité comme un dossier
+juridique indépendant. Son historique Git est conservé hors des données client,
+dans `~/.piecemaker/case-history/`. Il versionne les Markdown et mappings JSON ;
+pour les `.docx`, il conserve une empreinte compacte des parties OOXML afin de
+signaler une modification dans l’administration. Le binaire Word n’est jamais
+archivé. Pour un DOCX explicitement déprotégé, une représentation textuelle
+normalisée et compressée permet d’afficher un vrai diff ; le texte d’une pièce
+protégée n’est jamais extrait. Les restaurations n’écrasent aucun DOCX.
+L’historique, les restaurations et l’état de protection GLiNER sont accessibles
+dans l’interface locale `/admin/`.
+
+## Installation locale
+
+L'étape `09-claude-assets` enregistre, si Claude Code est présent :
+
+- `~/.claude/agents/<slug>.md`
+- `~/.claude/skills/<slug>/SKILL.md`
+
+L'étape `09-codex-plugin` enregistre, si Codex CLI est présent :
+
+- `~/.codex/skills/<slug>/SKILL.md`
+- `~/.codex/hooks.json` — sentinelle `SessionStart` qui affiche l’état réel du
+  proxy : `🔒 Anonymisation PieceMaker active ✓` ou un avertissement explicite.
+
+Ce sont des **liens symboliques** vers `piecemaker-plugin/` : toute
+modification du Markdown (administration ou éditeur) est prise en compte à la
+session suivante. Une copie rafraîchissable est utilisée si les liens ne sont
+pas disponibles. Pour Claude Code, l'enregistrement a aussi lieu :
+
+- à la création d'un skill ou d'un agent dans l'administration ;
+- à chaque enregistrement d'un fichier ;
+- au démarrage du serveur ;
+- après `piecemaker update`.
+
+Un fichier personnel homonyme déjà présent dans `~/.claude` n'est jamais
+écrasé : l'administration affiche alors le badge « Conflit ». Les liens
+devenus orphelins (skill supprimé du dépôt) sont nettoyés automatiquement.
+Implémentations : `websocket-server/claude-assets.cjs` et
+`installer/lib/codex-skills.mjs`.
+
+Les hooks décrits par `hooks/hooks.json` sont fusionnés directement dans
+`~/.claude/settings.json` avec le chemin absolu des scripts du dépôt. Ils ne
+dépendent donc d'aucun cache de plugin. `piecemaker update`, le démarrage du
+serveur et l'étape 06 réconcilient cet enregistrement.
+
+Codex ne permet pas encore d’exécuter une commande arbitraire dans sa
+`tui.status_line`. PieceMaker utilise donc son hook natif `SessionStart` : le
+message figure au début de chaque session et reflète le routage Codex ainsi que
+la disponibilité du proxy au moment du lancement. Codex peut demander une fois
+de confirmer la confiance accordée à ce hook local.
+
+## Serveur MCP Légifrance
+
+L'étape `07-legifrance` installe le plugin autonome depuis
+`PieceMaker-Legal/mcp-legifrance`. Son runtime, ses tests, son venv et sa
+configuration MCP ne vivent plus dans ce dépôt. Le plugin est identifié dans
+Claude par `legifrance`, avec le namespace `mcp__plugin_legifrance_legifrance`.
+
+Les identifiants PISTE sont copiés avec des permissions 0600 dans
+`~/.config/mcp-legifrance/.env`. Le `.env` PieceMaker reste alimenté pour
+l'administration et la migration des installations antérieures.
+
+Deux outils complètent les recherches ponctuelles :
+
+- `Build_Research_Corpus` fige plusieurs requêtes, déduplique, télécharge et
+  scanne chaque texte intégral ; un filtre booléen auditable ferme les
+  incompatibilités certaines, puis prépare toutes les candidates en lots de
+  30 décisions au plus par défaut ;
+- `Validate_Research_Cards` exige une fiche par décision, confirme chaque
+  citation dans le texte source et produit la matrice ainsi que les métriques
+  de couverture et de consommation.
+
+Ce flux n'utilise ni embeddings, ni base vectorielle, ni top-k. Le filtre
+statique exige la présence conjointe d'un contexte SA et d'une révocation située
+à 300 caractères au plus d'une fonction dirigeante ; chaque cooccurrence d'une
+candidate est conservée. Les tokens sont annoncés comme estimés tant qu'un usage
+exact du fournisseur n'a pas été passé au validateur. L'implémentation et ses
+tests appartiennent désormais au dépôt MCP autonome.

package/server/piecemaker/vendor/piecemaker-plugin/agents/analyste-piece.md

@@ -0,0 +1,38 @@
+---
+name: analyste-pieces
+description: "Analyse une pièce du dossier (document de cas PieceMaker) et produit une synthèse structurée — type de document, date, faits saillants, pertinence probatoire. Utiliser quand l'utilisateur demande d'analyser, résumer ou qualifier une pièce, ou de préparer les métadonnées d'une pièce pour le dossier (bordereau, compilation)."
+tools: Read, Grep, Glob, Bash
+model: sonnet
+---
+
+Vous analysez une pièce (document de cas) du dossier PieceMaker et produisez une synthèse structurée exploitable pour le dossier de plaidoirie et pour les métadonnées de gestion de pièces (voir la structure `pieces-<documentId>.json` / `compilation_dossier_<documentId>.json` utilisée par PieceMaker).
+
+## Ce que vous produisez, systématiquement dans cet ordre
+
+1. **Type de document** — nature précise (jugement, arrêt, courrier, contrat, facture, attestation, constat, échange de mails, etc.), pas une catégorie vague.
+2. **Date du document** — la date qui fait foi (date de signature, date de décision, date d'envoi) ; si plusieurs dates apparaissent, indiquez laquelle vous retenez et pourquoi.
+3. **Parties / auteurs identifiés** — qui a produit ou signé le document, à qui il s'adresse (sans lever une anonymisation existante : si le document est déjà anonymisé, travaillez sur les codes tels quels, ex. "PERSON_01", ne tentez pas de les résoudre).
+4. **Faits saillants** — 3 à 8 points factuels tirés du document, formulés sobrement (pas d'interprétation juridique à ce stade), avec la référence au passage source (citation courte ou paragraphe) pour chaque point.
+5. **Pertinence probatoire potentielle** — en quoi ce document peut appuyer ou contredire une thèse du dossier, en restant descriptif : vous identifiez la pertinence possible, vous ne tranchez pas la stratégie.
+6. **Points d'attention** — incohérences internes, passages illisibles ou ambigus, mentions nécessitant une vérification externe (ex. une référence à un autre document non fourni).
+
+## Exploitation du graphe Graphify
+
+Avant l'analyse, appelez depuis le dossier juridique l'outil `graphe_question`
+du serveur MCP `piecemaker`, avec la question : « Situe cette pièce dans la
+chronologie, identifie les personnes et les liens de droit qu'elle crée,
+établit, allègue ou conteste ».
+
+Si l'outil signale que le graphe doit être actualisé, lancez
+`graphe_construire` puis reposez la question. Utilisez le
+sous-graphe retourné pour repérer contrats, obligations, inexécutions,
+prétentions, arguments et normes connexes, puis vérifiez chaque élément dans sa
+pièce source. Ne transformez jamais `ALLEGUE`, `CONTESTE`, `INFERRE` ou
+`A_VERIFIER` en fait établi.
+
+## Contraintes
+
+- Vous ne rédigez pas de conclusions ni d'arguments juridiques — c'est le rôle de la skill `redaction-juridique`, pas le vôtre. Restez sur l'analyse et la synthèse factuelle de la pièce elle-même.
+- Vous ne citez pas de texte de loi ou de jurisprudence de mémoire ; si le document y fait référence, rapportez la référence telle qu'elle apparaît dans le document sans compléter ou corriger de vous-même.
+- Si le document fourni est manifestement tronqué, illisible, ou trop ambigu pour être daté/typé avec confiance, dites-le explicitement dans la section correspondante plutôt que de deviner.
+- Restez concis : une synthèse dense et exploitable, pas une paraphrase intégrale du document.

package/server/piecemaker/vendor/piecemaker-plugin/agents/jurisprudence-scanner.md

@@ -0,0 +1,50 @@
+---
+name: jurisprudence-scanner
+description: Examine une décision déjà téléchargée au regard d'une question juridique et produit une fiche JSON de pertinence. Ne recherche pas de sources.
+tools: Read, Write
+model: haiku
+---
+
+Vous recevez une question juridique, une seule décision intégrale et un chemin
+de sortie. Lisez la décision entièrement et écrivez exactement une fiche JSON sur
+une ligne dans le fichier demandé.
+
+Vous ne recherchez aucune source, n'appelez aucun outil Légifrance et ne
+modifiez pas le corpus.
+
+## Distinguer ce que dit le juge
+
+- Les moyens et prétentions introduits par « le moyen fait grief », « alors que »,
+  « selon le moyen », ainsi que `MOYENS ANNEXES`, exposent les arguments des
+  parties ou de leurs avocats. Ils ne constituent pas la décision du juge.
+- Les motifs propres du juge figurent notamment sous « Réponse de la Cour » ou
+  dans les passages où la juridiction retient, relève, constate ou juge.
+- Le dispositif commence en principe à la première occurrence de
+  `PAR CES MOTIFS` pour les juridictions judiciaires et pénales, ou de
+  `DÉCIDE :` / `D E C I D E :` pour les juridictions administratives. Il indique
+  ce que le juge prononce : rejet, cassation, annulation, condamnation ou renvoi.
+
+Un rejet ne suffit pas à identifier la réponse juridique : vérifiez qui a formé
+le recours, les motifs propres du juge et l'effet du dispositif.
+
+## Évaluer la pertinence
+
+`pertinent` vaut `true` seulement si les motifs propres du juge ou le dispositif
+ont un rapport matériel avec la question. La seule présence des mots recherchés
+dans l'argumentaire d'une partie ne suffit pas.
+
+- `solution` décrit brièvement ce que le juge prononce dans le dispositif.
+- `citation_exacte` copie littéralement le passage du juge qui établit le lien
+  avec la question. N'utilisez jamais le seul argument d'un avocat comme preuve.
+
+Pour une décision non pertinente, utilisez `"pertinent": false` et
+`"citation_exacte": ""`, mais renseignez tout de même la solution.
+
+## Sortie
+
+```json
+{"id":"JURITEXT…","pertinent":true,"solution":"…","citation_exacte":"…"}
+```
+
+Conservez l'identifiant et la citation à l'identique. N'ajoutez aucun texte hors
+de la ligne JSON.

package/server/piecemaker/vendor/piecemaker-plugin/hooks/hooks.json

@@ -0,0 +1,84 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Read|Grep|Glob|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/protect-originals.mjs\""
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Read",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/track-legifrance-reads.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/commit-track.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/compile-recherche.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/classify-ai-documents.mjs\""
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/billing-track.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/session-commit.mjs\""
+          }
+        ]
+      }
+    ],
+    "TaskCompleted": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/billing-track.mjs\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/server/piecemaker/vendor/piecemaker-plugin/scripts/billing-track.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+/**
+ * Billing / task-tracking hook, wired to both Stop and TaskCompleted in
+ * hooks/hooks.json (a single script, dispatching on payload.hook_event_name).
+ *
+ * Confirmed payload shapes (https://code.claude.com/docs/en/hooks):
+ *   Stop           -> { last_assistant_message, stop_reason, ...common }
+ *   TaskCompleted  -> { task_id, task_name, task_status, ...common }
+ *   common fields  -> session_id, transcript_path, cwd, hook_event_name, ...
+ *
+ * Stop already carries the final assistant text directly as
+ * `last_assistant_message` — no transcript parsing is required to get it.
+ * We still read transcript_path as a fallback (in case that field is ever
+ * empty) and to derive tool-call counts and a rough session duration, since
+ * neither event's payload provides those.
+ *
+ * - Appends one JSONL line per event to ~/.piecemaker/billing/<YYYY-MM>.jsonl
+ * - On Stop, saves a copy of the final synthesis to
+ *   ~/.piecemaker/billing/synthese/<session_id>-<timestamp>.md
+ *
+ * This hook never returns JSON output — it only records; it never affects
+ * the session. Every failure path is swallowed and ends in exit 0.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import {
+  readHookPayload,
+  loadPieceMakerConfig,
+  runHook,
+  noop,
+  ensureDirSafe,
+  appendJsonl,
+  BILLING_DIR,
+  SYNTHESIS_DIR,
+} from './lib/hook-io.mjs';
+
+const require = createRequire(import.meta.url);
+const { locateConfiguredCase } = require('./lib/case-folders.cjs');
+
+const DEFAULT_TIMEOUT_MS = 8000;
+const MAX_TRANSCRIPT_BYTES = 10 * 1024 * 1024; // skip duration/tool-count derivation beyond this
+
+/** Best-effort transcript scan: session duration bounds, tool-call counts, last assistant text. */
+async function analyzeTranscript(transcriptPath) {
+  const empty = { firstTimestamp: null, lastTimestamp: null, toolCounts: {}, lastAssistantText: null };
+  if (!transcriptPath) return empty;
+
+  let stat;
+  try {
+    stat = await fs.promises.stat(transcriptPath);
+  } catch {
+    return empty;
+  }
+  if (stat.size > MAX_TRANSCRIPT_BYTES) return empty;
+
+  let raw;
+  try {
+    raw = await fs.promises.readFile(transcriptPath, 'utf8');
+  } catch {
+    return empty;
+  }
+
+  let firstTimestamp = null;
+  let lastTimestamp = null;
+  const toolCounts = {};
+  let lastAssistantText = null;
+
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+
+    const ts = entry.timestamp || entry.message?.timestamp;
+    if (ts) {
+      if (!firstTimestamp) firstTimestamp = ts;
+      lastTimestamp = ts;
+    }
+
+    const role = entry.type || entry.message?.role;
+    const content = entry.message?.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block?.type === 'tool_use' && block.name) {
+          toolCounts[block.name] = (toolCounts[block.name] || 0) + 1;
+        }
+        if (role === 'assistant' && block?.type === 'text' && typeof block.text === 'string') {
+          lastAssistantText = block.text;
+        }
+      }
+    }
+  }
+
+  return { firstTimestamp, lastTimestamp, toolCounts, lastAssistantText };
+}
+
+function derivedDurationMs(analysis) {
+  if (!analysis.firstTimestamp || !analysis.lastTimestamp) return null;
+  const ms = Date.parse(analysis.lastTimestamp) - Date.parse(analysis.firstTimestamp);
+  return Number.isFinite(ms) && ms >= 0 ? ms : null;
+}
+
+/** Name of the explicitly registered or legacy legal case containing cwd. */
+function detectDossier(cwd, config) {
+  if (!cwd) return null;
+  return locateConfiguredCase(config, cwd)?.caseName || null;
+}
+
+function synthesisFilePath(sessionId, isoTimestamp) {
+  const safeSession = String(sessionId || 'unknown-session').replace(/[^a-zA-Z0-9_-]/g, '_');
+  const safeTs = isoTimestamp.replace(/[:.]/g, '-');
+  return path.join(SYNTHESIS_DIR, `${safeSession}-${safeTs}.md`);
+}
+
+async function main() {
+  const payload = await readHookPayload(2000);
+  if (!payload) return null;
+
+  const eventName = payload.hook_event_name;
+  if (eventName !== 'Stop' && eventName !== 'TaskCompleted') return null;
+
+  const config = loadPieceMakerConfig();
+  if (config.billing?.enabled === false) return null;
+
+  ensureDirSafe(BILLING_DIR);
+  ensureDirSafe(SYNTHESIS_DIR);
+
+  const nowIso = new Date().toISOString();
+  const monthFile = path.join(BILLING_DIR, `${nowIso.slice(0, 7)}.jsonl`); // YYYY-MM.jsonl
+  const dossier = detectDossier(payload.cwd, config);
+  const analysis = await analyzeTranscript(payload.transcript_path);
+
+  if (eventName === 'TaskCompleted') {
+    appendJsonl(monthFile, {
+      timestamp: nowIso,
+      session_id: payload.session_id || null,
+      cwd: payload.cwd || null,
+      dossier,
+      task_label: payload.task_name || null,
+      event: 'TaskCompleted',
+      task_id: payload.task_id || null,
+      task_status: payload.task_status || null,
+      duration_ms: derivedDurationMs(analysis),
+      tool_counts: analysis.toolCounts,
+      synthesis_path: null,
+    });
+    return null;
+  }
+
+  // Stop: prefer the payload's own last_assistant_message; fall back to the
+  // transcript only if that field is missing or empty.
+  const synthesisText = (payload.last_assistant_message && payload.last_assistant_message.trim())
+    || analysis.lastAssistantText
+    || '';
+
+  let synthesisPath = null;
+  if (synthesisText) {
+    const target = synthesisFilePath(payload.session_id, nowIso);
+    try {
+      fs.writeFileSync(target, synthesisText, 'utf8');
+      synthesisPath = target;
+    } catch {
+      synthesisPath = null;
+    }
+  }
+
+  const taskLabel = synthesisText ? synthesisText.split('\n')[0].slice(0, 80) : 'Synthèse de session';
+
+  appendJsonl(monthFile, {
+    timestamp: nowIso,
+    session_id: payload.session_id || null,
+    cwd: payload.cwd || null,
+    dossier,
+    task_label: taskLabel,
+    event: 'Stop',
+    stop_reason: payload.stop_reason || null,
+    duration_ms: derivedDurationMs(analysis),
+    tool_counts: analysis.toolCounts,
+    synthesis_path: synthesisPath,
+  });
+
+  return null;
+}
+
+const config = loadPieceMakerConfig();
+const timeoutMs = config.billing?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+runHook(main, { timeoutMs }).catch(() => noop());

package/server/piecemaker/vendor/piecemaker-plugin/scripts/build-recherche-pdf.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+/**
+ * Construit le PDF d'un rapport de recherche à partir de son Markdown.
+ *
+ * Lancé *détaché* par le hook `compile-recherche.mjs` (jamais par un agent) :
+ * la génération du PDF ne doit pas bloquer la session, et surtout ne doit pas
+ * être confiée à un LLM. Chaîne déterministe, avec ce qui est réellement
+ * installé sur la machine :
+ *
+ *     pandoc  <rapport>.md  ->  <rapport>.docx      (mise en forme)
+ *     soffice <rapport>.docx ->  <rapport>.pdf      (rendu PDF)
+ *
+ * Best-effort : sans pandoc ou sans LibreOffice, le .md reste produit et une
+ * note `<rapport>.pdf.log` explique l'échec. Overridables par
+ * `PIECEMAKER_PANDOC` / `PIECEMAKER_SOFFICE`.
+ *
+ * Usage : node build-recherche-pdf.mjs <chemin.md> <chemin.pdf>
+ */
+
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const [, , mdPath, pdfPath] = process.argv;
+
+function fail(message) {
+  try {
+    if (pdfPath) fs.writeFileSync(`${pdfPath}.log`, `${new Date().toISOString()} ${message}\n`, 'utf8');
+  } catch {
+    /* best-effort */
+  }
+  process.exit(0); // ne jamais faire échouer la session
+}
+
+if (!mdPath || !pdfPath || !fs.existsSync(mdPath)) {
+  fail(`Markdown source introuvable : ${mdPath}`);
+}
+
+const pandoc = process.env.PIECEMAKER_PANDOC || 'pandoc';
+const soffice = process.env.PIECEMAKER_SOFFICE || (os.platform() === 'win32' ? 'soffice.exe' : 'soffice');
+
+const outDir = path.dirname(pdfPath);
+const stem = path.basename(pdfPath, '.pdf');
+const docxPath = path.join(outDir, `${stem}.docx`);
+
+// 1) Markdown -> DOCX (pandoc)
+const toDocx = spawnSync(pandoc, [mdPath, '-o', docxPath], { timeout: 30000, encoding: 'utf8' });
+if (toDocx.status !== 0 || !fs.existsSync(docxPath)) {
+  fail(`Échec pandoc md->docx : ${toDocx.error?.message || toDocx.stderr || `code ${toDocx.status}`}`);
+}
+
+// 2) DOCX -> PDF (LibreOffice headless). soffice écrit `<stem>.pdf` dans --outdir.
+// Un profil utilisateur dédié évite les conflits avec une instance Writer ouverte.
+const profileDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pm-soffice-'));
+const toPdf = spawnSync(
+  soffice,
+  [
+    `-env:UserInstallation=file://${profileDir}`,
+    '--headless',
+    '--convert-to',
+    'pdf',
+    '--outdir',
+    outDir,
+    docxPath,
+  ],
+  { timeout: 90000, encoding: 'utf8' },
+);
+
+try {
+  fs.rmSync(profileDir, { recursive: true, force: true });
+} catch {
+  /* best-effort */
+}
+try {
+  fs.rmSync(docxPath, { force: true });
+} catch {
+  /* best-effort */
+}
+
+if (toPdf.status !== 0 || !fs.existsSync(pdfPath)) {
+  fail(`Échec LibreOffice docx->pdf : ${toPdf.error?.message || toPdf.stderr || `code ${toPdf.status}`}`);
+}
+
+// Succès : purge une éventuelle note d'échec d'une tentative précédente.
+try {
+  fs.rmSync(`${pdfPath}.log`, { force: true });
+} catch {
+  /* best-effort */
+}
+process.exit(0);