@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/vendor/installer/steps/09-codex-plugin.mjs

@@ -0,0 +1,142 @@
+/**
+ * Étape 09 — composants PieceMaker pour la CLI Codex.
+ *
+ * Aucune entrée de marketplace ni aucun plugin d'application n'est créé :
+ * les skills sont enregistrés dans `~/.codex/skills/` et la sentinelle du
+ * proxy dans `~/.codex/hooks.json`, deux emplacements locaux découverts par
+ * la CLI Codex. Claude Code et son marketplace restent entièrement inchangés.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { log } from '../lib/ui.mjs';
+import { REPO_ROOT, commandExists } from '../lib/platform.mjs';
+import {
+  codexProtectionHookStatus,
+  codexSessionHookStatus,
+  codexSkillStatus,
+  installCodexProtectionHook,
+  installCodexSessionHook,
+  repositoryCodexSkills,
+  syncCodexSkills,
+} from '../lib/codex-skills.mjs';
+import { loadConfig } from '../lib/state.mjs';
+
+const require = createRequire(import.meta.url);
+const { refreshRegisteredCaseRules } = require('../../websocket-server/case-instructions.cjs');
+
+export const meta = {
+  id: '09-codex-plugin',
+  label: 'Composants Codex PieceMaker',
+  description: 'Enregistre les skills et le badge d’anonymisation lorsque la CLI Codex est présente',
+  required: false,
+};
+
+const PLUGIN_DIR = path.join(REPO_ROOT, 'piecemaker-plugin');
+
+function dependencies(overrides = {}) {
+  return {
+    commandExists,
+    existsSync: fs.existsSync,
+    userHome: os.homedir(),
+    log,
+    codexSkillStatus,
+    codexSessionHookStatus,
+    codexProtectionHookStatus,
+    installCodexSessionHook,
+    installCodexProtectionHook,
+    repositoryCodexSkills,
+    syncCodexSkills,
+    loadConfig,
+    refreshRegisteredCaseRules,
+    ...overrides,
+  };
+}
+
+export async function install(ctx, overrides = {}) {
+  const ops = dependencies(overrides);
+  if (!ops.existsSync(PLUGIN_DIR)) {
+    return { status: 'skipped', note: 'Dossier piecemaker-plugin absent.' };
+  }
+  if (!ops.commandExists('codex', ['--version'])) {
+    return { status: 'skipped', note: 'CLI "codex" introuvable.' };
+  }
+
+  const skills = ops.repositoryCodexSkills(REPO_ROOT);
+  if (!skills.length) {
+    return { status: 'skipped', note: 'Aucun skill PieceMaker à enregistrer dans Codex.' };
+  }
+  if (ctx.dryRun) {
+    ops.log.info(`[simulation] enregistrement de ${skills.length} skill(s) PieceMaker dans ~/.codex/skills`);
+    ops.log.info('[simulation] enregistrement du badge d’anonymisation au démarrage des sessions Codex');
+    ops.log.info('[simulation] actualisation des instructions AGENTS.md des dossiers enregistrés');
+    return { status: 'skipped', note: 'Mode simulation — aucune modification effectuée.' };
+  }
+
+  const result = ops.syncCodexSkills(REPO_ROOT, ops.userHome);
+  ops.log.detail(`${result.registered} skill(s) PieceMaker enregistré(s) pour la CLI Codex.`);
+  for (const conflict of result.conflicts) {
+    ops.log.warn(`Le skill Codex personnel « ${conflict.slug} » existe déjà et n'a pas été remplacé.`);
+  }
+  const sessionHook = ops.installCodexSessionHook(REPO_ROOT, ops.userHome);
+  if (!sessionHook.ok) {
+    ops.log.warn(`Badge d’anonymisation Codex non enregistré : ${sessionHook.reason}.`);
+  } else {
+    ops.log.detail(`Badge d’anonymisation Codex ${sessionHook.changed ? 'enregistré' : 'déjà à jour'} dans ~/.codex/hooks.json.`);
+  }
+  const protectionHook = ops.installCodexProtectionHook(REPO_ROOT, ops.userHome);
+  if (!protectionHook.ok) {
+    ops.log.warn(`Protection des pièces Codex non enregistrée : ${protectionHook.reason}.`);
+  } else {
+    ops.log.detail(`Protection des pièces Codex ${protectionHook.changed ? 'enregistrée' : 'déjà à jour'} dans ~/.codex/hooks.json.`);
+  }
+  const instructions = ops.refreshRegisteredCaseRules(REPO_ROOT, ops.loadConfig());
+  ops.log.detail(`${instructions.refreshed} dossier(s) juridique(s) muni(s) des instructions Codex/Claude.`);
+  for (const failure of instructions.failed) {
+    ops.log.warn(`Instructions non actualisées pour ${failure.folder} : ${failure.error}`);
+  }
+  if (result.conflicts.length || !sessionHook.ok || !protectionHook.ok) {
+    return {
+      status: 'partial',
+      note: !sessionHook.ok
+        ? `Badge d’anonymisation Codex non enregistré (${sessionHook.reason}).`
+        : !protectionHook.ok
+        ? `Protection des pièces Codex non enregistrée (${protectionHook.reason}).`
+        : `${result.conflicts.length} skill(s) Codex personnel(s) homonyme(s) conservé(s).`,
+    };
+  }
+  return { status: 'done', note: 'Skills et badge PieceMaker disponibles à la prochaine session Codex CLI.' };
+}
+
+export async function check(_ctx, overrides = {}) {
+  const ops = dependencies(overrides);
+  if (!ops.existsSync(PLUGIN_DIR)) {
+    return { status: 'skipped', note: 'Dossier piecemaker-plugin absent.' };
+  }
+  if (!ops.commandExists('codex', ['--version'])) {
+    return { status: 'skipped', note: 'CLI "codex" introuvable.' };
+  }
+
+  const skills = ops.repositoryCodexSkills(REPO_ROOT);
+  const missing = skills.filter((relativePath) => {
+    const state = ops.codexSkillStatus(REPO_ROOT, ops.userHome, relativePath)?.state;
+    return state !== 'linked' && state !== 'copied';
+  });
+  if (missing.length) {
+    return {
+      status: 'partial',
+      note: `${missing.length} skill(s) PieceMaker non enregistré(s) dans ~/.codex/skills.`,
+    };
+  }
+  const sessionHook = ops.codexSessionHookStatus(REPO_ROOT, ops.userHome);
+  if (!sessionHook.ok) {
+    return { status: 'partial', note: `Badge d’anonymisation Codex absent ou périmé (${sessionHook.reason}).` };
+  }
+  const protectionHook = ops.codexProtectionHookStatus(REPO_ROOT, ops.userHome);
+  if (!protectionHook.ok) {
+    return { status: 'partial', note: `Protection des pièces Codex absente ou périmée (${protectionHook.reason}).` };
+  }
+  return { status: 'done', note: '' };
+}

package/server/piecemaker/vendor/installer/steps/10-libreoffice.mjs

@@ -0,0 +1,130 @@
+/**
+ * Step 10 — LibreOffice, moteur de conversion des pièces vers PDF.
+ *
+ * Une pièce Excel ou Word doit être en PDF avant d'être tamponnée
+ * (`POST /api/stamping` → `websocket-server/lib/office-to-pdf.cjs`). Les
+ * images et le texte brut sont rendus par `pdf-lib`, sans dépendance ; les
+ * formats bureautiques exigent LibreOffice en mode headless, comme le font
+ * les skills documentaires officielles d'Anthropic (`anthropics/skills`).
+ *
+ * Cette étape installe LibreOffice avec le gestionnaire de paquets du système
+ * (Homebrew, winget, apt/dnf) et enregistre SOFFICE_PATH quand le binaire
+ * n'est pas sur le PATH — sur macOS il vit dans le bundle .app.
+ */
+
+import { createRequire } from 'node:module';
+import { log, spinner } from '../lib/ui.mjs';
+import { confirm } from '../lib/prompt.mjs';
+import { commandExists, run, IS_MAC, IS_WINDOWS, REPO_ROOT } from '../lib/platform.mjs';
+import { writeEnv } from '../lib/state.mjs';
+
+const require = createRequire(import.meta.url);
+const { findSoffice } = require(`${REPO_ROOT}/websocket-server/lib/office-to-pdf.cjs`);
+
+export const meta = {
+  id: '10-libreoffice',
+  label: 'Conversion des pièces en PDF (LibreOffice)',
+  description: 'Installe LibreOffice, requis pour tamponner les pièces Excel et Word',
+};
+
+const MANUAL_URL = 'https://www.libreoffice.org/download/download-libreoffice/';
+
+/** Commande d'installation adaptée au système, ou null si aucun gestionnaire connu. */
+function installerCommand() {
+  if (IS_MAC) {
+    if (commandExists('brew')) return { command: 'brew', args: ['install', '--cask', 'libreoffice'], manager: 'Homebrew' };
+    return null;
+  }
+  if (IS_WINDOWS) {
+    if (commandExists('winget', ['--version'])) {
+      return {
+        command: 'winget',
+        args: ['install', '-e', '--id', 'TheDocumentFoundation.LibreOffice',
+          '--accept-package-agreements', '--accept-source-agreements'],
+        manager: 'winget',
+      };
+    }
+    return null;
+  }
+  if (commandExists('apt-get', ['--version'])) {
+    return { command: 'sudo', args: ['apt-get', 'install', '-y', 'libreoffice'], manager: 'apt' };
+  }
+  if (commandExists('dnf', ['--version'])) {
+    return { command: 'sudo', args: ['dnf', 'install', '-y', 'libreoffice'], manager: 'dnf' };
+  }
+  return null;
+}
+
+/** Enregistre SOFFICE_PATH si le binaire n'est pas joignable par son nom seul. */
+function recordPath(soffice) {
+  if (soffice === 'soffice' || soffice === 'libreoffice') return;
+  writeEnv({ SOFFICE_PATH: soffice });
+  log.detail(`SOFFICE_PATH enregistré : ${soffice}`);
+}
+
+export async function install(ctx) {
+  log.step('Vérification de LibreOffice...');
+
+  const existing = findSoffice();
+  if (existing) {
+    log.ok(`LibreOffice déjà installé (${existing})`);
+    recordPath(existing);
+    return { status: 'done', note: '' };
+  }
+
+  const installer = installerCommand();
+
+  if (ctx.dryRun) {
+    log.info(installer
+      ? `[simulation] ${installer.command} ${installer.args.join(' ')}`
+      : `[simulation] Installation manuelle depuis ${MANUAL_URL}`);
+    return { status: 'skipped', note: 'Mode simulation — aucune modification effectuée.' };
+  }
+
+  if (!installer) {
+    log.warn('Aucun gestionnaire de paquets reconnu pour installer LibreOffice automatiquement.');
+    log.detail(`Installez-le depuis ${MANUAL_URL}, puis relancez cette étape.`);
+    log.detail('Binaire déjà présent ailleurs ? Renseignez SOFFICE_PATH dans .env');
+    return {
+      status: 'failed',
+      note: `LibreOffice absent — installation manuelle requise (${MANUAL_URL}). Les pièces Excel et Word ne pourront pas être tamponnées.`,
+    };
+  }
+
+  log.info('LibreOffice convertit les pièces Excel et Word en PDF avant tamponnage (téléchargement de plusieurs centaines de Mo).');
+  const accepted = await confirm(`Installer LibreOffice via ${installer.manager} ?`, true);
+  if (!accepted) {
+    return {
+      status: 'partial',
+      note: 'LibreOffice non installé — seules les pièces PDF, images et texte pourront être tamponnées.',
+    };
+  }
+
+  const spin = spinner(`Installation de LibreOffice (${installer.manager})...`);
+  const code = await run(installer.command, installer.args, {
+    onLine: (line) => spin.update(line.slice(0, 100)),
+  });
+
+  const soffice = findSoffice();
+  if (code === 0 && soffice) {
+    spin.succeed(`LibreOffice installé (${soffice})`);
+    recordPath(soffice);
+    return { status: 'done', note: '' };
+  }
+
+  spin.fail('Installation de LibreOffice échouée');
+  log.detail(`Installez-le manuellement depuis ${MANUAL_URL}, puis relancez cette étape.`);
+  return {
+    status: 'failed',
+    note: `LibreOffice n'a pas pu être installé automatiquement (${installer.manager}, code ${code}). Installation manuelle : ${MANUAL_URL}`,
+  };
+}
+
+export async function check() {
+  const soffice = findSoffice();
+  if (soffice) return { status: 'done', note: '' };
+  return {
+    status: 'failed',
+    note: 'LibreOffice introuvable — les pièces Excel et Word ne pourront pas être converties en PDF pour le tamponnage.',
+  };
+}

package/server/piecemaker/vendor/installer/steps/10-pandoc.mjs

@@ -0,0 +1,212 @@
+/**
+ * Step 10 — pandoc et typst, moteurs de la voie génération (PDF/DOCX).
+ *
+ * Distinct du tamponnage (pièces du client, toujours LibreOffice via
+ * `10-libreoffice.mjs`) : ici il s'agit d'exporter en PDF/DOCX un HTML que
+ * PieceMaker écrit lui-même — la chronologie et l'historique mensuel. pandoc
+ * convertit ce HTML en DOCX (et pilote typst pour le PDF), avec de vrais
+ * styles Word et une bien meilleure typographie qu'un simple export
+ * navigateur.
+ *
+ * pandoc et typst sont **facultatifs** : sans eux, l'export retombe
+ * entièrement sur LibreOffice et reste pleinement fonctionnel, seule la
+ * qualité du rendu baisse. Cette étape ne renvoie donc jamais `failed` —
+ * même un échec d'installation aboutit à `partial`, avec une note qui
+ * explique le repli plutôt que d'alarmer inutilement `piecemaker doctor`.
+ */
+
+import { createRequire } from 'node:module';
+import { log, spinner } from '../lib/ui.mjs';
+import { confirm } from '../lib/prompt.mjs';
+import { commandExists, run, IS_MAC, IS_WINDOWS, REPO_ROOT } from '../lib/platform.mjs';
+import { writeEnv } from '../lib/state.mjs';
+
+const require = createRequire(import.meta.url);
+const { findPandoc, findTypst } = require(`${REPO_ROOT}/websocket-server/lib/doc-generate.cjs`);
+
+export const meta = {
+  id: '10-pandoc',
+  label: 'Génération PDF/DOCX (pandoc + typst)',
+  description: "Installe pandoc et typst, utilisés pour l'export de la chronologie et de l'historique",
+};
+
+const PANDOC_MANUAL_URL = 'https://pandoc.org/installing.html';
+const TYPST_MANUAL_URL = 'https://github.com/typst/typst/releases';
+
+/** Commande d'installation de pandoc adaptée au système, ou null. */
+function pandocInstaller() {
+  if (IS_MAC) {
+    if (commandExists('brew')) return { command: 'brew', args: ['install', 'pandoc'], manager: 'Homebrew' };
+    return null;
+  }
+  if (IS_WINDOWS) {
+    if (commandExists('winget', ['--version'])) {
+      return {
+        command: 'winget',
+        args: ['install', '-e', '--id', 'JohnMacFarlane.Pandoc',
+          '--accept-package-agreements', '--accept-source-agreements'],
+        manager: 'winget',
+      };
+    }
+    return null;
+  }
+  if (commandExists('apt-get', ['--version'])) {
+    return { command: 'sudo', args: ['apt-get', 'install', '-y', 'pandoc'], manager: 'apt' };
+  }
+  if (commandExists('dnf', ['--version'])) {
+    return { command: 'sudo', args: ['dnf', 'install', '-y', 'pandoc'], manager: 'dnf' };
+  }
+  return null;
+}
+
+/**
+ * Commande d'installation de typst, ou null.
+ * Sur Linux, aucune distribution courante ne le paquette : on ne tente rien,
+ * on journalise l'adresse des binaires officiels.
+ */
+function typstInstaller() {
+  if (IS_MAC) {
+    if (commandExists('brew')) return { command: 'brew', args: ['install', 'typst'], manager: 'Homebrew' };
+    return null;
+  }
+  if (IS_WINDOWS) {
+    if (commandExists('winget', ['--version'])) {
+      return {
+        command: 'winget',
+        args: ['install', '-e', '--id', 'Typst.Typst',
+          '--accept-package-agreements', '--accept-source-agreements'],
+        manager: 'winget',
+      };
+    }
+    return null;
+  }
+  return null;
+}
+
+/** Enregistre <ENV_KEY> si le binaire n'est pas joignable par son nom seul. */
+function recordPath(bareName, resolvedPath, envKey) {
+  if (resolvedPath === bareName) return;
+  writeEnv({ [envKey]: resolvedPath });
+  log.detail(`${envKey} enregistré : ${resolvedPath}`);
+}
+
+/**
+ * Installe un outil facultatif (pandoc ou typst) si un gestionnaire de
+ * paquets est disponible et que l'utilisateur accepte. Ne renvoie jamais
+ * d'échec bloquant : au pire, l'outil reste absent et l'appelant le note.
+ */
+async function ensureTool({ name, find, installer, manualUrl, usage }) {
+  if (!installer) {
+    log.warn(`${name} introuvable — aucun gestionnaire de paquets reconnu pour l'installer automatiquement.`);
+    log.detail(`Binaires officiels : ${manualUrl}`);
+    return null;
+  }
+
+  log.info(usage);
+  const accepted = await confirm(`Installer ${name} via ${installer.manager} ?`, true);
+  if (!accepted) {
+    log.detail(`${name} non installé — relancez cette étape pour réessayer.`);
+    return null;
+  }
+
+  const spin = spinner(`Installation de ${name} (${installer.manager})...`);
+  const code = await run(installer.command, installer.args, {
+    onLine: (line) => spin.update(line.slice(0, 100)),
+  });
+
+  const resolved = find();
+  if (code === 0 && resolved) {
+    spin.succeed(`${name} installé (${resolved})`);
+    return resolved;
+  }
+
+  spin.fail(`Installation de ${name} échouée`);
+  log.detail(`Installez-le manuellement depuis ${manualUrl}, puis relancez cette étape.`);
+  return null;
+}
+
+export async function install(ctx) {
+  log.step('Vérification de pandoc et typst...');
+
+  const existingPandoc = findPandoc();
+  const existingTypst = findTypst();
+
+  if (ctx.dryRun) {
+    if (!existingPandoc) {
+      const installer = pandocInstaller();
+      log.info(installer
+        ? `[simulation] ${installer.command} ${installer.args.join(' ')}`
+        : `[simulation] Installation manuelle de pandoc depuis ${PANDOC_MANUAL_URL}`);
+    } else {
+      log.info(`[simulation] pandoc déjà présent (${existingPandoc})`);
+    }
+    if (!existingTypst) {
+      const installer = typstInstaller();
+      log.info(installer
+        ? `[simulation] ${installer.command} ${installer.args.join(' ')}`
+        : `[simulation] Installation manuelle de typst depuis ${TYPST_MANUAL_URL}`);
+    } else {
+      log.info(`[simulation] typst déjà présent (${existingTypst})`);
+    }
+    return { status: 'skipped', note: 'Mode simulation — aucune modification effectuée.' };
+  }
+
+  let pandoc = existingPandoc;
+  if (pandoc) {
+    log.ok(`pandoc déjà installé (${pandoc})`);
+  } else {
+    pandoc = await ensureTool({
+      name: 'pandoc',
+      find: findPandoc,
+      installer: pandocInstaller(),
+      manualUrl: PANDOC_MANUAL_URL,
+      usage: "pandoc convertit le HTML de la chronologie et de l'historique en DOCX pour l'export (léger, quelques Mo).",
+    });
+  }
+  if (pandoc) recordPath('pandoc', pandoc, 'PANDOC_PATH');
+
+  let typst = existingTypst;
+  if (typst) {
+    log.ok(`typst déjà installé (${typst})`);
+  } else {
+    typst = await ensureTool({
+      name: 'typst',
+      find: findTypst,
+      installer: typstInstaller(),
+      manualUrl: TYPST_MANUAL_URL,
+      usage: 'typst sert de moteur PDF à pandoc pour un export direct et soigné (léger, un seul binaire).',
+    });
+  }
+  if (typst) recordPath('typst', typst, 'TYPST_PATH');
+
+  if (pandoc && typst) {
+    return { status: 'done', note: '' };
+  }
+  if (pandoc && !typst) {
+    return {
+      status: 'partial',
+      note: "typst absent — ce n'est pas un échec : le PDF de la chronologie et de l'historique passera par pandoc→DOCX puis LibreOffice, ce qui reste pleinement fonctionnel (rendu un peu moins soigné). Réessayer : node installer/bin/piecemaker.mjs --step 10-pandoc",
+    };
+  }
+  return {
+    status: 'partial',
+    note: "pandoc absent — ce n'est pas un échec : les exports de la chronologie et de l'historique retombent entièrement sur LibreOffice et restent pleinement fonctionnels, avec une qualité de rendu moindre. Réessayer : node installer/bin/piecemaker.mjs --step 10-pandoc",
+  };
+}
+
+export async function check() {
+  const pandoc = findPandoc();
+  const typst = findTypst();
+
+  if (pandoc && typst) return { status: 'done', note: '' };
+  if (pandoc && !typst) {
+    return {
+      status: 'partial',
+      note: "typst absent — ce n'est pas un échec : le PDF de la chronologie et de l'historique passera par pandoc→DOCX puis LibreOffice, ce qui reste pleinement fonctionnel.",
+    };
+  }
+  return {
+    status: 'partial',
+    note: "pandoc absent — ce n'est pas un échec : les exports de la chronologie et de l'historique retombent entièrement sur LibreOffice et restent pleinement fonctionnels.",
+  };
+}

package/server/piecemaker/vendor/installer/steps/11-docx-cli.mjs

@@ -0,0 +1,144 @@
+/**
+ * Étape 11 — outil `.docx` : le plugin `docx-cli` (kklimuk/docx-cli).
+ *
+ * PieceMaker manipule des documents Word de bout en bout : les pièces d'un
+ * dossier, et les actes rédigés pour le cabinet. `docx-cli` remplace le skill
+ * `document-skills:docx` d'Anthropic : au lieu de dépaqueter l'OOXML à la main
+ * (`unzip`/`zip` + `pandoc`), il expose un binaire `docx` qui mute le XML
+ * **en place** — les styles maison, les couleurs de thème et les objets
+ * embarqués survivent — et adresse le contenu par localisateurs stables. Le
+ * mode « modifications suivies » (`docx track-changes`), requis pour un acte
+ * juridique qu'un tiers doit relire, est un verbe de premier plan.
+ *
+ * Il travaille entièrement par Bash. C'est pour cela que le garde-fou
+ * `protect-originals.mjs` inspecte les commandes shell : sans cela, un
+ * `docx read pièce.docx` contournerait la protection des pièces.
+ *
+ * Trois choses, toutes idempotentes :
+ *   1. enregistrer le marketplace `kklimuk/docx-cli` ;
+ *   2. installer `docx-cli@docx-cli` ;
+ *   3. l'activer — une installation antérieure a pu le laisser désactivé dans
+ *      ~/.claude/settings.json, et `install` ne réactive pas tout seul.
+ *
+ * Le binaire `docx` lui-même n'est pas installé ici : le skill embarque son
+ * `scripts/bootstrap.sh`, qui résout la dernière version publiée, la télécharge
+ * épinglée au tag et vérifie son SHA-256 avant de la poser sur le PATH. On se
+ * contente de signaler son absence.
+ */
+
+import { log, spinner } from '../lib/ui.mjs';
+import { commandExists, run, runCapture } from '../lib/platform.mjs';
+
+export const meta = {
+  id: '11-docx-cli',
+  label: 'Outil docx-cli (documents Word)',
+  description: 'Installe et active le plugin docx-cli, qui pilote les .docx via le binaire « docx »',
+};
+
+const MARKETPLACE_NAME = 'docx-cli';
+const MARKETPLACE_REPO = 'kklimuk/docx-cli';
+const PLUGIN_NAME = 'docx-cli';
+const PLUGIN_SPEC = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+
+function parseJson(raw, fallback = null) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+function listMarketplaces() {
+  const result = runCapture('claude', ['plugin', 'marketplace', 'list', '--json']);
+  return result.code === 0 ? parseJson(result.stdout) : null;
+}
+
+function findPlugin(plugins) {
+  if (!Array.isArray(plugins)) return null;
+  return plugins.find((plugin) => plugin.id === PLUGIN_SPEC || plugin.name === PLUGIN_NAME) || null;
+}
+
+function pluginState() {
+  const result = runCapture('claude', ['plugin', 'list', '--json']);
+  if (result.code !== 0) return { installed: false, enabled: false, known: false };
+  const plugin = findPlugin(parseJson(result.stdout));
+  return { installed: Boolean(plugin), enabled: Boolean(plugin) && plugin.enabled !== false, known: true };
+}
+
+function binaryPresent() {
+  return commandExists('docx', ['--version']);
+}
+
+export async function install() {
+  if (!commandExists('claude', ['--version'])) {
+    log.warn('CLI « claude » introuvable : docx-cli ne peut pas être installé.');
+    return { status: 'skipped', note: 'CLI "claude" introuvable.' };
+  }
+
+  const marketplaces = listMarketplaces();
+  const registered = Array.isArray(marketplaces)
+    && marketplaces.some((marketplace) => marketplace.name === MARKETPLACE_NAME);
+
+  if (!registered) {
+    const spin = spinner(`Enregistrement du marketplace ${MARKETPLACE_REPO}...`);
+    const code = await run('claude', ['plugin', 'marketplace', 'add', MARKETPLACE_REPO]);
+    if (code !== 0) {
+      spin.fail('Échec de l\'enregistrement du marketplace docx-cli.');
+      return { status: 'failed', note: `Impossible d'enregistrer ${MARKETPLACE_REPO}.` };
+    }
+    spin.succeed('Marketplace docx-cli enregistré.');
+  } else {
+    log.ok(`Marketplace « ${MARKETPLACE_NAME} » déjà enregistré.`);
+  }
+
+  let state = pluginState();
+  if (!state.installed) {
+    const spin = spinner(`Installation du plugin ${PLUGIN_SPEC}...`);
+    const code = await run('claude', ['plugin', 'install', PLUGIN_SPEC]);
+    if (code !== 0) {
+      spin.fail('Échec de l\'installation du plugin docx-cli.');
+      return { status: 'failed', note: `Impossible d'installer ${PLUGIN_SPEC}.` };
+    }
+    spin.succeed('Plugin docx-cli installé.');
+    state = pluginState();
+  } else {
+    log.ok(`Plugin « ${PLUGIN_SPEC} » déjà installé.`);
+  }
+
+  // Un plugin installé puis désactivé reste dans `enabledPlugins` à `false` :
+  // `install` ne le rallume pas, seul `enable` le fait.
+  if (!state.enabled) {
+    const spin = spinner('Activation du plugin docx-cli...');
+    const code = await run('claude', ['plugin', 'enable', PLUGIN_SPEC]);
+    if (code !== 0) {
+      spin.fail('Le plugin est installé mais n\'a pas pu être activé.');
+      return { status: 'partial', note: `Activez-le à la main : claude plugin enable ${PLUGIN_SPEC}` };
+    }
+    spin.succeed('Plugin docx-cli activé.');
+  } else {
+    log.ok('Plugin docx-cli déjà activé.');
+  }
+
+  if (binaryPresent()) {
+    log.ok('Binaire « docx » présent sur le PATH.');
+  } else {
+    log.info('Binaire « docx » absent : le skill l\'installera (SHA-256 vérifié) à sa première activation.');
+  }
+
+  log.info('Le skill « docx-cli » sera disponible à la prochaine session Claude Code.');
+  return { status: 'done', note: '' };
+}
+
+export async function check() {
+  if (!commandExists('claude', ['--version'])) {
+    return { status: 'skipped', note: 'CLI "claude" introuvable.' };
+  }
+  const state = pluginState();
+  if (!state.known) return { status: 'failed', note: 'La CLI claude n\'a pas pu lister les plugins.' };
+  if (!state.installed) return { status: 'failed', note: `Plugin ${PLUGIN_SPEC} non installé.` };
+  if (!state.enabled) return { status: 'partial', note: `Plugin installé mais désactivé (claude plugin enable ${PLUGIN_SPEC}).` };
+  if (!binaryPresent()) {
+    return { status: 'done', note: 'Binaire « docx » pas encore posé : le skill l\'installe à sa première activation.' };
+  }
+  return { status: 'done', note: '' };
+}