@piecemaker-legal/piecemaker 1.0.6

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

@@ -0,0 +1,266 @@
+/**
+ * Étape 06 — hooks Claude Code (protection, commits, facturation).
+ *
+ * Écrit la configuration d'exécution des hooks dans ~/.piecemaker/config.json,
+ * puis 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).
+ *
+ * Le mapping PII n'est plus appliqué par des hooks Claude Code : le proxy
+ * PII couvre Claude Code et Codex au même point de passage. Le scan reste
+ * dans le pipeline de l'administration, seul endroit où les modèles NER sont
+ * chargés.
+ */
+
+import fs from 'node:fs';
+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, GIT_REPO_ROOT, HOME_DIR, runCapture, ensureDir } from '../lib/platform.mjs';
+import { updateConfig } from '../lib/state.mjs';
+
+const require = createRequire(import.meta.url);
+const {
+  claudeHooksStatus,
+  claudeSessionHookStatus,
+  claudeStatusLineStatus,
+  installClaudeHooks,
+  installClaudeSessionHook,
+  installClaudeStatusLine,
+} = require('../../websocket-server/claude-hooks.cjs');
+
+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',
+};
+
+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'),
+  proxyGuard: path.join(GIT_REPO_ROOT, 'scripts', 'piecemaker', 'hooks', 'proxy-guard.mjs'),
+  statusline: path.join(SCRIPTS_DIR, 'statusline.mjs'),
+};
+
+/** Run one hook script exactly like Claude Code would: JSON payload on stdin, JSON (or nothing) on stdout, exit 0 expected. */
+function runHookSelfTest(label, scriptPath, payload) {
+  if (!fs.existsSync(scriptPath)) {
+    return { label, ok: false, note: `script manquant : ${scriptPath}` };
+  }
+
+  const result = runCapture('node', [scriptPath], {
+    input: JSON.stringify(payload),
+    cwd: REPO_ROOT,
+    timeout: 15000,
+  });
+
+  if (result.error) {
+    return { label, ok: false, note: `échec du lancement : ${result.error.message}` };
+  }
+  if (result.code !== 0) {
+    return { label, ok: false, note: `code de sortie ${result.code}${result.stderr ? ` — ${result.stderr}` : ''}` };
+  }
+  if (result.stdout) {
+    try {
+      JSON.parse(result.stdout);
+    } catch {
+      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)' };
+}
+
+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.' };
+  }
+
+  const spin = spinner('Vérification des hooks (payload synthétique sur stdin)...');
+  const testResults = [];
+  let testDir = null;
+  let selftestRegistered = false;
+  const caseFoldersBefore = Array.isArray(ctx.config?.caseFolders) ? ctx.config.caseFolders : [];
+
+  try {
+    // 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 un dossier n'est protégé qu'une fois enregistré,
+    // on l'ajoute à `caseFolders` le temps du test, puis on rétablit la config.
+    testDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'piecemaker-hook-selftest-')));
+    fs.writeFileSync(path.join(testDir, 'piece-selftest.pdf'), 'PIECE DE TEST', 'utf8');
+    updateConfig({ caseFolders: [...new Set([...caseFoldersBefore, testDir])] });
+    selftestRegistered = true;
+
+    // 1. protect-originals.mjs — une pièce du bac de test : protégée par
+    //    défaut, donc la réponse de blocage doit être produite et bien formée.
+    const protectedResult = runHookSelfTest('protect-originals.mjs', HOOK_SCRIPTS.protect, {
+      hook_event_name: 'PreToolUse',
+      session_id: 'installer-selftest',
+      cwd: REPO_ROOT,
+      transcript_path: '',
+      permission_mode: 'default',
+      tool_name: 'Read',
+      tool_input: { file_path: path.join(testDir, 'piece-selftest.pdf') },
+      tool_use_id: 'toolu_installer_originals_selftest',
+    });
+    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
+    //    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.
+    const createdDoc = path.join(testDir, 'note-selftest.docx');
+    fs.writeFileSync(createdDoc, 'NOTE DE TEST', 'utf8');
+    const classifyResult = runHookSelfTest('classify-ai-documents.mjs', HOOK_SCRIPTS.classify, {
+      hook_event_name: 'PostToolUse',
+      session_id: 'installer-selftest',
+      cwd: testDir,
+      transcript_path: '',
+      permission_mode: 'default',
+      tool_name: 'Write',
+      tool_input: { file_path: createdDoc },
+      tool_response: { success: true },
+      tool_use_id: 'toolu_installer_classify_selftest',
+    });
+    if (classifyResult.ok) {
+      const { readProtection } = require('../../piecemaker-plugin/scripts/lib/protection.cjs');
+      if (!readProtection(testDir).unprotected.has('note-selftest.docx')) {
+        classifyResult.ok = false;
+        classifyResult.note = 'le document créé n\'a pas été classé « espace de travail »';
+      } else {
+        classifyResult.note = 'document créé classé « espace de travail »';
+      }
+    }
+    testResults.push(classifyResult);
+  } finally {
+    // Rétablir la liste des dossiers enregistrés : le bac de test ne doit pas
+    // rester surveillé après l'installation.
+    if (selftestRegistered) updateConfig({ caseFolders: caseFoldersBefore });
+    if (testDir) fs.rmSync(testDir, { recursive: true, force: true });
+  }
+
+  const allOk = testResults.every((r) => r.ok);
+  if (allOk) spin.succeed(`Hooks vérifiés — les ${testResults.length} scripts répondent au contrat stdin/stdout`);
+
+  else spin.fail('Échec de vérification d\'au moins un hook');
+
+  for (const r of testResults) {
+    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}`);
+  }
+
+  if (!allOk) {
+    const failed = testResults.filter((r) => !r.ok).map((r) => r.label).join(', ');
+    return { status: 'failed', note: `Échec de la vérification : ${failed}. Corrigez puis relancez cette étape.` };
+  }
+  const registration = installClaudeHooks(REPO_ROOT, os.homedir());
+  if (!registration.ok) {
+    return { status: 'failed', note: registration.reason };
+  }
+  if (registration.cleanup?.removed || registration.cleanup?.deletedFile) {
+    log.ok(`${registration.cleanup.removed} ancien(s) branchement(s) de mapping retiré(s)`
+      + (registration.cleanup.deletedFile ? ', script global supprimé.' : '.'));
+  }
+  log.ok(`${registration.registered} hook(s) PieceMaker ${registration.changed ? 'enregistré(s)' : 'déjà enregistré(s)'} directement dans ~/.claude/settings.json.`);
+
+  const sessionHook = installClaudeSessionHook(os.homedir());
+  if (!sessionHook.ok) {
+    log.warn(`Sentinelle proxy PII (SessionStart) non enregistrée : ${sessionHook.reason}.`);
+  } else {
+    log.ok(`Sentinelle proxy PII (SessionStart) ${sessionHook.changed ? 'enregistrée' : 'déjà à jour'} dans ~/.claude/settings.json.`);
+  }
+
+  const statusLine = installClaudeStatusLine(REPO_ROOT, os.homedir());
+  if (statusLine.conflict) {
+    log.warn(`statusLine Claude Code personnelle détectée — laissée telle quelle (${statusLine.reason}). Bandeau d'état PieceMaker non installé.`);
+  } else if (!statusLine.ok) {
+    log.warn(`statusLine Claude Code non installée : ${statusLine.reason}.`);
+  } else {
+    log.ok(`statusLine Claude Code ${statusLine.changed ? 'installée' : 'déjà à jour'} (${statusLine.command}).`);
+  }
+
+  return { status: 'done', note: '' };
+}
+
+export async function check(ctx) {
+  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 sessionHookRegistered = claudeSessionHookStatus(os.homedir()).ok;
+  const statusLine = claudeStatusLineStatus(REPO_ROOT, os.homedir());
+  const statusLineOk = statusLine.ok || statusLine.conflict; // une statusLine personnelle n'est pas une anomalie
+
+  if (!scriptsExist || !hooksJsonExists) {
+    return { status: 'failed', note: 'Fichiers du plugin manquants (scripts ou hooks.json) — réinstallez piecemaker-plugin/.' };
+  }
+  if (!dirsExist || !configOk || !hooksRegistered || !sessionHookRegistered) {
+    return { status: 'partial', note: 'Scripts présents mais configuration, enregistrement Claude ou répertoires de facturation incomplets — relancez cette étape.' };
+  }
+  if (!statusLineOk) {
+    return { status: 'partial', note: `statusLine Claude Code absente ou périmée (${statusLine.reason}) — relancez cette étape.` };
+  }
+  return { status: 'done', note: '' };
+}

package/server/piecemaker/vendor/installer/steps/07-legifrance.mjs

@@ -0,0 +1,279 @@
+/**
+ * Étape 07 — plugin MCP Légifrance autonome et clés PISTE.
+ *
+ * Le runtime vit dans https://github.com/PieceMaker-Legal/mcp-legifrance.
+ * PieceMaker ne possède plus son code : il installe le marketplace Claude,
+ * prépare le venv privé du plugin et écrit les identifiants dans le fichier de
+ * configuration stable ~/.config/mcp-legifrance/.env (0600). Une copie reste
+ * dans le .env PieceMaker pour l'administration et les migrations existantes.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { log, spinner, blank, link } from '../lib/ui.mjs';
+import { ask, select, confirm, nonInteractive } from '../lib/prompt.mjs';
+import { commandExists, compareVersions, findPython, run, runCapture } from '../lib/platform.mjs';
+import { writeEnv } from '../lib/state.mjs';
+import { removeLegacyLegifranceService } from '../lib/legacy-legifrance.mjs';
+
+export const meta = {
+  id: '07-legifrance',
+  label: 'Serveur MCP Légifrance (clés PISTE)',
+  description: "Installe le plugin MCP autonome et configure l'accès à l'API Légifrance via PISTE",
+};
+
+const MARKETPLACE_NAME = 'mcp-legifrance';
+const MARKETPLACE_REPO = 'PieceMaker-Legal/mcp-legifrance';
+const PLUGIN_NAME = 'legifrance';
+const PLUGIN_SPEC = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+const MINIMUM_PLUGIN_VERSION = '1.0.0';
+const REGISTRATION_URL = 'https://piste.gouv.fr/registration';
+const CATALOG_URL = 'https://piste.gouv.fr/api-catalog-all';
+const PISTE_ENV = 'production';
+
+const ENDPOINTS = {
+  token: 'https://oauth.piste.gouv.fr/api/oauth/token',
+  api: 'https://api.piste.gouv.fr/dila/legifrance/lf-engine-app/',
+};
+
+function parseJson(raw, fallback = null) {
+  try { return JSON.parse(raw); } catch { return fallback; }
+}
+
+function marketplaceRegistered(capture = runCapture) {
+  const result = capture('claude', ['plugin', 'marketplace', 'list', '--json']);
+  const marketplaces = result.code === 0 ? parseJson(result.stdout, []) : [];
+  return Array.isArray(marketplaces)
+    && marketplaces.some((marketplace) => marketplace.name === MARKETPLACE_NAME);
+}
+
+function pluginState(capture = runCapture) {
+  const result = capture('claude', ['plugin', 'list', '--json']);
+  if (result.code !== 0) return { known: false, installed: false, enabled: false, installPath: null, version: null };
+  const plugins = parseJson(result.stdout, []);
+  const plugin = Array.isArray(plugins)
+    ? plugins.find((item) => item.id === PLUGIN_SPEC || item.name === PLUGIN_NAME)
+    : null;
+  return {
+    known: true,
+    installed: Boolean(plugin),
+    enabled: Boolean(plugin) && plugin.enabled !== false,
+    installPath: plugin?.installPath || null,
+    version: plugin?.version || null,
+  };
+}
+
+export function legifranceEnvFile(userHome = os.homedir()) {
+  return path.join(userHome, '.config', 'mcp-legifrance', '.env');
+}
+
+function readSimpleEnv(file) {
+  const values = {};
+  try {
+    for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+      const match = line.match(/^\s*([A-Z0-9_]+)\s*=(.*)$/);
+      if (match) values[match[1]] = match[2];
+    }
+  } catch { /* fichier absent */ }
+  return values;
+}
+
+/** Fusionne les secrets MCP sans écraser les commentaires ni les autres clés. */
+export function writeLegifranceEnv(file, values) {
+  const existing = new Map();
+  const preamble = [];
+  try {
+    for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+      const match = line.match(/^\s*([A-Z0-9_]+)\s*=(.*)$/);
+      if (match) existing.set(match[1], match[2]);
+      else if (line.trim()) preamble.push(line);
+    }
+  } catch { /* première installation */ }
+  for (const [key, value] of Object.entries(values)) {
+    if (value !== undefined && value !== null && value !== '') existing.set(key, String(value));
+  }
+  const body = [...preamble, ...[...existing].map(([key, value]) => `${key}=${value}`)].join('\n');
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(temporary, `${body}\n`, { encoding: 'utf8', mode: 0o600 });
+  fs.renameSync(temporary, file);
+  try { fs.chmodSync(file, 0o600); } catch { /* ACL Windows */ }
+  return file;
+}
+
+async function validatePisteCredentials(clientId, clientSecret, fetchImpl = fetch) {
+  let tokenRes;
+  try {
+    tokenRes = await fetchImpl(ENDPOINTS.token, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        grant_type: 'client_credentials', client_id: clientId,
+        client_secret: clientSecret, scope: 'openid',
+      }),
+    });
+  } catch (error) {
+    return { ok: false, message: `Impossible de joindre le serveur OAuth PISTE (${ENDPOINTS.token}) : ${error.message}` };
+  }
+  if (!tokenRes.ok) {
+    const detail = await tokenRes.text().catch(() => '');
+    return {
+      ok: false,
+      message: `Authentification refusée par PISTE (HTTP ${tokenRes.status}). Vérifiez le Client ID et le Client Secret.${detail ? ` Détail : ${detail.slice(0, 200)}` : ''}`,
+    };
+  }
+  const tokenData = await tokenRes.json().catch(() => null);
+  if (!tokenData?.access_token) return { ok: false, message: 'Réponse PISTE invalide : aucun jeton reçu.' };
+  let searchRes;
+  try {
+    searchRes = await fetchImpl(`${ENDPOINTS.api}search`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${tokenData.access_token}`,
+        'Content-Type': 'application/json', Accept: 'application/json',
+      },
+      body: JSON.stringify({
+        fond: 'CODE_DATE',
+        recherche: {
+          champs: [{ typeChamp: 'ALL', criteres: [{ typeRecherche: 'UN_DES_MOTS', valeur: 'code civil', operateur: 'ET' }], operateur: 'ET' }],
+          filtres: [], pageNumber: 1, pageSize: 1, operateur: 'ET',
+          sort: 'SIGNATURE_DATE_DESC', typePagination: 'DEFAUT',
+        },
+      }),
+    });
+  } catch (error) {
+    return { ok: false, message: `Jeton obtenu, mais API Légifrance injoignable : ${error.message}` };
+  }
+  if (!searchRes.ok) {
+    const detail = await searchRes.text().catch(() => '');
+    return {
+      ok: false,
+      message: `Jeton obtenu, mais la requête Légifrance a échoué (HTTP ${searchRes.status}). Vérifiez la souscription PISTE.${detail ? ` Détail : ${detail.slice(0, 200)}` : ''}`,
+    };
+  }
+  return { ok: true };
+}
+
+function dependencies(overrides = {}) {
+  return {
+    userHome: os.homedir(), log, run, runCapture, commandExists, findPython,
+    writeEnv, writeLegifranceEnv, validatePisteCredentials,
+    ask, select, confirm, nonInteractive,
+    ...overrides,
+  };
+}
+
+async function ensurePlugin(ops) {
+  if (!ops.commandExists('claude', ['--version'])) return { ok: false, reason: 'CLI Claude Code introuvable.' };
+  if (!marketplaceRegistered(ops.runCapture)) {
+    const code = await ops.run('claude', ['plugin', 'marketplace', 'add', MARKETPLACE_REPO]);
+    if (code !== 0) return { ok: false, reason: `Impossible d'enregistrer ${MARKETPLACE_REPO}.` };
+  }
+  let state = pluginState(ops.runCapture);
+  if (!state.known) return { ok: false, reason: 'Claude Code ne peut pas lister ses plugins.' };
+  if (!state.installed) {
+    const code = await ops.run('claude', ['plugin', 'install', PLUGIN_SPEC]);
+    if (code !== 0) return { ok: false, reason: `Impossible d'installer ${PLUGIN_SPEC}.` };
+    state = pluginState(ops.runCapture);
+  }
+  if (state.installed && (!state.version || compareVersions(state.version, MINIMUM_PLUGIN_VERSION) < 0)) {
+    await ops.run('claude', ['plugin', 'marketplace', 'update', MARKETPLACE_NAME]);
+    const code = await ops.run('claude', ['plugin', 'update', PLUGIN_SPEC, '--yes']);
+    if (code !== 0) return { ok: false, reason: `Impossible de mettre à jour ${PLUGIN_SPEC}.` };
+    state = pluginState(ops.runCapture);
+  }
+  if (!state.enabled) {
+    const code = await ops.run('claude', ['plugin', 'enable', PLUGIN_SPEC]);
+    if (code !== 0) return { ok: false, reason: `Plugin ${PLUGIN_SPEC} installé mais non activé.` };
+    state = pluginState(ops.runCapture);
+  }
+  const launcher = state.installPath && path.join(state.installPath, 'scripts', 'launcher.py');
+  if (!launcher || !fs.existsSync(launcher)) return { ok: false, reason: 'Lanceur du plugin Légifrance introuvable.' };
+  const python = ops.findPython();
+  if (!python) return { ok: false, reason: 'Python 3 introuvable pour préparer le plugin.' };
+  const code = await ops.run(python.command, [launcher, '--bootstrap-only']);
+  if (code !== 0) return { ok: false, reason: 'Échec de la préparation du venv Légifrance.' };
+  return { ok: true, state };
+}
+
+export async function install(ctx, overrides = {}) {
+  const ops = dependencies(overrides);
+  if (ctx.dryRun) {
+    ops.log.info(`[simulation] installation de ${PLUGIN_SPEC} depuis ${MARKETPLACE_REPO}`);
+    ops.log.info(`[simulation] configuration PISTE dans ${legifranceEnvFile(ops.userHome)}`);
+    return { status: 'skipped', note: 'Mode simulation — aucune modification effectuée.' };
+  }
+  removeLegacyLegifranceService({ userHome: ops.userHome, capture: ops.runCapture, logger: ops.log });
+  const pluginSpin = spinner('Installation du plugin MCP Légifrance autonome...');
+  const plugin = await ensurePlugin(ops);
+  if (!plugin.ok) {
+    pluginSpin.fail('Plugin MCP Légifrance non installé.');
+    return { status: 'failed', note: plugin.reason };
+  }
+  pluginSpin.succeed('Plugin MCP Légifrance installé et prêt.');
+
+  const standalone = readSimpleEnv(legifranceEnvFile(ops.userHome));
+  const existingEnv = { ...standalone, ...(ctx.env || {}) };
+  let clientId = existingEnv.LEGIFRANCE_CLIENT_ID || '';
+  let clientSecret = existingEnv.LEGIFRANCE_CLIENT_SECRET || '';
+  if (clientId && clientSecret) {
+    const keep = await ops.confirm('Des clés PISTE sont déjà configurées. Les conserver pour la production ?', true);
+    if (!keep) { clientId = ''; clientSecret = ''; }
+  }
+  if (!clientId || !clientSecret) {
+    ops.log.info("Le serveur MCP interroge l'API officielle Légifrance via PISTE.");
+    ops.log.detail(`1. Compte PISTE : ${link(REGISTRATION_URL, REGISTRATION_URL)}`);
+    ops.log.detail(`2. Souscrire à l'API Légifrance : ${link(CATALOG_URL, CATALOG_URL)}`);
+    blank();
+  }
+  for (;;) {
+    if (!clientId || !clientSecret) {
+      clientId = await ops.ask('Client ID PISTE (production)', { required: true });
+      clientSecret = await ops.ask('Client Secret PISTE (production)', { required: true });
+    }
+    if (!clientId || !clientSecret) return { status: 'partial', note: 'Plugin installé, mais clés PISTE absentes.' };
+    const values = {
+      LEGIFRANCE_CLIENT_ID: clientId,
+      LEGIFRANCE_CLIENT_SECRET: clientSecret,
+      LEGIFRANCE_ENV: PISTE_ENV,
+    };
+    ops.writeEnv(values);
+    ops.writeLegifranceEnv(legifranceEnvFile(ops.userHome), values);
+    const validationSpin = spinner('Validation des clés PISTE de production...');
+    const validation = await ops.validatePisteCredentials(clientId, clientSecret);
+    if (validation.ok) {
+      validationSpin.succeed('Connexion à Légifrance confirmée.');
+      return { status: 'done', note: '' };
+    }
+    validationSpin.fail('Échec de la validation PISTE.');
+    ops.log.error(validation.message);
+    if (ops.nonInteractive) return { status: 'partial', note: validation.message };
+    const action = await ops.select('La validation a échoué. Que voulez-vous faire ?', [
+      { value: 'retry', label: 'Réessayer', hint: 'ressaisir les clés' },
+      { value: 'skip', label: 'Conserver sans validation', hint: 'terminer malgré l’échec' },
+    ], { def: 0 });
+    if (action === 'skip') return { status: 'partial', note: validation.message };
+    clientId = ''; clientSecret = '';
+  }
+}
+
+export async function check(_ctx, overrides = {}) {
+  const ops = dependencies(overrides);
+  if (!ops.commandExists('claude', ['--version'])) return { status: 'skipped', note: 'CLI Claude Code introuvable.' };
+  const state = pluginState(ops.runCapture);
+  if (!state.known) return { status: 'failed', note: 'Impossible de lister les plugins Claude Code.' };
+  if (!state.installed) return { status: 'failed', note: `Plugin ${PLUGIN_SPEC} non installé.` };
+  if (!state.enabled) return { status: 'partial', note: `Plugin ${PLUGIN_SPEC} désactivé.` };
+  if (!state.version || compareVersions(state.version, MINIMUM_PLUGIN_VERSION) < 0) {
+    return { status: 'partial', note: `Plugin ${PLUGIN_SPEC} antérieur à ${MINIMUM_PLUGIN_VERSION}.` };
+  }
+  const env = readSimpleEnv(legifranceEnvFile(ops.userHome));
+  if (!env.LEGIFRANCE_CLIENT_ID || !env.LEGIFRANCE_CLIENT_SECRET) {
+    return { status: 'partial', note: 'Plugin installé, mais clés PISTE absentes de ~/.config/mcp-legifrance/.env.' };
+  }
+  if ((env.LEGIFRANCE_ENV || PISTE_ENV).toLowerCase() !== PISTE_ENV) {
+    return { status: 'partial', note: 'Le plugin Légifrance n’est pas configuré en production.' };
+  }
+  return { status: 'done', note: 'Plugin autonome installé ; clés présentes. Validation réseau non rejouée.' };
+}