@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/vendor/piecemaker-plugin/scripts/protect-originals.mjs

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+/**
+ * PreToolUse hook — frontière dure autour des pièces protégées d'un dossier.
+ *
+ * La protection est une propriété du fichier, décidée dans l'administration et
+ * stockée dans `<dossier>/.piecemaker/protection.json` (voir `lib/protection.cjs`).
+ * Elle ne dépend plus d'un sous-dossier « Pièces originales » : un cabinet range
+ * ses pièces à plat, à côté du Markdown qu'il en tire, et cette organisation-là
+ * ne protégeait rien.
+ *
+ * Un refus renvoie systématiquement vers le Markdown converti, qui est la
+ * surface que l'IA a le droit de lire — anonymisée par le proxy PII avant
+ * l'appel au fournisseur.
+ *
+ * Bash est traité comme les outils de lecture. C'est indispensable depuis que
+ * le skill `docx-cli` est disponible : il travaille par le binaire `docx`
+ * (`docx read pièce.docx`, `docx find`…), qui contournerait entièrement un
+ * garde-fou limité à Read/Grep/Glob.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { loadPieceMakerConfig, readHookPayload, runHook, noop } from './lib/hook-io.mjs';
+
+const require = createRequire(import.meta.url);
+const { locateConfiguredCase } = require('./lib/case-folders.cjs');
+const { caseHasMapping } = require('./lib/mapping.cjs');
+const {
+  isMappingFile,
+  isSecretFile,
+  isProtectedFile,
+  markdownCounterpart,
+  readProtection,
+  relativeKey,
+  READABLE_EXTENSIONS,
+} = require('./lib/protection.cjs');
+
+/** Au-delà, on ne cherche pas de chemin : une commande pareille n'en cite pas un. */
+const MAX_COMMAND_LENGTH = 20_000;
+
+function deny(reason) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: reason,
+    },
+    systemMessage: reason,
+  };
+}
+
+/**
+ * Message de refus. Il doit rester actionnable : sans indication du Markdown à
+ * lire, l'agent réessaie le même chemin sous une autre forme.
+ */
+function protectionReason(absolute, caseRoot) {
+  const counterpart = markdownCounterpart(absolute, caseRoot);
+  const head = `[PieceMaker] « ${path.basename(absolute)} » est une pièce protégée : son contenu original n’est pas accessible à l’IA.`;
+  return counterpart.exists
+    ? `${head} Lisez le Markdown anonymisé à la place : ${counterpart.path}`
+    : `${head} Aucun Markdown n’a encore été produit pour cette pièce — lancez « Convertir en Markdown » dans l’administration PieceMaker, ou retirez sa protection si elle n’en a pas besoin.`;
+}
+
+/**
+ * Le mapping et les scans PII sont hors d'atteinte, sans exception possible : le
+ * mapping donne le nom réel derrière chaque code, un scan porte les entités en
+ * clair. Une seule lecture annulerait toute la frontière — et ce refus-ci ne
+ * renvoie vers rien, il n'existe pas de version anonymisée de ces fichiers.
+ * L'administration y accède par ses propres routes, qui ne passent pas par les hooks.
+ */
+function mappingReason(absolute) {
+  return `[PieceMaker] « ${path.basename(absolute)} » est le mapping d’anonymisation du dossier (ou un scan PII) : il n’est jamais accessible à l’IA. Consultez-le depuis l’administration PieceMaker si besoin.`;
+}
+
+/**
+ * Refus des secrets d'environnement. Comme le mapping, ils ne renvoient vers
+ * rien : il n'existe pas de version anonymisée d'une clé d'API.
+ */
+function secretReason(absolute) {
+  return `[PieceMaker] « ${path.basename(absolute)} » est un fichier de secrets d’environnement : il n’est jamais accessible à l’IA.`;
+}
+
+/**
+ * Refus « dossier non anonymisé ». Sans `mapping_default.json`, le proxy n'a
+ * rien à coder : lire une pièce livrerait des données personnelles en clair.
+ * On l'explique synthétiquement au modèle, avec l'action qui débloque la lecture.
+ */
+function missingMappingReason(caseName) {
+  return `[PieceMaker] « ${caseName} » est un dossier PieceMaker sans mapping d’anonymisation (mapping_default.json absent) : sa lecture est bloquée car son contenu n’est pas encore anonymisable et partirait en clair. Lancez l’anonymisation du dossier dans l’administration PieceMaker avant toute lecture.`;
+}
+
+/**
+ * Surface lisible dont le contenu serait normalement codé à la lecture (`.md`,
+ * `.json` de pièce) : c'est précisément ce que `missingMappingReason` doit
+ * protéger quand aucun mapping n'existe. On écarte les originaux (déjà refusés
+ * par `isProtectedFile`), le mapping et les scans (refusés à part), la
+ * configuration du dossier (`.piecemaker/…`, dotfiles) et les consignes
+ * structurelles `CLAUDE.md`/`AGENTS.md` — jamais des pièces, et l'assistant du
+ * dossier doit pouvoir charger sa consigne même avant anonymisation.
+ */
+function isReadableCaseSurface(absolute, caseRoot) {
+  const stat = statSafe(absolute);
+  if (!stat || stat.isDirectory()) return false;
+  const key = relativeKey(absolute, caseRoot);
+  if (!key) return false;
+  if (key.split('/').some((segment) => segment.startsWith('.'))) return false;
+  if (!READABLE_EXTENSIONS.has(path.extname(key).toLowerCase())) return false;
+  if (isMappingFile(absolute)) return false;
+  const base = path.basename(key);
+  return base !== 'CLAUDE.md' && base !== 'AGENTS.md';
+}
+
+function statSafe(target) {
+  try {
+    return fs.statSync(target);
+  } catch {
+    return null;
+  }
+}
+
+function absolutePath(value, cwd) {
+  if (!value) return null;
+  const raw = String(value);
+  if (!raw) return null;
+  return path.isAbsolute(raw) ? path.resolve(raw) : path.resolve(cwd, raw);
+}
+
+/**
+ * Chemins cités par une commande shell. On ne cherche pas à parser le shell :
+ * chaque mot (guillemets respectés) est un candidat, et seuls ceux qui tombent
+ * sur un fichier protégé d'un dossier juridique comptent. Un faux positif est
+ * impossible — il faudrait que le mot désigne réellement une pièce protégée.
+ */
+function commandPaths(command, cwd) {
+  const text = String(command || '');
+  if (!text || text.length > MAX_COMMAND_LENGTH) return [];
+  const candidates = new Set();
+  const tokens = text.match(/"[^"]*"|'[^']*'|[^\s;|&<>()]+/g) || [];
+  for (const token of tokens) {
+    const bare = token.replace(/^["']|["']$/g, '');
+    if (!bare || bare.startsWith('-')) continue;
+    candidates.add(bare);
+    // `--input=/chemin/piece.pdf`, `of=piece.docx` : la valeur est le chemin.
+    const equals = bare.indexOf('=');
+    if (equals > 0 && equals < bare.length - 1) candidates.add(bare.slice(equals + 1));
+  }
+  // Seuls les mots qui désignent un fichier réellement présent comptent :
+  // sans ce filtre, `pandoc` lui-même se résout en `<dossier>/pandoc`, un
+  // chemin sans extension donc « protégé », et toute commande était refusée.
+  return [...candidates]
+    .map((candidate) => absolutePath(candidate, cwd))
+    .filter((candidate) => candidate && statSafe(candidate)?.isFile());
+}
+
+/**
+ * Un `Grep`/`Glob` lancé à la racine d'un dossier juridique parcourt les pièces
+ * protégées et en ramène des extraits. On refuse à la première pièce protégée
+ * rencontrée plutôt que de filtrer les résultats un à un.
+ */
+function isBroadCaseSearch(located) {
+  if (!located) return false;
+  // `located.absolute` est déjà passé par realpath, `caseRoot` aussi : comparer
+  // un `path.resolve(target)` brut ne recouvrait jamais la racine sur macOS
+  // (`/var/…` contre `/private/var/…`), et la recherche large passait toujours.
+  if (located.absolute !== located.caseRoot) return false;
+  const protection = readProtection(located.caseRoot);
+  try {
+    return fs.readdirSync(located.caseRoot, { withFileTypes: true })
+      .some((entry) => entry.isFile()
+        && isProtectedFile(path.join(located.caseRoot, entry.name), located.caseRoot, protection));
+  } catch {
+    // Dossier illisible : on refuse, faute de pouvoir prouver qu'il est sûr.
+    return true;
+  }
+}
+
+/** Le répertoire visé est la racine du dossier et un mapping y est posé. */
+function caseRootHasMapping(located) {
+  if (!located) return false;
+  if (located.absolute !== located.caseRoot) return false;
+  try {
+    return fs.readdirSync(located.caseRoot).some((name) => isMappingFile(name));
+  } catch {
+    return true;
+  }
+}
+
+async function main() {
+  const payload = await readHookPayload(2000);
+  if (!payload) return null;
+  const config = loadPieceMakerConfig();
+
+  const toolName = payload.tool_name;
+  const cwd = payload.cwd || process.cwd();
+
+  if (toolName === 'Bash') {
+    for (const candidate of commandPaths(payload.tool_input?.command, cwd)) {
+      const located = locateConfiguredCase(config, candidate);
+      if (!located) continue;
+      if (isMappingFile(candidate)) return deny(mappingReason(candidate));
+      if (isSecretFile(candidate)) return deny(secretReason(candidate));
+      if (isProtectedFile(candidate, located.caseRoot)) {
+        return deny(protectionReason(candidate, located.caseRoot));
+      }
+      if (isReadableCaseSurface(candidate, located.caseRoot) && !caseHasMapping(located.caseRoot)) {
+        return deny(missingMappingReason(located.caseName));
+      }
+    }
+    return null;
+  }
+
+  if (!['Read', 'Grep', 'Glob'].includes(toolName)) return null;
+
+  const target = absolutePath(payload.tool_input?.file_path || payload.tool_input?.path, cwd);
+  if (!target) return null;
+  const located = locateConfiguredCase(config, target);
+  if (!located) return null;
+
+  // Un répertoire n'est pas une pièce : `Grep`/`Glob` en visent un couramment,
+  // et c'est `isBroadCaseSearch` qui décide s'il est sûr de le parcourir.
+  if (isMappingFile(target)) return deny(mappingReason(target));
+  if (isSecretFile(target)) return deny(secretReason(target));
+
+  const stat = statSafe(target);
+  if (!stat?.isDirectory() && isProtectedFile(target, located.caseRoot)) {
+    return deny(protectionReason(target, located.caseRoot));
+  }
+
+  // Dossier PieceMaker sans mapping : la garantie « anonymisé à la lecture »
+  // n'existe pas encore. Lire une surface lisible (`.md`/`.json` de pièce) la
+  // ferait sortir en clair, et un `Grep` récursif à la racine en ferait autant
+  // sur tout le dossier (un `Glob`, qui ne ramène que des noms, reste permis).
+  // On calcule l'absence de mapping au plus tard, une fois les refus francs
+  // (mapping, original) écartés — c'est le seul chemin qui paie la lecture du
+  // mapping.
+  if (isReadableCaseSurface(target, located.caseRoot) && !caseHasMapping(located.caseRoot)) {
+    return deny(missingMappingReason(located.caseName));
+  }
+  if (toolName === 'Grep' && located.absolute === located.caseRoot && !caseHasMapping(located.caseRoot)) {
+    return deny(missingMappingReason(located.caseName));
+  }
+
+  // Un `Grep` récursif ramène le *contenu* du mapping ; un `Glob` n'en ramène
+  // que le nom, qui ne trahit rien — d'où la restriction à Grep ici.
+  if (toolName === 'Grep' && caseRootHasMapping(located)) {
+    return deny(`[PieceMaker] Une recherche récursive à la racine de « ${located.caseName} » lirait le mapping d’anonymisation. Ciblez un fichier Markdown précis, ou un sous-dossier qui n’en contient pas.`);
+  }
+
+  if ((toolName === 'Grep' || toolName === 'Glob') && isBroadCaseSearch(located)) {
+    return deny(`[PieceMaker] Une recherche récursive à la racine de « ${located.caseName} » parcourrait des pièces protégées. Ciblez un fichier Markdown précis, ou un sous-dossier qui n’en contient pas.`);
+  }
+  return null;
+}
+
+runHook(main, { timeoutMs: 3000 }).catch(() => noop());

package/server/piecemaker/vendor/piecemaker-plugin/scripts/session-commit-worker.mjs

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+/**
+ * Worker détaché de l'auto-commit par tour.
+ *
+ * Lancé par `session-commit.mjs` (hook `Stop`) avec un unique argument : le
+ * chemin du fichier de spool. Tout le travail Git — potentiellement lent —
+ * vit ici, hors du tour de conversation :
+ *
+ *  - Le PÉRIMÈTRE du tour est l'union des dossiers de cas marqués pendant le
+ *    tour (`~/.piecemaker/pending/<session_id>.json`, écrit par
+ *    `commit-track.mjs` à chaque Write/Edit) et du dossier de cas contenant
+ *    `cwd` — ce second terme rattrape ce qui a changé sans passer par
+ *    Write/Edit (script, modification manuelle).
+ *  - Le MESSAGE de chaque commit est la conclusion de l'IA
+ *    (`last_assistant_message`), ré-identifiée via le mapping central puis
+ *    complétée d'un pied déterministe (fichiers modifiés, durée de session,
+ *    horodatage).
+ *  - `createCommit` ne crée jamais de commit vide : aucun pré-test de
+ *    propreté n'est fait ici.
+ *
+ * Le worker survit à la session qui l'a lancé : c'est voulu (`detached` +
+ * `unref()` côté hook). La concurrence entre workers d'un même dossier est
+ * déjà gérée par `withCaseLock` dans `createCommit`.
+ *
+ * Journal : ~/.piecemaker/auto-commit.log — seul témoin en cas d'échec, ce
+ * process n'a plus personne à qui remonter une erreur.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { HOME_DIR, loadPieceMakerConfig } from './lib/hook-io.mjs';
+
+const require = createRequire(import.meta.url);
+const { createCommit, worktreeDetails } = require('./lib/commits.cjs');
+const { locateConfiguredCase } = require('./lib/case-folders.cjs');
+const { revertMapping } = require('./lib/mapping.cjs');
+const { readCentralMapping } = require('./lib/central-mapping.cjs');
+const { sessionElapsedMs, formatDurationFr } = require('./lib/session-timing.cjs');
+
+const LOG_FILE = path.join(HOME_DIR, 'auto-commit.log');
+// Une ligne par commit de tour ou presque : 512 Ko couvrent des mois. Au-delà,
+// on bascule vers `.1` (une seule génération : le journal est un outil de
+// diagnostic, pas une archive) — même politique que session-autocommit.mjs.
+const MAX_LOG_BYTES = 512 * 1024;
+const PENDING_DIR = path.join(HOME_DIR, 'pending');
+const FALLBACK_LABEL = 'Modifications du tour';
+
+let logContext = '';
+
+/** Journalise sans jamais échouer : un worker muet ne doit pas mourir de son log. */
+function log(level, message, extra) {
+  try {
+    fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+    try {
+      if (fs.statSync(LOG_FILE).size > MAX_LOG_BYTES) fs.renameSync(LOG_FILE, `${LOG_FILE}.1`);
+    } catch { /* pas de journal existant, ou rotation impossible */ }
+    const details = extra ? ` ${JSON.stringify(extra)}` : '';
+    fs.appendFileSync(
+      LOG_FILE,
+      `${new Date().toISOString()} [${process.pid}] ${level} ${logContext}${message}${details}\n`,
+    );
+  } catch { /* fail-open : un journal indisponible n'empêche pas le commit */ }
+}
+
+/** Détail exploitable d'une erreur (le stderr git est porté sur `.stderr`). */
+function describeError(error) {
+  const stderr = (error?.stderr || '').toString().trim();
+  const base = error?.message || String(error);
+  return stderr ? `${base} | stderr: ${stderr}` : base;
+}
+
+function sanitizeSessionId(sessionId) {
+  return String(sessionId || 'unknown-session').replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+
+function readSpool(spoolFile) {
+  return JSON.parse(fs.readFileSync(spoolFile, 'utf8'));
+}
+
+/**
+ * Consomme le fichier pending de la session : les dossiers marqués pendant le
+ * tour par `commit-track.mjs`. Renommage avant lecture pour ne pas se
+ * disputer le fichier avec une écriture concurrente improbable ; le fichier
+ * renommé est supprimé après lecture (best-effort).
+ */
+function drainPendingCases(sessionId) {
+  const file = path.join(PENDING_DIR, `${sanitizeSessionId(sessionId)}.json`);
+  const staging = `${file}.${process.pid}.consuming`;
+  try {
+    fs.renameSync(file, staging);
+  } catch (error) {
+    if (error.code !== 'ENOENT') log('WARN', 'lecture du pending impossible', { file, error: describeError(error) });
+    return [];
+  }
+  let cases = [];
+  try {
+    const raw = fs.readFileSync(staging, 'utf8');
+    cases = raw.split('\n').map((line) => line.trim()).filter(Boolean).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((entry) => entry?.casesRoot && entry?.caseName);
+  } catch (error) {
+    log('WARN', 'pending illisible', { file: staging, error: describeError(error) });
+  } finally {
+    try { fs.unlinkSync(staging); } catch { /* best-effort */ }
+  }
+  return cases;
+}
+
+/** Retire les marqueurs Markdown de tête (titres, listes, citations, gras…). */
+function cleanMarkdownHeading(line) {
+  let text = String(line || '');
+  let previous;
+  do {
+    previous = text;
+    text = text.replace(/^\s*(?:#{1,6}|>{1,3}|[-*+•]{1,3}|`{1,3}|\*{1,3}|_{1,3})\s*/u, '');
+  } while (text !== previous && text.length);
+  return text.trim();
+}
+
+/** Première ligne (label) / reste (description) d'une conclusion d'IA. */
+function splitConclusion(text) {
+  if (!text || typeof text !== 'string') return { label: '', description: '' };
+  const normalized = text.replace(/\r\n/g, '\n').trim();
+  if (!normalized) return { label: '', description: '' };
+  const lines = normalized.split('\n');
+  return { label: lines[0] || '', description: lines.slice(1).join('\n').trim() };
+}
+
+/** Pied déterministe, une ligne : fichiers modifiés, durée de session, horodatage. */
+function buildFooter({ fileCount, durationMs, timestamp }) {
+  const bits = [];
+  if (Number.isFinite(fileCount)) {
+    bits.push(`${fileCount} fichier${fileCount > 1 ? 's' : ''} modifié${fileCount > 1 ? 's' : ''}`);
+  }
+  if (Number.isFinite(durationMs)) {
+    const human = formatDurationFr(durationMs);
+    if (human) bits.push(`durée de session ${human}`);
+  }
+  bits.push(timestamp);
+  return `— ${bits.join(' · ')}`;
+}
+
+async function commitScopeCase({ casesRoot, caseName }, { label, descriptionBody, sessionId, durationMs }) {
+  // Aperçu du nombre de fichiers modifiés pour le pied du message — avant le
+  // commit lui-même, qui a besoin du message complet. `createCommit` reste
+  // l'unique source de vérité sur ce qui est réellement commité : cet aperçu
+  // ne sert qu'à documenter le message, jamais à décider s'il faut committer.
+  let fileCount = null;
+  try {
+    const preview = await worktreeDetails(casesRoot, HOME_DIR, caseName);
+    fileCount = preview.filesCount;
+  } catch (error) {
+    log('WARN', 'aperçu des modifications indisponible', { caseName, error: describeError(error) });
+  }
+
+  const footer = buildFooter({ fileCount, durationMs, timestamp: new Date().toISOString() });
+  const description = descriptionBody ? `${descriptionBody}\n\n${footer}` : footer;
+
+  try {
+    const result = await createCommit({
+      casesRoot,
+      caseName,
+      homeDir: HOME_DIR,
+      label,
+      description,
+      paths: null, // arbre complet du dossier : tout ce qui a changé pendant le tour
+      sessionId,
+      durationMs,
+      event: 'Stop',
+      waitForLockMs: 10_000,
+    });
+    if (result?.skipped === 'busy') {
+      log('SKIP', 'verrou occupé, commit de tour abandonné', { caseName });
+    } else if (result?.created) {
+      log('OK', 'commit de tour créé', {
+        caseName,
+        commit: result.commit ? result.commit.slice(0, 12) : null,
+        files: result.files?.length ?? fileCount,
+      });
+    } else {
+      log('SKIP', 'rien à committer', { caseName });
+    }
+  } catch (error) {
+    log('ERROR', 'commit de tour échoué', { caseName, error: describeError(error) });
+  }
+}
+
+async function main() {
+  const spoolFile = process.argv[2];
+  if (!spoolFile) {
+    log('ERROR', 'aucun fichier de spool fourni');
+    return;
+  }
+
+  let spoolData;
+  try {
+    spoolData = readSpool(spoolFile);
+  } catch (error) {
+    log('ERROR', 'lecture du spool échouée', { spoolFile, error: describeError(error) });
+    return;
+  } finally {
+    // Le spool est un instantané transitoire : il a fait son office une fois lu.
+    try { fs.unlinkSync(spoolFile); } catch { /* best-effort */ }
+  }
+
+  logContext = spoolData.session_id ? `session=${spoolData.session_id} ` : '';
+  log('INFO', 'début du commit de tour', { cwd: spoolData.cwd });
+
+  const config = loadPieceMakerConfig();
+  if (config.commits?.enabled === false) {
+    log('SKIP', 'commits désactivés par la configuration');
+    return;
+  }
+
+  // Périmètre : dossiers marqués pendant le tour ∪ dossier de cas de cwd.
+  const scope = new Map();
+  for (const entry of drainPendingCases(spoolData.session_id)) {
+    scope.set(`${entry.casesRoot}${entry.caseName}`, { casesRoot: entry.casesRoot, caseName: entry.caseName });
+  }
+  if (spoolData.cwd) {
+    try {
+      const cwdCase = locateConfiguredCase(config, spoolData.cwd);
+      if (cwdCase) {
+        scope.set(`${cwdCase.casesRoot}${cwdCase.caseName}`, { casesRoot: cwdCase.casesRoot, caseName: cwdCase.caseName });
+      }
+    } catch (error) {
+      log('WARN', 'résolution du dossier courant impossible', { cwd: spoolData.cwd, error: describeError(error) });
+    }
+  }
+
+  if (!scope.size) {
+    log('SKIP', 'aucun dossier de cas dans le périmètre du tour');
+    return;
+  }
+
+  // Message de commit = la conclusion de l'IA, ré-identifiée avec le mapping
+  // central (le modèle n'a vu que des codes ; le cabinet ne voit que des noms).
+  const central = readCentralMapping();
+  const reverseMapping = central.reverse_mapping || {};
+  const { label: rawLabel, description: rawDescription } = splitConclusion(spoolData.last_assistant_message);
+  const revertedLabel = revertMapping(cleanMarkdownHeading(rawLabel), reverseMapping).trim();
+  const label = (revertedLabel || FALLBACK_LABEL).slice(0, 140);
+  const descriptionBody = revertMapping(rawDescription, reverseMapping).trim();
+  const durationMs = sessionElapsedMs(spoolData.transcript_path);
+
+  log('INFO', 'périmètre du tour établi', { cases: scope.size, label });
+
+  for (const entry of scope.values()) {
+    await commitScopeCase(entry, { label, descriptionBody, sessionId: spoolData.session_id, durationMs });
+  }
+}
+
+main().catch((error) => {
+  log('ERROR', 'échec inattendu du worker', { error: describeError(error) });
+});

package/server/piecemaker/vendor/piecemaker-plugin/scripts/session-commit.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/**
+ * Hook Stop — déclenche l'auto-commit par tour, sans rien coûter au tour.
+ *
+ * Ce script ne fait que déposer un instantané minimal du tour (session, cwd,
+ * transcript, conclusion de l'IA) dans le spool
+ * (`~/.piecemaker/spool/<session_id>-<horodatage>.json`), puis lance le
+ * worker détaché `session-commit-worker.mjs` qui fait tout le travail Git —
+ * comparer les arbres, ré-identifier la conclusion, écrire le commit — hors
+ * du tour (même motif de spawn détaché que `compile-recherche.mjs`).
+ *
+ * `Stop` refuse un code de sortie 2 : sur cet événement, un code 2 empêche
+ * Claude de s'arrêter et boucle la session. Ce hook sort donc TOUJOURS en 0 —
+ * fail-open intégral, toute exception est avalée (journalisée si possible).
+ * Objectif de latence : quelques millisecondes, jamais de `git` synchrone ici.
+ */
+
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  HOME_DIR,
+  noop,
+  readHookPayload,
+  runHook,
+} from './lib/hook-io.mjs';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const SPOOL_DIR = path.join(HOME_DIR, 'spool');
+const LOG_FILE = path.join(HOME_DIR, 'auto-commit.log');
+
+function sanitizeSessionId(sessionId) {
+  return String(sessionId || 'unknown-session').replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+
+/**
+ * Best-effort, jamais bloquant : une seule ligne append, pas de rotation ici
+ * (le worker détaché tient le journal complet, y compris sa rotation).
+ */
+function logFailure(message, error) {
+  try {
+    fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+    const detail = error ? ` ${String(error?.message || error)}` : '';
+    fs.appendFileSync(
+      LOG_FILE,
+      `${new Date().toISOString()} [${process.pid}] ERROR (session-commit) ${message}${detail}\n`,
+    );
+  } catch { /* fail-open : un journal indisponible ne doit rien bloquer */ }
+}
+
+async function main() {
+  const payload = await readHookPayload(2000);
+  if (!payload || payload.hook_event_name !== 'Stop') return null;
+
+  try {
+    fs.mkdirSync(SPOOL_DIR, { recursive: true });
+    const sessionId = sanitizeSessionId(payload.session_id);
+    const spoolFile = path.join(SPOOL_DIR, `${sessionId}-${Date.now()}.json`);
+    fs.writeFileSync(spoolFile, JSON.stringify({
+      session_id: payload.session_id || null,
+      cwd: payload.cwd || null,
+      transcript_path: payload.transcript_path || null,
+      last_assistant_message: payload.last_assistant_message || null,
+      ts: new Date().toISOString(),
+    }), 'utf8');
+
+    const workerPath = path.join(HERE, 'session-commit-worker.mjs');
+    const child = spawn(process.execPath, [workerPath, spoolFile], {
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.unref();
+  } catch (error) {
+    // Fail-open intégral : jamais de code 2 sur Stop, jamais d'exception qui
+    // remonte — au pire, ce tour n'aura pas de commit automatique.
+    logFailure('commit de tour non lancé', error);
+  }
+
+  return null;
+}
+
+runHook(main, { timeoutMs: 2000 }).catch(() => noop());