@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/harness/verification.cjs

@@ -0,0 +1,159 @@
+'use strict';
+
+/**
+ * Vérification mécanique des citations d'un tour de chat — équivalent
+ * serveur du hook Stop `verify-citations.mjs` de l'autre dépôt
+ * (`piecemaker-plugin/scripts/verify-citations.mjs`).
+ *
+ * Ce dépôt n'a pas de hook Claude Code : tout le trafic IA passe par le
+ * proxy PII local (`server/piecemaker/anonymizer/proxy.cjs`), qui est donc
+ * l'unique point d'observation possible pour un texte produit par le modèle.
+ * Contrairement au hook d'origine, ce module n'a pas le pouvoir de bloquer
+ * un tour (il n'y a pas de conversation Claude Code à interrompre côté
+ * proxy) : il se contente d'observer, de vérifier mécaniquement et de
+ * journaliser — le blocage éventuel reste une décision de l'appelant
+ * (câblage laissé à une tâche ultérieure).
+ *
+ * Enchaînement, fidèle à Mike et au hook d'origine : détection du bloc
+ * `<CITATIONS>` (cas de très loin le plus fréquent : absent, silence total)
+ * → parse (`citations.cjs`) → résolution des sources (`citation-sources.cjs`,
+ * décisions Légifrance + pièces du dossier) → vérification mécanique
+ * (`verify-citations.cjs`) → journalisation dans
+ * `<homeDir>/citations-verifiees.jsonl`.
+ *
+ * Garantie de confidentialité : le journal ne contient JAMAIS le texte d'une
+ * citation ni celui d'une source — seulement des identifiants et un motif
+ * d'échec parmi trois valeurs fixes (« source inconnue », « source
+ * illisible », « introuvable dans la source »).
+ *
+ * Ne jette jamais : toute erreur inattendue (bloc malformé compris) retombe
+ * sur `{ analysee: false, citations: 0, nonVerifiees: 0, details: [] }`.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { parseCitationsWithDiagnostics } = require('../vendor/piecemaker-plugin/scripts/lib/citations.cjs');
+const { verifyCitations, UNREADABLE_SOURCES } = require('../vendor/piecemaker-plugin/scripts/lib/verify-citations.cjs');
+const {
+  createDecisionTextResolver,
+  createDocumentTextResolver,
+} = require('../vendor/piecemaker-plugin/scripts/lib/citation-sources.cjs');
+
+const LOG_FILE_NAME = 'citations-verifiees.jsonl';
+
+function emptyResult() {
+  return { analysee: false, citations: 0, nonVerifiees: 0, details: [] };
+}
+
+/** mkdir -p qui ne jette jamais. */
+function ensureDirSafe(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Identifiant lisible d'une citation pour le journal. */
+function citationIdentifier(citation) {
+  if (citation?.kind === 'case') return `decision:${citation.decision_id ?? '?'}#${citation.ref ?? '?'}`;
+  return `document:${citation?.doc_id ?? '?'}#${citation?.ref ?? '?'}`;
+}
+
+/**
+ * Reclasse l'échec d'une citation en rappelant la source qui a servi (ou pas)
+ * à sa vérification — jamais un LLM, purement mécanique. Trois motifs, sans
+ * jamais exposer de texte : source inconnue (résolveur vide : identifiant
+ * introuvable), source illisible (sentinelle `UNREADABLE_SOURCES`), ou
+ * introuvable dans la source (la source existe mais ne contient pas la
+ * citation, même tolérante aux espaces/casse/ponctuation).
+ */
+async function classifyFailureReason(citation, getSourceText, getDecisionText) {
+  let source = '';
+  try {
+    source = citation.kind === 'case'
+      ? await getDecisionText(citation.decision_id)
+      : await getSourceText(citation.doc_id);
+  } catch {
+    source = '';
+  }
+  const text = typeof source === 'string' ? source : '';
+  if (!text) return 'source inconnue';
+  if (UNREADABLE_SOURCES.has(text)) return 'source illisible';
+  return 'introuvable dans la source';
+}
+
+/** Journalise une ligne — jamais de texte de citation ni de source. */
+function logVerification(homeDir, entry) {
+  if (typeof homeDir !== 'string' || !homeDir) return;
+  try {
+    ensureDirSafe(homeDir);
+    fs.appendFileSync(path.join(homeDir, LOG_FILE_NAME), `${JSON.stringify(entry)}\n`, 'utf8');
+  } catch {
+    // Une panne du journal ne doit jamais faire échouer la vérification.
+  }
+}
+
+/**
+ * Vérifie les citations du bloc `<CITATIONS>` d'un message d'assistant.
+ *
+ * @param {string} texteAssistant Dernier message produit par le modèle.
+ * @param {object} [options]
+ * @param {string} [options.homeDir] Dossier où journaliser (`~/.piecemaker` typiquement).
+ * @param {string|null} [options.session] Identifiant d'session, purement informatif.
+ * @param {{getDecisionText: Function, getSourceText: Function}} [options.resolvers]
+ *   Résolveurs de source injectables (tests) ; par défaut, ceux de
+ *   `citation-sources.cjs` sur le répertoire courant.
+ * @returns {Promise<{analysee: boolean, citations: number, nonVerifiees: number, details: Array}>}
+ */
+async function verifierReponse(texteAssistant, options = {}) {
+  try {
+    if (typeof texteAssistant !== 'string' || !texteAssistant) return emptyResult();
+
+    const { citations, diagnostics } = parseCitationsWithDiagnostics(texteAssistant);
+    if (!diagnostics.hasBlock) return emptyResult(); // cas de très loin le plus fréquent
+
+    const { homeDir, session, resolvers } = options;
+    const getDecisionText = resolvers?.getDecisionText || createDecisionTextResolver([process.cwd()]);
+    const getSourceText = resolvers?.getSourceText || createDocumentTextResolver(process.cwd());
+
+    let verified = [];
+    try {
+      verified = await verifyCitations(citations, getSourceText, getDecisionText);
+    } catch {
+      verified = [];
+    }
+
+    const details = [];
+    let nonVerifiees = 0;
+    for (const citation of verified) {
+      const id = citationIdentifier(citation);
+      if (citation?.verified === false) {
+        nonVerifiees += 1;
+        const motif = await classifyFailureReason(citation, getSourceText, getDecisionText);
+        details.push({ id, verified: false, motif });
+      } else {
+        details.push({ id, verified: true, motif: null });
+      }
+    }
+
+    logVerification(homeDir, {
+      session_id: session || null,
+      at: new Date().toISOString(),
+      citations: verified.length,
+      non_verifiees: nonVerifiees,
+      details,
+    });
+
+    return { analysee: true, citations: verified.length, nonVerifiees, details };
+  } catch {
+    return emptyResult();
+  }
+}
+
+module.exports = {
+  LOG_FILE_NAME,
+  verifierReponse,
+};

package/server/piecemaker/index.ts

@@ -0,0 +1,59 @@
+import { createRequire } from 'module';
+import path from 'path';
+
+import type { Router } from 'express';
+
+import { providerRuntimeService, sessionsService } from '@/modules/providers/index.js';
+import { findApplicationRoot, getModuleDirectory } from '@/shared/utils.js';
+
+import { startRequiredAnonymizer } from './anonymizer/lifecycle.js';
+import { createCitationStore } from './harness/citation-store.js';
+import { installChatCitationHarness } from './harness/chat-harness.js';
+import { createCitationsRouter } from './harness/citations.routes.js';
+import { startLibraryBackend, installLibraryRuntime } from './library/index.js';
+import { createTimesheetBackend } from './timesheet/index.js';
+
+/**
+ * Point d'entrée PieceMaker. Les modules de `server/piecemaker/vendor/` sont du
+ * CommonJS : `createRequire` les charge tels quels, sans les convertir ni les
+ * faire passer par `tsc`.
+ *
+ * Le chemin est résolu depuis la racine applicative, pas depuis `__dirname` :
+ * compilé, ce fichier vit sous `dist-server/server/piecemaker/`, alors que le
+ * `vendor/` (CommonJS, Python, gabarits Markdown) reste dans l'arbre source.
+ */
+const applicationRoot = findApplicationRoot(getModuleDirectory(import.meta.url));
+const routerPath = path.join(applicationRoot, 'server', 'piecemaker', 'router.cjs');
+
+type PieceMakerRuntimeStatus = {
+  port?: number | string;
+  host?: string;
+  libreOffice?: boolean;
+};
+
+type PieceMakerVendorModule = {
+  createPieceMakerRouter(options?: { getRuntimeStatus?: () => PieceMakerRuntimeStatus; anonymizer?: unknown }): Router;
+  piecemakerHome(): string;
+};
+
+const vendor = createRequire(import.meta.url)(routerPath) as PieceMakerVendorModule;
+
+export const { piecemakerHome } = vendor;
+const { createAnonymizerService } = createRequire(import.meta.url)(path.join(applicationRoot, 'server/piecemaker/anonymizer/service.cjs'));
+const anonymizer = createAnonymizerService({ homeDir: piecemakerHome(), required: true });
+const ensureProxy = await startRequiredAnonymizer(anonymizer);
+const citations = createCitationStore(piecemakerHome());
+installChatCitationHarness({ runtime: providerRuntimeService, sessions: sessionsService, store: citations, ensureProxy });
+const library = await startLibraryBackend(piecemakerHome(), applicationRoot);
+installLibraryRuntime(providerRuntimeService, sessionsService, library);
+const timesheet = createTimesheetBackend(piecemakerHome());
+
+export function createPieceMakerRouter(options: { getRuntimeStatus?: () => PieceMakerRuntimeStatus } = {}) {
+  const router = vendor.createPieceMakerRouter({ ...options, anonymizer });
+  router.use(createCitationsRouter(citations, (id) => {
+    try { sessionsService.getSessionDetailsById(id); return true; } catch { return false; }
+  }));
+  router.use(timesheet);
+  return router;
+}
+export type { PieceMakerRuntimeStatus };

package/server/piecemaker/library/index.ts

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { createRequire } from 'node:module';
+
+import express from 'express';
+
+import { createLibraryStore } from './store.js';
+import { createLibraryRouter } from './routes.js';
+import { createLibraryMarketplaceRouter, scanInstalledLibraryCollections } from './marketplace.js';
+import { scanAndPersistLibraryProviderSkills } from './provider-skills.js';
+
+export { installLibraryRuntime } from './runtime.js';
+
+export async function startLibraryBackend(home: string, applicationRoot: string) {
+  const store = createLibraryStore(home);
+  try { await scanAndPersistLibraryProviderSkills(store, undefined); } catch {}
+  try { scanInstalledLibraryCollections(store, os.homedir()); } catch {}
+  const require = createRequire(import.meta.url);
+  const { createActivationRouter } = require(path.join(applicationRoot, 'server/piecemaker/activation/index.cjs'));
+  const options = { repoRoot: path.join(applicationRoot, 'server/piecemaker/vendor'), piecemakerHome: home, homeDir: home, userHome: os.homedir(), isOriginAllowed: () => true };
+  const token = randomBytes(32).toString('hex');
+  const app = express();
+  app.use((req, res, next) => {
+    if (req.headers.authorization !== `Bearer ${token}`) { res.sendStatus(401); return; }
+    res.setHeader('Cache-Control', 'no-store');
+    next();
+  });
+  app.use(express.json({ limit: '1mb' }));
+  app.use(createLibraryRouter(store));
+  app.use(createLibraryMarketplaceRouter(store, applicationRoot, os.homedir()));
+  app.use((req, res, next) => {
+    if ((req.method === 'GET' && req.path === '/activation')
+      || (req.method === 'POST' && req.path === '/activation/toggle')) { next(); return; }
+    res.sendStatus(404);
+  });
+  app.use(createActivationRouter(options));
+  const server = app.listen(0, '127.0.0.1');
+  await new Promise<void>((resolve, reject) => { server.once('listening', resolve); server.once('error', reject); });
+  const address = server.address();
+  if (!address || typeof address === 'string') throw new Error('Bibliothèque indisponible.');
+  const connection = path.join(store.directory, 'connection.json');
+  const temporary = `${connection}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, JSON.stringify({ port: address.port, token }), { mode: 0o600 });
+  fs.renameSync(temporary, connection);
+  server.unref();
+  process.once('exit', () => {
+    try {
+      if (JSON.parse(fs.readFileSync(connection, 'utf8')).token === token) fs.unlinkSync(connection);
+    } catch {}
+  });
+  return store;
+}

package/server/piecemaker/library/marketplace.ts

@@ -0,0 +1,152 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+
+import express from 'express';
+
+import type { createLibraryStore } from './store.js';
+import { importLibraryDirectory } from './migrate.js';
+
+export function scanInstalledLibraryCollections(store: ReturnType<typeof createLibraryStore>, userHome: string) {
+  const filename = path.join(userHome, '.claude/plugins/installed_plugins.json');
+  const registry = fs.existsSync(filename) ? JSON.parse(fs.readFileSync(filename, 'utf8')).plugins || {} : {};
+  const pluginsDirectory = path.join(userHome, '.claude', 'plugins');
+  if (!fs.existsSync(pluginsDirectory) || fs.lstatSync(pluginsDirectory).isSymbolicLink()) return;
+  const pluginsRoot = fs.realpathSync(pluginsDirectory);
+  for (const [id, installs] of Object.entries(registry)) {
+    if (store.hasCollection(id)) continue;
+    if (!Array.isArray(installs)) continue;
+    const install = installs.find((entry) => entry && typeof entry.installPath === 'string') as { installPath: string } | undefined;
+    if (!install || !fs.existsSync(install.installPath)) continue;
+    const installRoot = fs.realpathSync(install.installPath);
+    if (!installRoot.startsWith(`${pluginsRoot}${path.sep}`)) continue;
+    let manifest: { name?: string; displayName?: string; description?: string } = {};
+    const manifestPath = path.join(installRoot, '.claude-plugin', 'plugin.json');
+    try { manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')); } catch {}
+    const imported = [
+      ...importLibraryDirectory(store, path.join(installRoot, 'skills'), 'skill', false),
+      ...importLibraryDirectory(store, path.join(installRoot, 'agents'), 'agent', false),
+    ];
+    const commandsDirectory = path.join(installRoot, 'commands');
+    if (fs.existsSync(commandsDirectory) && !fs.lstatSync(commandsDirectory).isSymbolicLink()) {
+      for (const command of fs.readdirSync(commandsDirectory, { withFileTypes: true })) {
+        if (!command.isFile() || !command.name.toLowerCase().endsWith('.md')) continue;
+        const source = path.join(commandsDirectory, command.name);
+        imported.push({ source, id: store.importFile(source, 'skill', false), linked: false });
+      }
+    }
+    const files: Array<{ path: string; content: Buffer }> = [];
+    let totalSize = 0;
+    const collect = (directory: string, relative = '') => {
+      for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+        if (entry.name === '.git' || entry.name === 'node_modules' || entry.name === '__pycache__' || entry.isSymbolicLink()) continue;
+        const relativePath = path.posix.join(relative.split(path.sep).join('/'), entry.name);
+        const absolutePath = path.join(directory, entry.name);
+        if (entry.isDirectory()) collect(absolutePath, relativePath);
+        else if (entry.isFile()) {
+          const content = fs.readFileSync(absolutePath);
+          totalSize += content.length;
+          if (totalSize > 30 * 1024 * 1024 || files.length >= 5000) throw new Error(`Plugin trop volumineux : ${id}`);
+          files.push({ path: relativePath, content });
+        }
+      }
+    };
+    collect(installRoot);
+    store.upsertCollection({
+      id,
+      name: manifest.displayName || manifest.name || id,
+      description: manifest.description || '',
+      source: installRoot,
+      entries: imported.map((entry) => ({
+        entryId: entry.id,
+        rootPath: path.relative(installRoot, entry.source).split(path.sep).join('/'),
+      })),
+      files,
+    });
+  }
+}
+
+export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLibraryStore>, applicationRoot: string, userHome: string) {
+  const require = createRequire(import.meta.url);
+  const { listMarketplaceConnectors, registerOfficialMarketplace } = require(path.join(applicationRoot, 'server/piecemaker/vendor/websocket-server/admin-routes.cjs'));
+  const router = express.Router();
+  const run = (command: string, args: string[], timeout = 60000) => {
+    const result = spawnSync(command, args, { encoding: 'utf8', timeout, maxBuffer: 8 * 1024 * 1024, windowsHide: true });
+    return { ok: result.status === 0, output: `${result.stdout || ''}${result.stderr || ''}`, status: result.status };
+  };
+  const scope = (value: unknown) => {
+    if (value === 'legal') return { name: 'claude-for-legal', slug: 'anthropics/claude-for-legal' };
+    if (value === 'official') return { name: 'claude-plugins-official', slug: 'anthropics/claude-plugins-official' };
+    throw new Error('Marketplace inconnue.');
+  };
+  const installed = () => {
+    const filename = path.join(userHome, '.claude/plugins/installed_plugins.json');
+    return fs.existsSync(filename) ? JSON.parse(fs.readFileSync(filename, 'utf8')).plugins || {} : {};
+  };
+  const importInstalledCollections = () => scanInstalledLibraryCollections(store, userHome);
+  const disable = (id: string) => {
+    const filename = path.join(userHome, '.claude/settings.json');
+    const settings = fs.existsSync(filename) ? JSON.parse(fs.readFileSync(filename, 'utf8')) : {};
+    settings.enabledPlugins = { ...settings.enabledPlugins, [id]: false };
+    fs.mkdirSync(path.dirname(filename), { recursive: true, mode: 0o700 });
+    const temporary = `${filename}.library.tmp`;
+    fs.writeFileSync(temporary, JSON.stringify(settings, null, 2), { mode: 0o600 });
+    fs.renameSync(temporary, filename);
+  };
+  router.get('/plugin/marketplace', (req, res) => {
+    try {
+      const marketplace = scope(req.query.scope);
+      const catalog = listMarketplaceConnectors(run, { marketplaceName: marketplace.name });
+      const registry = installed();
+      res.json({ ...catalog, plugins: catalog.plugins.map((plugin: { id: string }) => ({ ...plugin, installed: Boolean(registry[plugin.id]) })) });
+    } catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.get('/plugins', (req, res) => {
+    try {
+      res.json({ plugins: store.listCollections(typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined) });
+    } catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.post('/plugins/scan', (_req, res) => {
+    try { importInstalledCollections(); res.json({ ok: true }); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.get('/plugins/:id/files', (req, res) => {
+    try { res.json({ files: store.collectionFiles(String(req.params.id)) }); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.get('/plugins/:id/file', (req, res) => {
+    try { res.json(store.collectionFile(String(req.params.id), String(req.query.path || ''))); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.put('/plugins/:id/file', (req, res) => {
+    try { res.json(store.updateCollectionFile(String(req.params.id), req.body?.path, req.body?.content, req.body?.previousContent)); }
+    catch (error) { res.status(409).json({ error: (error as Error).message }); }
+  });
+  router.put('/plugins/:id/activation', (req, res) => {
+    try { res.json(store.setCollectionEnabled(req.body?.workspacePath, String(req.params.id), req.body?.enabled)); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.post('/plugin/marketplace/register', (req, res) => {
+    try { res.json(registerOfficialMarketplace(run, scope(req.body?.scope))); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.post('/plugin/marketplace/acquire', (req, res) => {
+    try {
+      const marketplace = scope(req.body?.scope);
+      const id = req.body?.id;
+      if (typeof id !== 'string' || !/^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+$/.test(id) || !id.endsWith(`@${marketplace.name}`)) throw new Error('Connecteur invalide.');
+      if (installed()[id]) throw new Error('Connecteur déjà installé. Son activation se règle par dossier.');
+      const catalog = listMarketplaceConnectors(run, { marketplaceName: marketplace.name });
+      if (!catalog.plugins.some((plugin: { id: string }) => plugin.id === id)) throw new Error('Connecteur absent du catalogue.');
+      disable(id);
+      let result;
+      try { result = run('claude', ['plugin', 'install', id, '--scope', 'user']); }
+      finally { disable(id); }
+      if (!result.ok) throw new Error(result.output || 'Installation impossible.');
+      importInstalledCollections();
+      res.json({ ok: true, enabled: false });
+    } catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  return router;
+}

package/server/piecemaker/library/migrate-cli.ts

@@ -0,0 +1,11 @@
+import os from 'node:os';
+import path from 'node:path';
+
+import { createLibraryStore } from './store.js';
+import { migratePersonalLibrary } from './migrate.js';
+
+const store = createLibraryStore(process.env.PIECEMAKER_HOME || path.join(os.homedir(), '.piecemaker'));
+try {
+  const imported = migratePersonalLibrary(store, os.homedir(), process.cwd(), process.argv.includes('--withdraw'));
+  process.stdout.write(`${JSON.stringify({ imported: imported.map(({ id, source }) => ({ id, source })), catalog: store.list() }, null, 2)}\n`);
+} finally { store.close(); }

package/server/piecemaker/library/migrate.ts

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { createLibraryStore } from './store.js';
+
+export function importLibraryDirectory(store: ReturnType<typeof createLibraryStore>, directory: string, kind: 'skill' | 'agent', followLinks = true) {
+  if (!fs.existsSync(directory)) return [];
+  if (!followLinks && fs.lstatSync(directory).isSymbolicLink()) return [];
+  const imported: Array<{ source: string; id: string; linked: boolean }> = [];
+  for (const item of fs.readdirSync(directory, { withFileTypes: true })) {
+    if (item.name.startsWith('.')) continue;
+    const source = path.join(directory, item.name);
+    const file = kind === 'skill' ? path.join(source, 'SKILL.md') : source;
+    if (!fs.existsSync(file) || !fs.statSync(file).isFile() || (kind === 'agent' && !file.endsWith('.md'))) continue;
+    if (!followLinks && (item.isSymbolicLink() || fs.lstatSync(file).isSymbolicLink())) continue;
+    const id = store.importFile(file, kind);
+    if (store.document(id).content !== fs.readFileSync(file, 'utf8')) throw new Error(`Import non vérifié : ${source}`);
+    imported.push({ source, id, linked: item.isSymbolicLink() });
+  }
+  return imported;
+}
+
+export function migratePersonalLibrary(store: ReturnType<typeof createLibraryStore>, userHome: string, applicationRoot: string, withdraw = false) {
+  const imported = [];
+  for (const folder of ['assistant-workflows', 'tabular-review-workflows']) {
+    imported.push(...importLibraryDirectory(store, path.join(applicationRoot, 'server/piecemaker/vendor/mike-defaults-fr', folder), 'skill'));
+  }
+  for (const [directory, kind] of [
+    [path.join(userHome, '.claude', 'skills'), 'skill'],
+    [path.join(userHome, '.codex', 'skills'), 'skill'],
+    [path.join(userHome, '.agents', 'skills'), 'skill'],
+    [path.join(userHome, '.claude', 'agents'), 'agent'],
+    [path.join(userHome, '.piecemaker', 'library', 'skills'), 'skill'],
+    [path.join(userHome, '.piecemaker', 'library', 'agents'), 'agent'],
+  ] as const) imported.push(...importLibraryDirectory(store, directory, kind));
+  if (withdraw) {
+    const candidates = imported.filter((entry) => ['.claude', '.codex', '.agents'].some((provider) => entry.source.startsWith(path.join(userHome, provider) + path.sep)));
+    const backup = path.join(store.directory, `migration-${Date.now()}`);
+    fs.mkdirSync(backup, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(path.join(backup, 'manifest.json'), JSON.stringify(candidates, null, 2), { mode: 0o600 });
+    for (const entry of candidates.sort((a, b) => Number(b.linked) - Number(a.linked))) {
+      const destination = path.join(backup, path.relative(userHome, entry.source));
+      fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
+      fs.renameSync(entry.source, destination);
+    }
+    fs.writeFileSync(path.join(store.directory, 'centralized.json'), JSON.stringify({ migratedAt: new Date().toISOString(), count: candidates.length }), { mode: 0o600 });
+  }
+  return imported;
+}

package/server/piecemaker/library/policy.cjs

@@ -0,0 +1,9 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+function libraryIsCentralized(userHome) {
+  const home = process.env.PIECEMAKER_HOME || path.join(userHome, '.piecemaker');
+  return fs.existsSync(path.join(home, 'library-backend', 'centralized.json'));
+}
+
+module.exports = { libraryIsCentralized };

package/server/piecemaker/library/provider-skills.test.ts

@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import type { LLMProvider } from '@/shared/types.js';
+
+import { listLibraryProviderSkills, scanAndPersistLibraryProviderSkills } from './provider-skills.js';
+import { createLibraryStore } from './store.js';
+
+test('library provider skills include every provider and isolate failures', async () => {
+  const calls: Array<{ provider: string; workspacePath: string | undefined }> = [];
+  const reader = {
+    async listProviderSkills(provider: string, options?: { workspacePath?: string }) {
+      calls.push({ provider, workspacePath: options?.workspacePath });
+      if (provider === 'cursor') throw new Error('Cursor indisponible');
+      return [{ provider: provider as LLMProvider, name: `${provider}-skill`, description: '', command: `/${provider}`, scope: 'user' as const, sourcePath: `/${provider}/SKILL.md` }];
+    },
+  };
+
+  const result = await listLibraryProviderSkills('/dossier', reader);
+
+  assert.deepEqual(calls.map(({ provider }) => provider), ['claude', 'codex', 'cursor', 'mistral', 'opencode']);
+  assert.ok(calls.every(({ workspacePath }) => workspacePath === '/dossier'));
+  assert.equal(result.providers.find(({ provider }) => provider === 'cursor')?.error, 'Cursor indisponible');
+  assert.deepEqual(result.providers.find(({ provider }) => provider === 'cursor')?.skills, []);
+  assert.equal(result.providers.filter(({ skills }) => skills.length === 1).length, 4);
+});
+
+test('provider skill scans persist the catalogue without duplicating or replacing edits', async (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pm-library-scan-'));
+  const source = path.join(root, 'SKILL.md');
+  const store = createLibraryStore(path.join(root, '.piecemaker'));
+  t.after(() => { store.close(); fs.rmSync(root, { recursive: true, force: true }); });
+  fs.writeFileSync(source, '---\nname: Relire\ndescription: Initiale\n---\nInstructions initiales.');
+  const reader = {
+    async listProviderSkills(provider: string) {
+      if (provider !== 'claude') return [];
+      return [{ provider: 'claude' as const, name: 'Relire', description: 'Initiale', command: '/relire', scope: 'user' as const, sourcePath: source }];
+    },
+  };
+
+  const listed = await listLibraryProviderSkills(undefined, reader);
+  assert.equal(listed.providers[0].skills[0].sourcePath, source);
+  assert.equal(store.list().length, 0);
+  await scanAndPersistLibraryProviderSkills(store, undefined, reader);
+  const first = store.list();
+  assert.equal(first.length, 1);
+  const id = first[0].id;
+  const original = store.document(id).content;
+  store.updateDocument(id, original.replace('Instructions initiales.', 'Instructions adaptées.'), original);
+  await scanAndPersistLibraryProviderSkills(store, undefined, reader);
+  assert.equal(store.list().length, 1);
+  assert.match(store.document(id).content, /Instructions adaptées/);
+
+  fs.writeFileSync(source, '---\nname: Relire\ndescription: Source changée\n---\nInstructions externes.');
+  await scanAndPersistLibraryProviderSkills(store, undefined, reader);
+  assert.equal(store.list().length, 1);
+  assert.match(store.document(id).content, /Instructions adaptées/);
+});

package/server/piecemaker/library/provider-skills.ts

@@ -0,0 +1,48 @@
+import { providerSkillsService } from '@/modules/providers/index.js';
+import type { LLMProvider, ProviderSkillListOptions } from '@/shared/types.js';
+
+import type { createLibraryStore } from './store.js';
+
+const LIBRARY_SKILL_PROVIDERS: LLMProvider[] = ['claude', 'codex', 'cursor', 'mistral', 'opencode'];
+
+type ProviderSkillsReader = {
+  listProviderSkills(provider: string, options?: ProviderSkillListOptions): ReturnType<typeof providerSkillsService.listProviderSkills>;
+};
+
+export async function listLibraryProviderSkills(
+  workspacePath: string | undefined,
+  reader: ProviderSkillsReader = providerSkillsService,
+) {
+  const results = await Promise.all(LIBRARY_SKILL_PROVIDERS.map(async (provider) => {
+    try {
+      return {
+        provider,
+        skills: await reader.listProviderSkills(provider, { workspacePath }),
+      };
+    } catch (error) {
+      return {
+        provider,
+        skills: [],
+        error: error instanceof Error ? error.message : 'Chargement impossible.',
+      };
+    }
+  }));
+
+  return { providers: results };
+}
+
+export async function scanAndPersistLibraryProviderSkills(
+  store: ReturnType<typeof createLibraryStore>,
+  workspacePath: string | undefined,
+  reader: ProviderSkillsReader = providerSkillsService,
+) {
+  const result = await listLibraryProviderSkills(workspacePath, reader);
+  for (const provider of result.providers) {
+    for (const skill of provider.skills) {
+      if (!skill.sourcePath) continue;
+      try { store.importFile(skill.sourcePath, 'skill'); }
+      catch { try { store.importFile(skill.sourcePath, 'skill', false); } catch {} }
+    }
+  }
+  return result;
+}

package/server/piecemaker/library/routes.ts

@@ -0,0 +1,38 @@
+import express from 'express';
+
+import type { createLibraryStore } from './store.js';
+import { listLibraryProviderSkills, scanAndPersistLibraryProviderSkills } from './provider-skills.js';
+
+export function createLibraryRouter(store: ReturnType<typeof createLibraryStore>) {
+  const router = express.Router();
+  router.get('/catalog', (req, res) => {
+    try { res.json({ entries: store.list(typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined) }); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.get('/provider-skills', async (req, res) => {
+    const workspacePath = typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined;
+    res.json(await listLibraryProviderSkills(workspacePath));
+  });
+  router.post('/provider-skills/scan', async (req, res) => {
+    const workspacePath = typeof req.body?.workspacePath === 'string' ? req.body.workspacePath : undefined;
+    try { res.json(await scanAndPersistLibraryProviderSkills(store, workspacePath)); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.get('/catalog/:id', (req, res) => {
+    try { res.json(store.document(String(req.params.id))); }
+    catch (error) { res.status(404).json({ error: (error as Error).message }); }
+  });
+  router.put('/catalog/:id', (req, res) => {
+    if (typeof req.body?.content !== 'string' || typeof req.body?.previousContent !== 'string') {
+      res.status(400).json({ error: 'Contenu et version précédente requis.' });
+      return;
+    }
+    try { res.json(store.updateDocument(String(req.params.id), req.body.content, req.body.previousContent)); }
+    catch (error) { res.status(409).json({ error: (error as Error).message }); }
+  });
+  router.put('/catalog/:id/activation', (req, res) => {
+    try { res.json(store.setEnabled(req.body?.workspacePath, String(req.params.id), req.body?.enabled)); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  return router;
+}