@piecemaker-legal/piecemaker 2.0.9 → 2.0.11

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/substitution.cjs

@@ -115,6 +115,157 @@ function byDescendingEntityLength(getEntity) {
   };
 }
 
+function mappingSignature(entries) {
+  let signature = '';
+  for (const [key, value] of entries) signature += key + '\u0000' + value + '\u0001';
+  return signature;
+}
+
+function literalAnchor(value) {
+  const runs = String(value).match(/[A-Za-z0-9_]+/g) || [];
+  return runs.reduce((longest, run) => (run.length > longest.length ? run : longest), '');
+}
+
+const ANCHOR_WIDTH = 37;
+const ANCHOR_SYMBOL = new Int8Array(128).fill(-1);
+for (let letter = 0; letter < 26; letter += 1) {
+  ANCHOR_SYMBOL[65 + letter] = letter;
+  ANCHOR_SYMBOL[97 + letter] = letter;
+}
+for (let digit = 0; digit < 10; digit += 1) ANCHOR_SYMBOL[48 + digit] = 26 + digit;
+ANCHOR_SYMBOL[95] = 36;
+const KELVIN_SIGN = 0x212A;
+const LONG_S = 0x017F;
+
+function anchorSymbol(unit) {
+  if (unit < 128) return ANCHOR_SYMBOL[unit];
+  if (unit === KELVIN_SIGN) return ANCHOR_SYMBOL[107];
+  if (unit === LONG_S) return ANCHOR_SYMBOL[115];
+  return -1;
+}
+
+function buildAnchorScanner(anchors) {
+  let transitions = new Int32Array(ANCHOR_WIDTH * 16).fill(-1);
+  const outputs = [[]];
+  let size = 1;
+  anchors.forEach((anchor, index) => {
+    if (!anchor) return;
+    let node = 0;
+    for (let position = 0; position < anchor.length; position += 1) {
+      const slot = node * ANCHOR_WIDTH + ANCHOR_SYMBOL[anchor.charCodeAt(position)];
+      if (transitions[slot] === -1) {
+        if ((size + 1) * ANCHOR_WIDTH > transitions.length) {
+          const grown = new Int32Array(transitions.length * 2).fill(-1);
+          grown.set(transitions);
+          transitions = grown;
+        }
+        transitions[slot] = size;
+        outputs.push([]);
+        size += 1;
+      }
+      node = transitions[slot];
+    }
+    outputs[node].push(index);
+  });
+
+  const failure = new Int32Array(size);
+  const queue = [];
+  for (let symbol = 0; symbol < ANCHOR_WIDTH; symbol += 1) {
+    const child = transitions[symbol];
+    if (child === -1) transitions[symbol] = 0;
+    else queue.push(child);
+  }
+  for (let head = 0; head < queue.length; head += 1) {
+    const node = queue[head];
+    outputs[node] = outputs[node].concat(outputs[failure[node]]);
+    for (let symbol = 0; symbol < ANCHOR_WIDTH; symbol += 1) {
+      const slot = node * ANCHOR_WIDTH + symbol;
+      const child = transitions[slot];
+      if (child === -1) {
+        transitions[slot] = transitions[failure[node] * ANCHOR_WIDTH + symbol];
+      } else {
+        failure[child] = transitions[failure[node] * ANCHOR_WIDTH + symbol];
+        queue.push(child);
+      }
+    }
+  }
+
+  const next = new Int32Array(size * ANCHOR_WIDTH);
+  for (let slot = 0; slot < next.length; slot += 1) next[slot] = transitions[slot] * ANCHOR_WIDTH;
+  const emitted = new Array(size * ANCHOR_WIDTH).fill(null);
+  for (let node = 0; node < size; node += 1) if (outputs[node].length) emitted[node * ANCHOR_WIDTH] = outputs[node];
+
+  return (text) => {
+    const found = new Set();
+    let state = 0;
+    for (let position = 0; position < text.length; position += 1) {
+      const symbol = anchorSymbol(text.charCodeAt(position));
+      if (symbol === -1) {
+        state = 0;
+        continue;
+      }
+      state = next[state + symbol];
+      const matched = emitted[state];
+      if (matched !== null) for (const index of matched) found.add(index);
+    }
+    return found;
+  };
+}
+
+function compileReplacements(replacements) {
+  return { replacements, scan: buildAnchorScanner(replacements.map(({ anchor }) => anchor.toLowerCase())) };
+}
+
+function isDeeplyFrozen(object) {
+  return Object.isFrozen(object) && Object.values(object).every((value) => !Array.isArray(value) || Object.isFrozen(value));
+}
+
+const compiledMappings = new WeakMap();
+
+function compileMapping(mapping) {
+  const cached = compiledMappings.get(mapping);
+  if (cached && cached.frozen) return cached;
+  const entries = Object.entries(mapping);
+  const signature = mappingSignature(entries);
+  if (cached && cached.signature === signature) return cached;
+
+  const codes = [...new Set(entries.map(([, code]) => String(code)).filter(Boolean))]
+    .sort((a, b) => b.length - a.length);
+  const replacements = [];
+  for (const [entity, code] of entries.sort(byDescendingEntityLength(([key]) => key))) {
+    const regex = buildEntityRegex(entity);
+    if (!regex) continue;
+    const trimmed = entity.trim();
+    replacements.push({ regex, code, anchor: literalAnchor(regex.flags.includes('i') ? trimmed : trimmed.toUpperCase()) });
+  }
+  const compiled = {
+    frozen: Object.isFrozen(mapping),
+    signature,
+    codes,
+    codeProbe: codes.length ? new RegExp(codes.map(escapeRegex).join('|')) : null,
+    replacements: compileReplacements(replacements),
+  };
+  compiledMappings.set(mapping, compiled);
+  return compiled;
+}
+
+function applyReplacements({ replacements, scan }, text) {
+  let output = text;
+  let present = null;
+  replacements.forEach(({ regex, code, anchor }, index) => {
+    if (anchor) {
+      if (present === null) present = scan(output);
+      if (!present.has(index)) return;
+    }
+    const next = output.replace(regex, code);
+    if (next !== output) {
+      output = next;
+      present = null;
+    }
+  });
+  return output;
+}
+
 /**
  * Entité → code. Les entrées passent de la plus longue à la plus courte pour
  * qu'un nom contenu dans un autre ne consomme jamais le plus long en premier
@@ -122,41 +273,49 @@ function byDescendingEntityLength(getEntity) {
  */
 function applyMapping(text, mapping) {
   if (typeof text !== 'string' || !text) return text;
-  const entries = Object.entries(mapping || {});
-  if (!entries.length) return text;
-
-  // Masquage préalable des codes déjà présents dans le texte. La substitution en
-  // sous-chaîne (≥ 3 car.) et l'underscore-séparateur (acronymes 2 car.)
-  // pourraient sinon réécrire l'intérieur d'un code — « SA » dans « URGOT SA »,
-  // « Moral » dans « PERSONNE_MORALE_01 » — et le corrompre. Chaque code distinct
-  // est remplacé par un caractère de zone privée (ni lettre ni chiffre, absent des
-  // documents, jamais matché par une regex d'entité), on anonymise, puis on
-  // restaure. C'est aussi ce qui garantit l'idempotence : réappliquer le mapping à
-  // un texte déjà codé masque ses codes et ne touche à rien. Codes triés du plus
-  // long au plus court pour qu'un code contenu dans un autre ne soit pas masqué
-  // en premier.
-  const codes = [...new Set(entries.map(([, code]) => String(code)).filter(Boolean))]
-    .sort((a, b) => b.length - a.length);
+  if (!mapping || typeof mapping !== 'object') return text;
+  const compiled = compileMapping(mapping);
+  if (!compiled.replacements.replacements.length) return text;
+
   const restore = [];
   let masked = text;
-  codes.forEach((code, idx) => {
-    if (!masked.includes(code)) return;
-    const token = String.fromCodePoint(0xE000 + idx);
-    restore.push([token, code]);
-    masked = masked.split(code).join(token);
-  });
-
-  let output = masked;
-  for (const [entity, code] of entries.sort(byDescendingEntityLength(([key]) => key))) {
-    const regex = buildEntityRegex(entity);
-    if (!regex) continue;
-    output = output.replace(regex, code);
+  if (compiled.codeProbe && compiled.codeProbe.test(text)) {
+    compiled.codes.forEach((code, idx) => {
+      if (!masked.includes(code)) return;
+      const token = String.fromCodePoint(0xE000 + idx);
+      restore.push([token, code]);
+      masked = masked.split(code).join(token);
+    });
   }
 
+  let output = applyReplacements(compiled.replacements, masked);
+  if (output === masked) return text;
+
   for (const [token, code] of restore) output = output.split(token).join(code);
   return output;
 }
 
+const compiledReverseMappings = new WeakMap();
+
+function compileReverseMapping(reverseMapping) {
+  const cached = compiledReverseMappings.get(reverseMapping);
+  if (cached && cached.frozen) return cached;
+  const entries = Object.entries(reverseMapping);
+  const signature = mappingSignature(entries.map(([code, variants]) => [code, Array.isArray(variants) ? variants[0] : variants]));
+  if (cached && cached.signature === signature) return cached;
+
+  const replacements = [];
+  for (const [code, variants] of entries.sort(byDescendingEntityLength(([key]) => key))) {
+    const canonical = Array.isArray(variants) ? variants[0] : variants;
+    if (!canonical) continue;
+    const regex = new RegExp(`${WORD_BOUNDARY_BEFORE}${escapeRegex(String(code))}${WORD_BOUNDARY_AFTER}`, 'giu');
+    replacements.push({ regex, code: String(canonical), anchor: literalAnchor(code) });
+  }
+  const compiled = { frozen: isDeeplyFrozen(reverseMapping), signature, replacements: compileReplacements(replacements) };
+  compiledReverseMappings.set(reverseMapping, compiled);
+  return compiled;
+}
+
 /**
  * Code → entité. Le premier variant du tableau fait foi : c'est l'orthographe
  * canonique retenue par `consolidate_duplicate_entities`, celle qu'un humain
@@ -175,20 +334,9 @@ function applyMapping(text, mapping) {
  */
 function revertMapping(text, reverseMapping) {
   if (typeof text !== 'string' || !text) return text;
-  const entries = Object.entries(reverseMapping || {});
-  if (!entries.length) return text;
-
-  let output = text;
-  for (const [code, variants] of entries.sort(byDescendingEntityLength(([key]) => key))) {
-    const canonical = Array.isArray(variants) ? variants[0] : variants;
-    if (!canonical) continue;
-    // Un code est un identifiant ASCII : pas de variantes Unicode à gérer, mais
-    // les mêmes frontières de mots, pour ne pas réécrire un code cité dans un
-    // mot plus long.
-    const regex = new RegExp(`${WORD_BOUNDARY_BEFORE}${escapeRegex(String(code))}${WORD_BOUNDARY_AFTER}`, 'giu');
-    output = output.replace(regex, String(canonical));
-  }
-  return output;
+  if (!reverseMapping || typeof reverseMapping !== 'object') return text;
+  const compiled = compileReverseMapping(reverseMapping);
+  return applyReplacements(compiled.replacements, text);
 }
 
 function normalizedPathName(value) {

package/server/piecemaker/vendor/piecemaker-plugin/scripts/protect-originals.mjs

@@ -21,19 +21,16 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
-import { loadPieceMakerConfig, readHookPayload, runHook, noop } from './lib/hook-io.mjs';
+import { readHookPayload, runHook, noop } from './lib/hook-io.mjs';
 
 const require = createRequire(import.meta.url);
-const { locateConfiguredCase } = require('./lib/case-folders.cjs');
-const { caseHasMapping } = require('./lib/mapping.cjs');
+const { locateProjectCase } = require('./lib/case-folders.cjs');
 const {
   isMappingFile,
   isSecretFile,
   isProtectedFile,
   markdownCounterpart,
   readProtection,
-  relativeKey,
-  READABLE_EXTENSIONS,
 } = require('./lib/protection.cjs');
 
 /** Au-delà, on ne cherche pas de chemin : une commande pareille n'en cite pas un. */
@@ -81,36 +78,6 @@ function secretReason(absolute) {
   return `[PieceMaker] « ${path.basename(absolute)} » est un fichier de secrets d’environnement : il n’est jamais accessible à l’IA.`;
 }
 
-/**
- * Refus « dossier non anonymisé ». Sans `mapping_default.json`, le proxy n'a
- * rien à coder : lire une pièce livrerait des données personnelles en clair.
- * On l'explique synthétiquement au modèle, avec l'action qui débloque la lecture.
- */
-function missingMappingReason(caseName) {
-  return `[PieceMaker] « ${caseName} » est un dossier PieceMaker sans mapping d’anonymisation (mapping_default.json absent) : sa lecture est bloquée car son contenu n’est pas encore anonymisable et partirait en clair. Lancez l’anonymisation du dossier dans l’administration PieceMaker avant toute lecture.`;
-}
-
-/**
- * Surface lisible dont le contenu serait normalement codé à la lecture (`.md`,
- * `.json` de pièce) : c'est précisément ce que `missingMappingReason` doit
- * protéger quand aucun mapping n'existe. On écarte les originaux (déjà refusés
- * par `isProtectedFile`), le mapping et les scans (refusés à part), la
- * configuration du dossier (`.piecemaker/…`, dotfiles) et les consignes
- * structurelles `CLAUDE.md`/`AGENTS.md` — jamais des pièces, et l'assistant du
- * dossier doit pouvoir charger sa consigne même avant anonymisation.
- */
-function isReadableCaseSurface(absolute, caseRoot) {
-  const stat = statSafe(absolute);
-  if (!stat || stat.isDirectory()) return false;
-  const key = relativeKey(absolute, caseRoot);
-  if (!key) return false;
-  if (key.split('/').some((segment) => segment.startsWith('.'))) return false;
-  if (!READABLE_EXTENSIONS.has(path.extname(key).toLowerCase())) return false;
-  if (isMappingFile(absolute)) return false;
-  const base = path.basename(key);
-  return base !== 'CLAUDE.md' && base !== 'AGENTS.md';
-}
-
 function statSafe(target) {
   try {
     return fs.statSync(target);
@@ -189,23 +156,19 @@ function caseRootHasMapping(located) {
 async function main() {
   const payload = await readHookPayload(2000);
   if (!payload) return null;
-  const config = loadPieceMakerConfig();
 
   const toolName = payload.tool_name;
   const cwd = payload.cwd || process.cwd();
 
   if (toolName === 'Bash') {
     for (const candidate of commandPaths(payload.tool_input?.command, cwd)) {
-      const located = locateConfiguredCase(config, candidate);
+      const located = locateProjectCase(candidate);
       if (!located) continue;
       if (isMappingFile(candidate)) return deny(mappingReason(candidate));
       if (isSecretFile(candidate)) return deny(secretReason(candidate));
       if (isProtectedFile(candidate, located.caseRoot)) {
         return deny(protectionReason(candidate, located.caseRoot));
       }
-      if (isReadableCaseSurface(candidate, located.caseRoot) && !caseHasMapping(located.caseRoot)) {
-        return deny(missingMappingReason(located.caseName));
-      }
     }
     return null;
   }
@@ -214,7 +177,7 @@ async function main() {
 
   const target = absolutePath(payload.tool_input?.file_path || payload.tool_input?.path, cwd);
   if (!target) return null;
-  const located = locateConfiguredCase(config, target);
+  const located = locateProjectCase(target);
   if (!located) return null;
 
   // Un répertoire n'est pas une pièce : `Grep`/`Glob` en visent un couramment,
@@ -227,20 +190,6 @@ async function main() {
     return deny(protectionReason(target, located.caseRoot));
   }
 
-  // Dossier PieceMaker sans mapping : la garantie « anonymisé à la lecture »
-  // n'existe pas encore. Lire une surface lisible (`.md`/`.json` de pièce) la
-  // ferait sortir en clair, et un `Grep` récursif à la racine en ferait autant
-  // sur tout le dossier (un `Glob`, qui ne ramène que des noms, reste permis).
-  // On calcule l'absence de mapping au plus tard, une fois les refus francs
-  // (mapping, original) écartés — c'est le seul chemin qui paie la lecture du
-  // mapping.
-  if (isReadableCaseSurface(target, located.caseRoot) && !caseHasMapping(located.caseRoot)) {
-    return deny(missingMappingReason(located.caseName));
-  }
-  if (toolName === 'Grep' && located.absolute === located.caseRoot && !caseHasMapping(located.caseRoot)) {
-    return deny(missingMappingReason(located.caseName));
-  }
-
   // Un `Grep` récursif ramène le *contenu* du mapping ; un `Glob` n'en ramène
   // que le nom, qui ne trahit rien — d'où la restriction à Grep ici.
   if (toolName === 'Grep' && caseRootHasMapping(located)) {

package/server/piecemaker/vendor/piecemaker-plugin/scripts/statusline.mjs

@@ -1,120 +1,46 @@
 #!/usr/bin/env node
-/**
- * statusLine Claude Code — bandeau permanent d'état de l'anonymisation PieceMaker.
- *
- * Contrat statusLine (type "command") : JSON sur stdin décrivant la session
- * (workspace, model...), une seule ligne sur stdout, exit 0. Appelé très
- * souvent (à chaque rendu de l'interface) : ce script doit rester rapide et
- * ne jamais bloquer ni jeter.
- *
- * Le badge reflète les deux mêmes conditions que `proxy-guard.mjs` (routage
- * + proxy vivant), mais sans autostart ni journalisation : une statusLine
- * n'est pas le bon endroit pour une action de fond, seulement pour un
- * affichage. Le sondage réseau est borné à 400 ms et son résultat est mis en
- * cache 5 s dans ~/.piecemaker/proxy-statusline.json pour éviter une requête
- * à chaque frappe.
- */
-
-import fs from 'node:fs';
 import http from 'node:http';
-import os from 'node:os';
 import path from 'node:path';
-import { HOME_DIR, loadPieceMakerConfig, readHookPayload } from './lib/hook-io.mjs';
+import { loadPieceMakerConfig, readHookPayload } from './lib/hook-io.mjs';
 
-const CACHE_FILE = path.join(HOME_DIR, 'proxy-statusline.json');
-const CACHE_TTL_MS = 5000;
 const PROBE_TIMEOUT_MS = 400;
 const STDIN_TIMEOUT_MS = 1000;
-const DEFAULT_PORT = 4000;
 const FLUSH_TIMEOUT_MS = 1000;
+const VERT = '\u001b[32m';
+const ROUGE = '\u001b[31m';
+const RESET = '\u001b[0m';
 
-const SETTINGS_FILE = path.join(os.homedir(), '.claude', 'settings.json');
-
-function validPort(value) {
-  const port = Number(value);
-  return Number.isInteger(port) && port >= 1024 && port <= 65535 ? port : DEFAULT_PORT;
-}
-
-/** Même définition du routage que proxy-guard.mjs — lecture directe, jamais de throw. */
-function readRouting() {
-  try {
-    const settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8'));
-    const value = settings?.env?.HTTPS_PROXY;
-    if (typeof value !== 'string' || !value) return false;
-    const url = new URL(value);
-    return ['127.0.0.1', 'localhost'].includes(url.hostname);
-  } catch {
-    return false;
-  }
-}
-
-/** Cache court entre deux sondages. Un cache illisible/absent n'empêche pas de sonder. */
-function readCache() {
+function routedProxy() {
   try {
-    const parsed = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
-    if (typeof parsed?.ts !== 'number' || typeof parsed?.actif !== 'boolean') return null;
-    if (Date.now() - parsed.ts > CACHE_TTL_MS) return null;
-    return parsed;
+    const url = new URL(process.env.HTTPS_PROXY || process.env.https_proxy || '');
+    return ['127.0.0.1', 'localhost'].includes(url.hostname) ? url : null;
   } catch {
     return null;
   }
 }
 
-function writeCache(actif) {
-  try {
-    fs.mkdirSync(HOME_DIR, { recursive: true });
-    fs.writeFileSync(CACHE_FILE, JSON.stringify({ ts: Date.now(), actif }), 'utf8');
-  } catch {
-    // Le cache est un confort de performance, pas une garantie.
-  }
-}
-
-function probe(port, timeoutMs) {
+function proxyHealthy(proxy) {
   return new Promise((resolve) => {
-    let settled = false;
-    const finish = (ok) => {
-      if (settled) return;
-      settled = true;
-      resolve(ok);
-    };
-    try {
-      const request = http.get({
-        hostname: '127.0.0.1',
-        port,
-        path: '/health/liveliness',
-        timeout: timeoutMs,
-      }, (response) => {
-        response.resume();
-        finish(response.statusCode === 200);
-      });
-      request.on('timeout', () => { request.destroy(); finish(false); });
-      request.on('error', () => finish(false));
-    } catch {
-      finish(false);
-    }
+    const request = http.get({ hostname: proxy.hostname, port: proxy.port, path: '/health', timeout: PROBE_TIMEOUT_MS }, (response) => {
+      response.resume();
+      resolve(response.statusCode === 200);
+    });
+    request.on('timeout', () => { request.destroy(); resolve(false); });
+    request.on('error', () => resolve(false));
   });
 }
 
-/**
- * Couleur ANSI du badge : vert quand l'anonymisation est effective, rouge
- * sinon. Claude Code rend les séquences ANSI de la statusLine ; on n'en met
- * que sur le badge, jamais sur le dossier ni le modèle.
- */
-const VERT = '\u001b[32m';
-const ROUGE = '\u001b[31m';
-const RESET = '\u001b[0m';
-
 function colore(texte, couleur) {
   return process.env.NO_COLOR ? texte : `${couleur}${texte}${RESET}`;
 }
 
-function badge(routed, actif) {
-  if (routed && actif) return colore('🔒 Anonymisation PieceMaker active ✓', VERT);
-  if (routed) return colore('⚠️ Anonymisation PieceMaker inactive — proxy arrêté (piecemaker)', ROUGE);
-  return colore('⚠️ Anonymisation PieceMaker inactive — accès direct', ROUGE);
+async function badge() {
+  const proxy = routedProxy();
+  if (!proxy) return colore('⚠️ Anonymisation PieceMaker inactive — accès direct', ROUGE);
+  if (await proxyHealthy(proxy)) return colore('🔒 Anonymisation PieceMaker active ✓', VERT);
+  return colore('⛔ Anonymisation PieceMaker indisponible — requêtes bloquées (relancer piecemaker)', ROUGE);
 }
 
-/** Écrit la ligne et quitte proprement, en attendant le flush comme hook-io.mjs::emit. */
 function printAndExit(text) {
   const guard = setTimeout(() => process.exit(0), FLUSH_TIMEOUT_MS);
   guard.unref?.();
@@ -139,35 +65,16 @@ function safeCwdName(cwd) {
 }
 
 async function main() {
-  let payload = null;
-  try {
-    payload = await readHookPayload(STDIN_TIMEOUT_MS);
-  } catch {
-    payload = null;
-  }
-
+  const payload = await readHookPayload(STDIN_TIMEOUT_MS).catch(() => null);
   const dirName = safeCwdName(payload?.workspace?.current_dir || payload?.cwd);
   const modelName = typeof payload?.model?.display_name === 'string' ? payload.model.display_name : '';
-
-  let config = {};
+  let disabled = false;
   try {
-    config = loadPieceMakerConfig();
+    disabled = loadPieceMakerConfig()?.anonymizer?.enabled === false;
   } catch {
-    config = {};
+    disabled = false;
   }
-  const port = validPort(config.litellmPort);
-  const routed = readRouting();
-
-  const cached = readCache();
-  let actif;
-  if (cached) {
-    actif = cached.actif;
-  } else {
-    actif = await probe(port, PROBE_TIMEOUT_MS);
-    writeCache(actif);
-  }
-
-  const parts = [badge(routed, actif)];
+  const parts = [disabled ? 'Anonymisation PieceMaker désactivée' : await badge()];
   if (dirName) parts.push(dirName);
   if (modelName) parts.push(modelName);
   printAndExit(parts.join(' · '));

package/server/piecemaker/vendor/piecemaker-plugin/skills/ajout-de-fonctionnalites/SKILL.md

@@ -14,9 +14,9 @@ skill sert de guide pour ranger un ajout personnel au bon endroit.
 
 | Type d'ajout | Emplacement | Portée |
 | --- | --- | --- |
-| Instructions ou préférences globales (style, rappels, habitudes) | `/Users/tsardet/.piecemaker/custom/perso.md` | Toutes les affaires — ce fichier est importé automatiquement dans chaque dossier via `/Users/tsardet/.piecemaker/CLAUDE.md`. |
-| Skill personnelle réutilisable | Nouveau dossier `/Users/tsardet/.claude/skills/<nom>/SKILL.md` | Toutes les sessions Claude Code — découverte automatique, jamais écrasée par PieceMaker (un fichier créé à la main n'est jamais remplacé par l'application). |
-| Gabarit personnel (acte, courrier type…) | `/Users/tsardet/.piecemaker/templates/` | Disponible pour toute rédaction, indépendamment du dépôt de l'application. |
+| Instructions ou préférences globales (style, rappels, habitudes) | `~/.piecemaker/custom/perso.md` | Toutes les affaires — ce fichier est importé automatiquement dans chaque dossier via `~/.piecemaker/CLAUDE.md`. |
+| Skill personnelle réutilisable | Nouveau dossier `~/.claude/skills/<nom>/SKILL.md` | Toutes les sessions Claude Code — découverte automatique, jamais écrasée par PieceMaker (un fichier créé à la main n'est jamais remplacé par l'application). |
+| Gabarit personnel (acte, courrier type…) | `~/.piecemaker/templates/` | Disponible pour toute rédaction, indépendamment du dépôt de l'application. |
 | Élément propre à une seule affaire (parties, juridiction, échéances) | Section « Ce dossier » du `CLAUDE.md` / `AGENTS.md` de ce dossier | Uniquement ce dossier-là. |
 
 Ces emplacements sont hors du dépôt PieceMaker : une mise à jour de PieceMaker
@@ -26,7 +26,7 @@ PieceMaker — la garantie va dans les deux sens.
 
 ## Format minimal d'une skill personnelle
 
-Un fichier `/Users/tsardet/.claude/skills/<nom>/SKILL.md` avec un en-tête
+Un fichier `~/.claude/skills/<nom>/SKILL.md` avec un en-tête
 puis du texte libre :
 
 ```markdown
@@ -50,17 +50,3 @@ Instructions pour l'assistant, en français, centrées sur la tâche.
 3. **Créer ou éditer le fichier correspondant**, en respectant le format
    attendu (front matter pour une skill, section « Ce dossier » pour un
    élément local, etc.).
-4. **Pour un nouveau dossier d'affaire** qui n'a pas encore de wrapper : sur
-   demande, proposer et créer `CLAUDE.md` et `AGENTS.md` à la racine du
-   dossier, avec exactement ce contenu (chemin absolu, jamais `~`) :
-
-   ```
-   @/Users/tsardet/.piecemaker/CLAUDE.md
-
-   # Ce dossier
-   <!-- Éléments propres à ce dossier : parties, juridiction, échéances, particularités. À compléter. -->
-   ```
-
-   Si l'un de ces deux fichiers existe déjà dans le dossier, ne jamais
-   l'écraser : le lire, et s'il ne contient pas déjà cette ligne d'import,
-   l'ajouter en tête sans supprimer le contenu existant.

package/server/piecemaker/vendor/piecemaker-plugin/skills/tamponnage/SKILL.md

@@ -40,8 +40,8 @@ dossier ni par utilisateur.
    haute définition : forme, contour, police, couleur et épaisseur, puis
    « Enregistrer le tampon »).
 2. **La liste des pièces vient des dossiers juridiques enregistrés** :
-   `GET /api/admin/dossiers` → `listDossiers` bâtit la liste sur le registre
-   `caseFolders` (quelle que soit sa place dans l'arborescence), et chaque
+   `GET /api/admin/dossiers` → `listDossiers` bâtit la liste sur les projets
+   publiés par le serveur (`~/.piecemaker/projects.json`), et chaque
    pièce est un **fichier original** du dossier (tout fichier qui n'est ni
    `.md` ni `.json`, via `listOriginals`), **identifié par son chemin relatif
    au dossier** — aucun `compilation_dossier_*.json` n'est requis. L'ancien