@piecemaker-legal/piecemaker 2.0.11 → 2.0.13

package/server/piecemaker/vendor/installer/bin/piecemaker.mjs

@@ -8,11 +8,6 @@
  *
  * Usage:
  *   piecemaker                 menu interactif
- *   piecemaker chronology      affiche la chronologie du dossier courant
- *   piecemaker chronology write --path <pièce> --correction-json <json>
- *                              crée une correction de chronologie pour une pièce
- *   piecemaker chronology edit --path <pièce> --correction-json <json>
- *                              modifie une correction de chronologie existante
  *   piecemaker conversion      convertit et pseudonymise les pièces manquantes
  *   piecemaker install         ouvre le menu des composants
  *   piecemaker doctor          diagnostic seul
@@ -33,16 +28,15 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { banner, title, log, write, blank, summary, spinner, badge, c } from '../lib/ui.mjs';
 import { select, confirm, multiSelect, pause, nonInteractive } from '../lib/prompt.mjs';
 import { GIT_REPO_ROOT, HOME_DIR, REPO_ROOT, commandExists, findPython } from '../lib/platform.mjs';
-import { COMMANDS, CHRONOLOGY_ACTIONS } from '../lib/commandes.mjs';
+import { COMMANDS } from '../lib/commandes.mjs';
 import { loadConfig, readEnv, markStep, loadState, CONFIG_FILE } from '../lib/state.mjs';
 import { scheduleStepResume, selectStepsToResume } from '../lib/resume-steps.mjs';
-import { appServerPort, readLocalScanJob, startLocalScan } from '../lib/conversion-client.mjs';
+import { adoptRunningServerPort, appServerPort, localServerReachable, readLocalScanJob, startLocalScan } from '../lib/conversion-client.mjs';
 import { checkForUpdate, updateRepository } from '../lib/service.mjs';
 
 const require = createRequire(import.meta.url);
 const CLAUDE_ASSETS_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/claude-assets.cjs');
 const CLAUDE_HOOKS_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/claude-hooks.cjs');
-const DOCUMENT_INDEX_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/document-index.cjs');
 const ORIGINALS_PIPELINE_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/originals-pipeline.cjs');
 const APP_CLI_LIB = path.join(GIT_REPO_ROOT, 'scripts', 'piecemaker', 'cli', 'lib');
 
@@ -129,11 +123,8 @@ function parseArgs(argv) {
     check: false,
     dryRun: false,
     conversionDocuments: [],
-    correctionJson: null,
     force: false,
-    chronologyAction: 'read',
     json: false,
-    piecePath: null,
     resumeSteps: null,
     step: null,
     yes: false,
@@ -142,18 +133,13 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (!arg.startsWith('-') && !flags.command && COMMANDS.has(arg)) flags.command = arg;
-    else if (!arg.startsWith('-') && flags.command === 'chronology' && flags.chronologyAction === 'read' && CHRONOLOGY_ACTIONS.has(arg)) flags.chronologyAction = arg;
-    else if (!arg.startsWith('-') && flags.command === 'chronology' && !flags.caseTarget) flags.caseTarget = arg;
     else if (!arg.startsWith('-') && flags.command === 'conversion') flags.conversionDocuments.push(arg);
     else if (arg === '--all') flags.all = true;
-    else if (arg === '--action') flags.chronologyAction = argv[++i];
     else if (arg === '--case') flags.caseTarget = argv[++i];
     else if (arg === '--check') flags.check = true;
-    else if (arg === '--correction-json') flags.correctionJson = argv[++i];
     else if (arg === '--dry-run') flags.dryRun = true;
     else if (arg === '--force') flags.force = true;
     else if (arg === '--json') flags.json = true;
-    else if (arg === '--path') flags.piecePath = argv[++i];
     else if (arg === '--yes' || arg === '-y') flags.yes = true;
     else if (arg === '--step') flags.step = argv[++i];
     else if (arg === '--resume-steps') {
@@ -313,20 +299,15 @@ async function runCheck(steps, ctx) {
 function printHelp() {
   write(`  ${c.bold('piecemaker')} — PieceMaker local`);
   blank();
-  write('  chronology [read]        affiche la chronologie pseudonymisée du dossier courant');
-  write('  chronology write --path <pièce> --correction-json <json>  crée une correction de chronologie');
-  write('  chronology edit --path <pièce> --correction-json <json>   modifie une correction existante');
   write('  conversion [pièce…] convertit et pseudonymise les pièces manquantes ou indiquées');
   write('  install         ouvre le menu d’installation/réparation');
   write('  doctor, check   diagnostic seul, n’installe rien');
   write('  update          met à jour PieceMaker');
   blank();
   write('  --all           installe tout sans menu');
-  write('  --case <chemin> cible un dossier enregistré (chronology/conversion)');
-  write('  --path <pièce>  chemin relatif de la pièce (chronology write/edit)');
-  write('  --correction-json <json> correction à appliquer (chronology write/edit)');
+  write('  --case <chemin> cible un dossier enregistré (conversion)');
   write('  --force         retraite les pièces');
-  write('  --json          produit une sortie JSON sans décor (chronology/conversion)');
+  write('  --json          produit une sortie JSON sans décor (conversion)');
   write('  --check         diagnostic seul, n\'installe rien');
   write('  --step <id>     rejoue une seule étape');
   write('  --resume-steps <ids> rejoue les étapes indiquées sans interaction (usage interne)');
@@ -375,135 +356,6 @@ async function installerMenu(steps, ctx, { allowBack = false } = {}) {
   }
 }
 
-function formatChronologyText(chronology) {
-  const lines = [];
-  lines.push(`Chronologie : ${chronology.stats.documents} pièce(s), ${chronology.stats.dated} datée(s), ${chronology.stats.entities} entité(s).`);
-  lines.push('');
-  for (const doc of chronology.documents) {
-    lines.push(`${doc.dateIso || '(date manquante)'}  ${doc.nature || '(nature inconnue)'}  ${doc.name}`);
-  }
-  const missing = chronology.documents.filter((doc) => !doc.dateIso);
-  if (missing.length) {
-    lines.push('');
-    lines.push('Dates manquantes :');
-    for (const doc of missing) lines.push(`  - ${doc.name}`);
-  }
-  return `${lines.join('\n')}\n`;
-}
-
-function locateChronologyCase(flags) {
-  const { locateProjectCase } = require('../../piecemaker-plugin/scripts/lib/case-folders.cjs');
-  const located = locateProjectCase(flags.caseTarget || process.cwd());
-  if (!located) {
-    throw new Error('Lancez la commande depuis un dossier juridique enregistré ou passez --case <chemin>.');
-  }
-  return located;
-}
-
-async function runChronologyReadCommand(flags) {
-  if (!fs.existsSync(DOCUMENT_INDEX_MODULE)) {
-    throw new Error('Le module de chronologie PieceMaker est introuvable.');
-  }
-  const located = locateChronologyCase(flags);
-  const { buildChronology } = require(DOCUMENT_INDEX_MODULE);
-  const chronology = await buildChronology(located.caseRoot, { deanonymizeLabels: false, includeManualDecisions: true });
-  const output = flags.json
-    ? `${JSON.stringify(chronology, null, 2)}\n`
-    : formatChronologyText(chronology);
-  process.stdout.write(output);
-  return 0;
-}
-
-function resolveChronologyPiecePath(caseRoot, relativePath) {
-  const relative = String(relativePath || '').replaceAll('\\', '/').replace(/^\.\//, '');
-  if (!relative) throw new Error('Chemin de pièce manquant.');
-  const absolute = path.resolve(caseRoot, ...relative.split('/'));
-  if (absolute !== caseRoot && !absolute.startsWith(`${caseRoot}${path.sep}`)) {
-    throw new Error('Pièce hors du dossier juridique.');
-  }
-  if (!fs.existsSync(absolute)) throw new Error('Pièce introuvable.');
-  return relative;
-}
-
-async function runChronologyCorrectionCommand(flags) {
-  if (!fs.existsSync(DOCUMENT_INDEX_MODULE)) {
-    throw new Error('Le module de chronologie PieceMaker est introuvable.');
-  }
-  const located = locateChronologyCase(flags);
-  const relative = resolveChronologyPiecePath(located.caseRoot, flags.piecePath);
-
-  let correction;
-  try {
-    correction = JSON.parse(flags.correctionJson || '{}');
-  } catch (error) {
-    throw new Error(`Correction JSON invalide : ${error.message}`);
-  }
-
-  const { stateKey } = require('../../piecemaker-plugin/scripts/lib/anonymization-state.cjs');
-  const { applyDocumentIndexCorrection, readDocumentIndex, documentIndexFile } = require(DOCUMENT_INDEX_MODULE);
-  const key = stateKey(relative);
-  const existing = readDocumentIndex(located.caseRoot).overrides[key] || null;
-
-  if (flags.chronologyAction === 'write' && existing) {
-    throw new Error('Une correction existe déjà pour cette pièce ; utilisez edit_chronology pour la modifier.');
-  }
-  if (flags.chronologyAction === 'edit' && !existing) {
-    throw new Error('Aucune correction existante pour cette pièce ; utilisez write_chronology pour en créer une.');
-  }
-
-  const mutation = applyDocumentIndexCorrection(located.caseRoot, relative, correction);
-
-  let history;
-  try {
-    const { createCommit } = require('../../piecemaker-plugin/scripts/lib/commits.cjs');
-    history = await createCommit({
-      casesRoot: located.casesRoot,
-      caseName: located.caseName,
-      homeDir: HOME_DIR,
-      envFile: path.join(REPO_ROOT, '.env'),
-      label: flags.chronologyAction === 'write'
-        ? 'Création d’une correction de chronologie'
-        : 'Modification d’une correction de chronologie',
-      description: `Mise à jour déterministe de la pièce ${mutation.documentKey.slice(0, 12).toUpperCase()}.`,
-      event: 'assistant-chronology-correction',
-      paths: [path.relative(located.caseRoot, documentIndexFile(located.caseRoot)).split(path.sep).join('/')],
-      waitForLockMs: 10_000,
-    });
-  } catch (error) {
-    history = { created: false, error: error.message };
-  }
-
-  const result = {
-    ok: true,
-    action: flags.chronologyAction,
-    path: relative,
-    documentKey: mutation.documentKey,
-    override: mutation.override,
-    entityDecisions: mutation.entityDecisions,
-    editRevision: mutation.editRevision,
-    history: {
-      created: Boolean(history?.created),
-      hash: history?.commit || null,
-      error: history?.error || null,
-    },
-  };
-
-  if (flags.json) {
-    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-  } else {
-    const verb = flags.chronologyAction === 'write' ? 'Correction créée' : 'Correction modifiée';
-    log.ok(`${verb} pour ${relative}.`);
-  }
-  return 0;
-}
-
-async function runChronologyCommand(flags) {
-  if (flags.chronologyAction === 'write' || flags.chronologyAction === 'edit') {
-    return runChronologyCorrectionCommand(flags);
-  }
-  return runChronologyReadCommand(flags);
-}
-
 function normalizedConversionRequest(value, caseRoot) {
   const raw = String(value || '').trim();
   if (!raw) throw new Error('Nom de pièce vide.');
@@ -570,6 +422,8 @@ async function waitForConversionJob({ folder, id }, { json = false } = {}) {
 }
 
 async function ensureServerForConversion({ json = false } = {}) {
+  await adoptRunningServerPort();
+  if (await localServerReachable()) return;
   const servicesModule = path.join(APP_CLI_LIB, 'services.mjs');
   if (!fs.existsSync(servicesModule)) {
     throw new Error(`Le serveur applicatif doit être démarré par la commande « piecemaker » avant la conversion (port ${appServerPort()}).`);
@@ -625,7 +479,6 @@ async function runConversionCommand(flags) {
 }
 
 async function runOperationalCommand(command, knownUpdate = null, flags = {}) {
-  if (command === 'chronology') return runChronologyCommand(flags);
   if (command === 'conversion') return runConversionCommand(flags);
   if (command === 'update') {
     const pending = knownUpdate ?? checkForUpdate();
@@ -749,20 +602,14 @@ async function main() {
     return 1;
   }
 
-  if (!['chronology', 'conversion'].includes(flags.command) && (flags.caseTarget || flags.json)) {
+  if (flags.command !== 'conversion' && (flags.caseTarget || flags.json)) {
     banner();
-    log.error('Les options --case et --json sont réservées aux commandes chronology et conversion.');
-    return 1;
-  }
-
-  if (flags.command === 'chronology' && !CHRONOLOGY_ACTIONS.has(flags.chronologyAction)) {
-    log.error('Action inconnue : utilisez « piecemaker chronology read|write|edit ».');
+    log.error('Les options --case et --json sont réservées à la commande conversion.');
     return 1;
   }
 
   // Les sorties JSON sont directement consommées par les assistants.
-  if ((flags.command === 'chronology' && flags.json)
-      || (flags.command === 'conversion' && flags.json)) {
+  if (flags.command === 'conversion' && flags.json) {
     return runOperationalCommand(flags.command, null, flags);
   }
 

package/server/piecemaker/vendor/installer/lib/commandes.mjs

@@ -7,5 +7,4 @@
  * est importable sans effet de bord.
  */
 
-export const COMMANDS = new Set(['chronology', 'conversion', 'install', 'doctor', 'check', 'update']);
-export const CHRONOLOGY_ACTIONS = new Set(['read', 'write', 'edit']);
+export const COMMANDS = new Set(['conversion', 'install', 'doctor', 'check', 'update']);

package/server/piecemaker/vendor/installer/lib/conversion-client.mjs

@@ -4,20 +4,79 @@
  * La conversion et l'analyse PII n'ont qu'un seul point d'entrée : la route
  * `knowledge/scan` du serveur applicatif. Le CLI en est un client, sur la
  * boucle locale, via le montage `/api/piecemaker/local` placé avant
- * l'authentification. Le serveur applicatif écoute en clair sur le port du
- * CLI (`PIECEMAKER_APP_PORT`, 3003 par défaut) : aucun certificat n'entre en
- * jeu et la requête ne sort jamais de 127.0.0.1.
+ * l'authentification. Le serveur applicatif écoute en clair sur la boucle
+ * locale : celui qui tourne déjà (application de bureau comprise, annoncé par
+ * `local-server.json` dans le dossier de données), sinon le port du CLI
+ * (`PIECEMAKER_APP_PORT`, 3003 par défaut). Aucun certificat n'entre en jeu et
+ * la requête ne sort jamais de 127.0.0.1.
  */
 
+import fs from 'node:fs';
 import http from 'node:http';
+import os from 'node:os';
+import { join } from 'node:path';
+
+import { GIT_REPO_ROOT } from './platform.mjs';
 
 const LOCAL_BASE = '/api/piecemaker/local';
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '::1', '0.0.0.0', '::']);
 
 export function appServerPort() {
   const parsed = Number.parseInt(process.env.PIECEMAKER_APP_PORT || '', 10);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : 3003;
 }
 
+function runningServerMarkerPath() {
+  if (process.env.CLOUDCLI_HOME) return join(process.env.CLOUDCLI_HOME, 'local-server.json');
+  try {
+    const config = JSON.parse(fs.readFileSync(join(GIT_REPO_ROOT, 'product.config.json'), 'utf8'));
+    return join(os.homedir(), config.dataDirectoryName, 'local-server.json');
+  } catch {
+    return null;
+  }
+}
+
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === 'EPERM';
+  }
+}
+
+export function runningServerPort(markerPath = runningServerMarkerPath()) {
+  if (!markerPath) return null;
+  try {
+    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+    const port = Number(marker?.port);
+    const pid = Number(marker?.pid);
+    if (!Number.isInteger(port) || port <= 0 || !LOOPBACK_HOSTS.has(marker?.host)) return null;
+    if (!Number.isInteger(pid) || pid <= 0 || !processAlive(pid)) return null;
+    return port;
+  } catch {
+    return null;
+  }
+}
+
+export function localServerReachable(port = appServerPort()) {
+  return new Promise((resolve) => {
+    const request = http.get({ hostname: '127.0.0.1', port, path: '/api/auth/status', timeout: 2_000 }, (response) => {
+      response.resume();
+      resolve(response.statusCode < 500);
+    });
+    request.on('timeout', () => request.destroy());
+    request.on('error', () => resolve(false));
+  });
+}
+
+export async function adoptRunningServerPort({ markerPath, reachable = localServerReachable } = {}) {
+  if (process.env.PIECEMAKER_APP_PORT) return appServerPort();
+  const port = runningServerPort(markerPath);
+  if (port && await reachable(port)) process.env.PIECEMAKER_APP_PORT = String(port);
+  return appServerPort();
+}
+
 function requestJson({ method, path, body }) {
   const payload = body === undefined ? null : Buffer.from(JSON.stringify(body));
   return new Promise((resolve, reject) => {

package/server/piecemaker/vendor/installer/steps/06-hooks.mjs

@@ -1,8 +1,7 @@
 /**
- * Étape 06 — hooks Claude Code (protection, commits, facturation).
+ * Étape 06 — hooks Claude Code (protection des pièces, recherche, documents IA).
  *
- * Écrit la configuration d'exécution des hooks dans ~/.piecemaker/config.json,
- * puis prouve que chaque script tourne proprement en lui envoyant une charge
+ * Prouve que chaque script tourne proprement en lui envoyant une charge
  * utile synthétique sur stdin — le contrat exact qu'utilise Claude Code (voir
  * piecemaker-plugin/scripts/lib/hook-io.mjs).
  *
@@ -17,8 +16,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { log, spinner } from '../lib/ui.mjs';
-import { REPO_ROOT, HOME_DIR, runCapture, ensureDir } from '../lib/platform.mjs';
-import { updateConfig } from '../lib/state.mjs';
+import { HOME_DIR, REPO_ROOT, runCapture } from '../lib/platform.mjs';
 
 const require = createRequire(import.meta.url);
 const {
@@ -30,21 +28,17 @@ const {
 
 export const meta = {
   id: '06-hooks',
-  label: 'Hooks Claude Code (protection, commits & facturation)',
-  description: 'Configure les garde-fous, les commits PostToolUse et le suivi de facturation',
+  label: 'Hooks Claude Code (protection des pièces)',
+  description: 'Configure les garde-fous et les hooks de recherche et de classement des documents IA',
 };
 
 const PLUGIN_ROOT = path.join(REPO_ROOT, 'piecemaker-plugin');
 const SCRIPTS_DIR = path.join(PLUGIN_ROOT, 'scripts');
 const HOOKS_JSON = path.join(PLUGIN_ROOT, 'hooks', 'hooks.json');
-const BILLING_DIR = path.join(HOME_DIR, 'billing');
-const SYNTHESE_DIR = path.join(BILLING_DIR, 'synthese');
 
 const HOOK_SCRIPTS = {
   protect: path.join(SCRIPTS_DIR, 'protect-originals.mjs'),
-  commit: path.join(SCRIPTS_DIR, 'commit-track.mjs'),
   classify: path.join(SCRIPTS_DIR, 'classify-ai-documents.mjs'),
-  billing: path.join(SCRIPTS_DIR, 'billing-track.mjs'),
   statusline: path.join(SCRIPTS_DIR, 'statusline.mjs'),
 };
 
@@ -73,29 +67,12 @@ function runHookSelfTest(label, scriptPath, payload) {
       return { label, ok: false, note: 'sortie stdout non-JSON — contrat de hook invalide' };
     }
   }
-  return { label, ok: true, note: result.stdout ? 'sortie JSON valide' : 'exit 0 (aucune sortie)' };
+  return { label, ok: true, stdout: result.stdout, note: result.stdout ? 'sortie JSON valide' : 'exit 0 (aucune sortie)' };
 }
 
 export async function install(ctx) {
-  log.step('Répertoires de facturation...');
-  if (!ctx.dryRun) {
-    ensureDir(BILLING_DIR);
-    ensureDir(SYNTHESE_DIR);
-  }
-  log.ok(`${BILLING_DIR}`);
-
   if (ctx.dryRun) {
-    log.info('[simulation] configuration commits/facturation non écrite');
     log.info('[simulation] hooks PieceMaker fusionnés directement dans ~/.claude/settings.json');
-  } else {
-    updateConfig({
-      commits: { enabled: true, timeoutMs: 8000 },
-      billing: { enabled: true },
-    });
-    log.ok('Configuration écrite dans ~/.piecemaker/config.json (commits, billing)');
-  }
-
-  if (ctx.dryRun) {
     return { status: 'skipped', note: 'Mode simulation — hooks non vérifiés.' };
   }
 
@@ -109,10 +86,14 @@ export async function install(ctx) {
     // Un vrai dossier juridique factice, sans point de tête : les hooks
     // ignorent les répertoires cachés, un bac de test caché ne prouverait donc
     // rien du garde-fou. Comme seul un projet publié est un dossier juridique,
-    // on le publie le temps du test sous une source dédiée, retirée ensuite.
-    testDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'piecemaker-hook-selftest-')));
+    // on le publie le temps du test sous une source dédiée, retirée ensuite,
+    // et comme anonymisé : le garde-fou n'agit que sous un bouclier vert.
+    // Les dossiers temporaires du système ne sont jamais des dossiers
+    // juridiques : le bac vit donc dans le répertoire PieceMaker.
+    fs.mkdirSync(HOME_DIR, { recursive: true });
+    testDir = fs.realpathSync(fs.mkdtempSync(path.join(HOME_DIR, 'hook-selftest-')));
     fs.writeFileSync(path.join(testDir, 'piece-selftest.pdf'), 'PIECE DE TEST', 'utf8');
-    publishProjectSource('installer-selftest', [testDir]);
+    publishProjectSource('installer-selftest', [testDir], [testDir]);
     selftestRegistered = true;
 
     // 1. protect-originals.mjs — une pièce du bac de test : protégée par
@@ -127,38 +108,15 @@ export async function install(ctx) {
       tool_input: { file_path: path.join(testDir, 'piece-selftest.pdf') },
       tool_use_id: 'toolu_installer_originals_selftest',
     });
+    if (protectedResult.ok && !/"permissionDecision"\s*:\s*"deny"/.test(protectedResult.stdout || '')) {
+      protectedResult.ok = false;
+      protectedResult.note = 'la pièce du bac de test n\'a pas été bloquée';
+    } else if (protectedResult.ok) {
+      protectedResult.note = 'pièce protégée bloquée';
+    }
     testResults.push(protectedResult);
 
-    // 2. commit-track.mjs — réponse d'outil en échec : exerce le contrat
-    //    d'entrée/sortie sans créer de vrai commit pendant l'installation.
-    const commitResult = runHookSelfTest('commit-track.mjs', HOOK_SCRIPTS.commit, {
-      hook_event_name: 'PostToolUse',
-      session_id: 'installer-selftest',
-      cwd: REPO_ROOT,
-      transcript_path: '',
-      permission_mode: 'default',
-      tool_name: 'Edit',
-      tool_input: { file_path: path.join(REPO_ROOT, 'README.md') },
-      tool_response: { success: false },
-      tool_use_id: 'toolu_installer_commit_selftest',
-    });
-    testResults.push(commitResult);
-
-    // 3. billing-track.mjs — une vraie charge utile Stop : ajoute une ligne
-    //    (clairement identifiée) au registre du mois et écrit une synthèse,
-    //    ce qui prouve le chemin d'écriture de bout en bout.
-    const billingResult = runHookSelfTest('billing-track.mjs', HOOK_SCRIPTS.billing, {
-      hook_event_name: 'Stop',
-      session_id: 'installer-selftest',
-      cwd: REPO_ROOT,
-      transcript_path: path.join(testDir, 'transcript-selftest.jsonl'),
-      permission_mode: 'default',
-      last_assistant_message: 'Test d\'installation PieceMaker — vérification du hook de facturation.',
-      stop_reason: 'end_turn',
-    });
-    testResults.push(billingResult);
-
-    // 4. classify-ai-documents.mjs — un document « créé par l'IA » dans le bac
+    // 2. classify-ai-documents.mjs — un document « créé par l'IA » dans le bac
     //    de test enregistré doit ressortir classé « espace de travail » dans
     //    `.piecemaker/protection.json`, sans quoi l'IA ne pourrait pas se
     //    relire. On vérifie l'effet de bord, pas seulement le code de sortie.
@@ -201,7 +159,6 @@ export async function install(ctx) {
     if (r.ok) log.ok(`${r.label} : ${r.note}`);
     else log.error(`${r.label} : ${r.note}`);
   }
-  log.detail(`Une ligne de test a été ajoutée à ${path.join(BILLING_DIR, `${new Date().toISOString().slice(0, 7)}.jsonl`)} (session "installer-selftest") — supprimez-la si besoin.`);
   if (!fs.existsSync(HOOKS_JSON)) {
     log.warn(`hooks/hooks.json introuvable dans le plugin : ${HOOKS_JSON}`);
   }
@@ -232,12 +189,9 @@ export async function install(ctx) {
   return { status: 'done', note: '' };
 }
 
-export async function check(ctx) {
+export async function check() {
   const scriptsExist = Object.values(HOOK_SCRIPTS).every((p) => fs.existsSync(p));
   const hooksJsonExists = fs.existsSync(HOOKS_JSON);
-  const dirsExist = fs.existsSync(BILLING_DIR) && fs.existsSync(SYNTHESE_DIR);
-  const cfg = ctx.config || {};
-  const configOk = Boolean(cfg.commits && cfg.billing);
   const hooksRegistered = claudeHooksStatus(REPO_ROOT, os.homedir()).ok;
   const statusLine = claudeStatusLineStatus(REPO_ROOT, os.homedir());
   const statusLineOk = statusLine.ok || statusLine.conflict; // une statusLine personnelle n'est pas une anomalie
@@ -245,8 +199,8 @@ export async function check(ctx) {
   if (!scriptsExist || !hooksJsonExists) {
     return { status: 'failed', note: 'Fichiers du plugin manquants (scripts ou hooks.json) — réinstallez piecemaker-plugin/.' };
   }
-  if (!dirsExist || !configOk || !hooksRegistered) {
-    return { status: 'partial', note: 'Scripts présents mais configuration, enregistrement Claude ou répertoires de facturation incomplets — relancez cette étape.' };
+  if (!hooksRegistered) {
+    return { status: 'partial', note: 'Scripts présents mais hooks non enregistrés dans Claude Code — relancez cette étape.' };
   }
   if (!statusLineOk) {
     return { status: 'partial', note: `statusLine Claude Code absente ou périmée (${statusLine.reason}) — relancez cette étape.` };

package/server/piecemaker/vendor/installer/steps/12-mcp-piecemaker.mjs

@@ -1,5 +1,5 @@
 /**
- * Étape 12 — serveur MCP « piecemaker » (conversion, chronologie).
+ * Étape 12 — serveur MCP « piecemaker » (conversion).
  *
  * Les commandes de conversion sont aujourd'hui présentées au
  * modèle par du texte injecté dans les templates, sans rien qui relie ce
@@ -21,8 +21,8 @@ import { REPO_ROOT, commandExists, run, runCapture } from '../lib/platform.mjs';
 
 export const meta = {
   id: '12-mcp-piecemaker',
-  label: 'Serveur MCP piecemaker (conversion, chronologie)',
-  description: 'Enregistre dans Claude Code le serveur MCP qui expose la conversion et la chronologie',
+  label: 'Serveur MCP piecemaker (conversion)',
+  description: 'Enregistre dans Claude Code le serveur MCP qui expose la conversion',
 };
 
 const SERVER_NAME = 'piecemaker';

package/server/piecemaker/vendor/mcp/README.md

@@ -1,7 +1,7 @@
 # MCP PieceMaker
 
 Point d'entrée du serveur MCP `piecemaker` (`piecemaker/server.mjs`), qui expose
-les outils `chronologie` et `conversion` en pilotant
+l'outil `conversion` en pilotant
 `installer/bin/piecemaker.mjs`.
 
 - `REPO_ROOT`, calculé deux niveaux au-dessus de ce fichier, résout vers