@piecemaker-legal/piecemaker 2.0.11 → 2.0.12

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

@@ -1,194 +0,0 @@
-#!/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 { locateProjectCase } = 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 project folder containing cwd. */
-function detectDossier(cwd) {
-  if (!cwd) return null;
-  return locateProjectCase(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);
-  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/commit-track.mjs

@@ -1,71 +0,0 @@
-#!/usr/bin/env node
-/**
- * PostToolUse hook — marque le dossier de cas touché par un Write/Edit.
- *
- * Ne commite plus rien lui-même (aucun appel git) : il note juste, pour la
- * session en cours, quel dossier de cas a bougé pendant CE tour, dans
- * `~/.piecemaker/pending/<session_id>.json`. Le hook `Stop`
- * (`session-commit.mjs`) déclenche à la fin du tour un worker détaché
- * (`session-commit-worker.mjs`) qui consomme ce fichier et fait le commit
- * réel — un seul commit par tour et par dossier, au lieu d'un commit par
- * Write/Edit.
- *
- * Chaque dossier de cas explicitement enregistré (et chaque enfant de
- * l'espace de travail historique) reste une affaire indépendante. Les pièces
- * originales ne sont ni ouvertes ni indexées ici.
- */
-
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import {
-  HOME_DIR,
-  appendJsonl,
-  loadPieceMakerConfig,
-  noop,
-  readHookPayload,
-  runHook,
-} from './lib/hook-io.mjs';
-
-const require = createRequire(import.meta.url);
-const { locateCaseFile } = require('./lib/commits.cjs');
-const { locateProjectCase } = require('./lib/case-folders.cjs');
-
-const PENDING_DIR = path.join(HOME_DIR, 'pending');
-
-function sanitizeSessionId(sessionId) {
-  return String(sessionId || 'unknown-session').replace(/[^a-zA-Z0-9_-]/g, '_');
-}
-
-async function main() {
-  const payload = await readHookPayload(2000);
-  if (!payload || !['Write', 'Edit'].includes(payload.tool_name)) return null;
-  if (payload.tool_response?.success === false) return null;
-
-  const config = loadPieceMakerConfig();
-  if (config.commits?.enabled === false) return null;
-
-  const cwd = payload.cwd || process.cwd();
-  const filePath = payload.tool_input?.file_path;
-  if (!filePath) return null;
-  const absolute = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-  let located;
-  try {
-    const configured = locateProjectCase(absolute);
-    if (!configured) return null;
-    located = locateCaseFile(configured.casesRoot, absolute);
-  } catch {
-    return null;
-  }
-  if (!located?.safe || located.protected) return null;
-
-  const pendingFile = path.join(PENDING_DIR, `${sanitizeSessionId(payload.session_id)}.json`);
-  appendJsonl(pendingFile, {
-    casesRoot: located.casesRoot,
-    caseName: located.name,
-    ts: new Date().toISOString(),
-  });
-  return null;
-}
-
-const timeoutMs = loadPieceMakerConfig().commits?.timeoutMs ?? 8000;
-runHook(main, { timeoutMs }).catch(() => noop());

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

@@ -1,260 +0,0 @@
-#!/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

@@ -1,83 +0,0 @@
-#!/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());