@piecemaker-legal/piecemaker 2.0.9 → 2.0.11

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/case-folder-structure.cjs

@@ -7,7 +7,6 @@ const CASE_FOLDER_STRUCTURE_VERSION = 1;
 const CASE_FOLDER_STRUCTURE_RELATIVE = '.piecemaker/case-folder-structure.json';
 
 const DEFAULT_CASE_FOLDER_STRUCTURE = Object.freeze({
-  administrative: '00_ADMINISTRATIF_ET_FACTURATION',
   correspondence: '01_CORRESPONDANCE',
   correspondenceClient: '01_Client',
   correspondenceOpposingCounsel: '02_Avocats_adverses',
@@ -65,7 +64,6 @@ function normalizeCaseFolderStructure(value = {}) {
   }
 
   ensureUniqueSiblingNames(structure, [
-    'administrative',
     'correspondence',
     'dataRoom',
     'drafts',
@@ -107,9 +105,8 @@ function readStructureManifest(caseRoot) {
 }
 
 /**
- * La structure est figée par dossier lors de son premier enregistrement. Ainsi,
- * personnaliser les prochains dossiers ne change pas le routage du Markdown
- * des dossiers déjà existants.
+ * Seuls les anciens dossiers portent encore un manifeste d'arborescence : il
+ * continue de router leur Markdown. Sans manifeste, le dossier n'est pas géré.
  */
 function readCaseFolderStructure(caseRoot, config = {}) {
   const manifest = readStructureManifest(caseRoot);
@@ -119,78 +116,6 @@ function readCaseFolderStructure(caseRoot, config = {}) {
   };
 }
 
-function caseFolderDirectoriesFromStructure(structure) {
-  return [
-    structure.administrative,
-    structure.correspondence,
-    path.join(structure.correspondence, structure.correspondenceMarkdown),
-    path.join(structure.correspondence, structure.correspondenceClient),
-    path.join(structure.correspondence, structure.correspondenceOpposingCounsel),
-    path.join(structure.correspondence, structure.correspondenceThirdParties),
-    structure.dataRoom,
-    path.join(structure.dataRoom, structure.dataRoomMarkdown),
-    structure.drafts,
-    structure.notesAndResearch,
-    structure.procedure,
-  ];
-}
-
-/** Chemins relatifs, dans l'ordre lisible de l'arborescence documentée. */
-function caseFolderDirectories(config = {}) {
-  return caseFolderDirectoriesFromStructure(configuredCaseFolderStructure(config));
-}
-
-function writeStructureManifest(file, structure) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const temporary = `${file}.piecemaker-${process.pid}.tmp`;
-  fs.writeFileSync(temporary, `${JSON.stringify({
-    version: CASE_FOLDER_STRUCTURE_VERSION,
-    structure,
-  }, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
-  fs.renameSync(temporary, file);
-}
-
-/**
- * Crée uniquement les dossiers manquants. Aucun fichier ni dossier existant
- * n'est renommé ou remplacé quand l'utilisateur modifie les noms par défaut.
- */
-function ensureCaseFolderStructure(caseRoot, config = {}) {
-  const requested = String(caseRoot || '').trim();
-  if (!requested || !path.isAbsolute(requested)) throw new Error('Racine du dossier juridique invalide.');
-  const root = path.resolve(requested);
-  let rootStat;
-  try {
-    rootStat = fs.statSync(root);
-  } catch {
-    throw new Error('Racine du dossier juridique introuvable.');
-  }
-  if (!rootStat.isDirectory()) throw new Error('Racine du dossier juridique invalide.');
-
-  const created = [];
-  const manifest = readStructureManifest(root);
-  const structure = manifest.structure || configuredCaseFolderStructure(config);
-  const directories = caseFolderDirectoriesFromStructure(structure);
-  for (const relative of directories) {
-    const target = path.join(root, relative);
-    if (fs.existsSync(target)) {
-      if (!fs.statSync(target).isDirectory()) {
-        throw new Error(`L’emplacement « ${relative} » existe mais n’est pas un dossier.`);
-      }
-      continue;
-    }
-    fs.mkdirSync(target, { recursive: true });
-    created.push(relative.split(path.sep).join('/'));
-  }
-  if (!manifest.exists) writeStructureManifest(manifest.file, structure);
-
-  return {
-    file: manifest.file,
-    names: structure,
-    directories: directories.map((relative) => relative.split(path.sep).join('/')),
-    created,
-  };
-}
-
 function relativeSegments(relativePath) {
   const value = String(relativePath || '').replaceAll('\\', '/').replace(/^\.\//, '');
   if (!value || value.startsWith('/') || value.split('/').some((segment) => !segment || segment === '.' || segment === '..')) {
@@ -278,20 +203,7 @@ function structuredMarkdownCounterpart(absolutePath, caseRoot, config = {}) {
 }
 
 module.exports = {
-  CASE_FOLDER_KEYS,
-  CASE_FOLDER_STRUCTURE_KEY,
-  CASE_FOLDER_STRUCTURE_RELATIVE,
-  DEFAULT_CASE_FOLDER_STRUCTURE,
-  caseConversionOutputDirectory,
-  caseFolderDirectories,
-  caseFolderStructureFile,
-  classifyCaseFolderPath,
   classifyRelativeCaseFolderPath,
-  configuredCaseFolderStructure,
-  ensureCaseFolderStructure,
-  isCaseGeneratedPath,
-  normalizeCaseFolderStructure,
   readCaseFolderStructure,
   structuredMarkdownCounterpart,
-  validateCaseFolderName,
 };

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/case-folders.cjs

@@ -1,7 +1,18 @@
-/** Registered PieceMaker legal-case folders, including folders outside a common root. */
+/** Legal-case folders: every CloudCLI project, as published by the PieceMaker server. */
 const fs = require('node:fs');
+const os = require('node:os');
 const path = require('node:path');
 
+const PROJECTS_FILE = 'projects.json';
+
+function piecemakerHome() {
+  return process.env.PIECEMAKER_HOME || path.join(os.homedir(), '.piecemaker');
+}
+
+function projectsFile() {
+  return path.join(piecemakerHome(), PROJECTS_FILE);
+}
+
 function realDirectory(value) {
   const requested = String(value || '').trim();
   if (!requested || !path.isAbsolute(requested)) return null;
@@ -13,23 +24,57 @@ function realDirectory(value) {
   }
 }
 
-/** Absolute, existing and de-duplicated folders explicitly registered by the admin. */
-function registeredCaseFolders(config) {
-  const folders = Array.isArray(config?.caseFolders) ? config.caseFolders : [];
-  return [...new Set(folders.map(realDirectory).filter(Boolean))];
-}
-
-function isInsideOrEqual(root, candidate) {
+function isInsideOrEqualPath(root, candidate) {
   const relative = path.relative(root, candidate);
   return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
 }
 
-/** Locate a target inside one of the explicitly registered legal-case folders. */
-function locateRegisteredCase(folders, target) {
-  if (!target) return null;
-  let absolute;
+function excludedRoots() {
+  return [os.tmpdir(), '/tmp', '/private/tmp', '/var/folders', '/private/var/folders']
+    .map(realDirectory)
+    .filter(Boolean);
+}
+
+function isEligibleProjectFolder(folder) {
+  const home = realDirectory(os.homedir());
+  if (home && isInsideOrEqualPath(folder, home)) return false;
+  return !excludedRoots().some((root) => isInsideOrEqualPath(root, folder));
+}
+
+function readProjectSources() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(projectsFile(), 'utf8'));
+    return parsed?.sources && typeof parsed.sources === 'object' && !Array.isArray(parsed.sources) ? parsed.sources : {};
+  } catch {
+    return {};
+  }
+}
+
+/** Absolute, existing and de-duplicated project folders, across every publishing server. */
+function registeredProjectFolders() {
+  const folders = Object.values(readProjectSources()).flatMap((list) => (Array.isArray(list) ? list : []));
+  return [...new Set(folders.map(realDirectory).filter(Boolean))].filter(isEligibleProjectFolder);
+}
+
+function publishProjectSource(sourceId, folders) {
+  const file = projectsFile();
+  const sources = readProjectSources();
+  if (folders === null) delete sources[sourceId];
+  else sources[sourceId] = [...new Set(folders.map((folder) => path.resolve(String(folder))))].sort();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporaryFile = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(temporaryFile, `${JSON.stringify({ version: 1, sources }, null, 2)}\n`, 'utf8');
+    fs.renameSync(temporaryFile, file);
+  } catch (error) {
+    fs.rmSync(temporaryFile, { force: true });
+    throw error;
+  }
+}
+
+function resolveTarget(target) {
   try {
-    absolute = fs.realpathSync(path.resolve(String(target)));
+    return fs.realpathSync(path.resolve(String(target)));
   } catch {
     // Write/Edit may target a file that does not exist yet. Resolve its nearest
     // existing parent, then append the missing tail without following links.
@@ -37,22 +82,24 @@ function locateRegisteredCase(folders, target) {
     const tail = [];
     while (path.dirname(current) !== current) {
       try {
-        absolute = path.join(fs.realpathSync(current), ...tail);
-        break;
+        return path.join(fs.realpathSync(current), ...tail);
       } catch {
         tail.unshift(path.basename(current));
         current = path.dirname(current);
       }
     }
-    if (!absolute) return null;
+    return null;
   }
+}
 
-  // A nested registered matter wins over its parent. It prevents a folder
-  // intentionally registered as its own case from sharing the parent's map.
-  const roots = [...new Set((folders || []).map(realDirectory).filter(Boolean))]
-    .sort((a, b) => b.length - a.length);
+/** Locate a target inside one of the project folders; a nested project wins over its parent. */
+function locateProjectCase(target) {
+  if (!target) return null;
+  const absolute = resolveTarget(target);
+  if (!absolute) return null;
+  const roots = registeredProjectFolders().sort((a, b) => b.length - a.length);
   for (const caseRoot of roots) {
-    if (!isInsideOrEqual(caseRoot, absolute)) continue;
+    if (!isInsideOrEqualPath(caseRoot, absolute)) continue;
     return {
       casesRoot: path.dirname(caseRoot),
       caseName: path.basename(caseRoot),
@@ -65,22 +112,8 @@ function locateRegisteredCase(folders, target) {
   return null;
 }
 
-/**
- * Locate a target inside one of the explicitly registered legal-case folders.
- * There is no longer a workspace-root fallback: a matter is protected only once
- * it is explicitly registered, never by mere location under a common root.
- */
-function locateConfiguredCase(config, target) {
-  return locateRegisteredCase(registeredCaseFolders(config), target);
-}
-
-function configuredWatchPaths(config) {
-  return registeredCaseFolders(config);
-}
-
 module.exports = {
-  configuredWatchPaths,
-  locateConfiguredCase,
-  locateRegisteredCase,
-  registeredCaseFolders,
+  locateProjectCase,
+  publishProjectSource,
+  registeredProjectFolders,
 };

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

@@ -2,8 +2,7 @@
  * Mapping d'anonymisation d'un dossier juridique — implémentation unique.
  *
  * Le pipeline admin (`websocket-server/originals-pipeline.cjs`), le serveur
- * Word, l'historique et les vues juridiques la partagent. Le proxy PII lit le
- * mapping central produit à partir de ces mappings de dossier.
+ * Word, l'historique et les vues juridiques la partagent.
  *
  * Deux sens, jamais symétriques dans leur usage :
  *  - `applyMapping`  entité → code, sur tout ce que l'IA s'apprête à lire ;
@@ -16,11 +15,11 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { locateCase, WORKSPACE_SUBDIR } = require('./protection.cjs');
-const { locateConfiguredCase } = require('./case-folders.cjs');
+const { WORKSPACE_SUBDIR } = require('./protection.cjs');
+const { locateProjectCase } = require('./case-folders.cjs');
 const { isInstitutionalEntity } = require('./institutional-terms.cjs');
 // Le moteur de substitution est extrait dans un module autonome : il est aussi
-// requis par le hook central global, distribué hors du plugin. Une seule
+// requis par le proxy PII (`anonymizer/dictionary.cjs`). Une seule
 // implémentation, ré-exportée ici pour les appelants historiques.
 const {
   applyMapping,
@@ -286,40 +285,13 @@ function readCaseMapping(caseRoot) {
   };
 }
 
-/**
- * Un mapping d'anonymisation exploitable existe-t-il pour ce dossier ? C'est la
- * condition de la garantie « anonymisé avant envoi » : sans lui, le proxy n'a
- * rien à coder et une surface lisible partirait en clair. `protect-originals`
- * s'en sert pour refuser la lecture d'un dossier PieceMaker pas encore anonymisé.
- * On s'appuie sur `readCaseMapping` (et non sur la seule présence du fichier) pour
- * qu'un `mapping_default.json` illisible compte comme absent — c'est exactement ce
- * que voit la reconstruction du mapping central.
- */
-function caseHasMapping(caseRoot) {
-  return readCaseMapping(caseRoot).exists;
-}
-
 // La substitution (`applyMapping` / `revertMapping`) vit dans `substitution.cjs`
 // et est importée en tête de fichier. Elle est ré-exportée ci-dessous pour les
 // appelants historiques de `mapping.cjs`.
 
-/**
- * Retrouve le mapping du dossier juridique auquel `hint` appartient. `hint` est
- * un chemin de fichier (Read, Write, Edit) ou un répertoire de travail (Bash,
- * Telegram). Retourne `null` hors dossier juridique ou sans mapping utilisable :
- * les hooks n'ont alors rien à faire.
- */
-function resolveCaseMapping(casesRoot, hint) {
-  const located = locateCase(casesRoot, hint);
-  if (!located) return null;
-  const mapping = readCaseMapping(located.caseRoot);
-  if (!mapping.exists) return null;
-  return { caseRoot: located.caseRoot, caseName: located.caseName, ...mapping };
-}
-
-/** Resolve a mapping from the explicit folder registry plus legacy workspace. */
-function resolveConfiguredCaseMapping(config, hint) {
-  const located = locateConfiguredCase(config, hint);
+/** Resolve the mapping of the project folder containing the hint. */
+function resolveProjectCaseMapping(hint) {
+  const located = locateProjectCase(hint);
   if (!located) return null;
   const mapping = readCaseMapping(located.caseRoot);
   if (!mapping.exists) return null;
@@ -330,15 +302,13 @@ module.exports = {
   applyMapping,
   buildEntityRegex,
   byDescendingEntityLength,
-  caseHasMapping,
   caseMappingFile,
   escapeWithVariants,
   normalizeMappingDocument,
   normalizeProcedureInfo,
   readCaseMapping,
   readJsonFile,
-  resolveConfiguredCaseMapping,
-  resolveCaseMapping,
+  resolveProjectCaseMapping,
   resolveMappedPath,
   revertMapping,
   sortedMapping,

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

@@ -3,8 +3,8 @@
  *
  * L'ancienne règle protégeait le contenu d'un sous-dossier « Pièces
  * originales ». Elle ne protégeait donc rien dans un dossier organisé
- * autrement, ce qui est le cas courant : les PDF et DOCX y côtoient le Markdown
- * qu'on en a tiré. La protection est désormais une propriété du fichier,
+ * autrement, ce qui est le cas courant : les PDF y côtoient le Markdown qu'on
+ * en a tiré. La protection est désormais une propriété du fichier,
  * décidée dans l'administration.
  *
  * **Protégés par défaut : les PDF et les images** (`PROTECTED_EXTENSIONS`), qui
@@ -81,7 +81,7 @@ const PROTECTED_EXTENSIONS = new Set([
  * celles rangées sous `ignored` et les variantes d'`extracted_data` ressortiraient
  * telles quelles. Le seul traitement correct est le refus.
  */
-const FORBIDDEN_JSON_PATTERNS = [/^mapping.*\.json$/i, /_sensitive_map\.json$/i, /^central-mapping\.json$/i];
+const FORBIDDEN_JSON_PATTERNS = [/^mapping.*\.json$/i, /_sensitive_map\.json$/i];
 
 /** Vrai pour un mapping de dossier ou un scan PII, où qu'il soit rangé. */
 function isMappingFile(filePath) {
@@ -172,37 +172,6 @@ function relativeKey(absolutePath, caseRoot) {
   return relative.split(path.sep).join('/');
 }
 
-/**
- * Situe un chemin dans la racine PieceMaker : chaque enfant direct de cette
- * racine est un dossier juridique indépendant. Retourne `null` hors racine, ce
- * qui est le cas de la grande majorité des appels d'outil — c'est le chemin
- * rapide des hooks.
- */
-function locateCase(casesRoot, target) {
-  if (!casesRoot || !target) return null;
-  let root;
-  try {
-    root = fs.realpathSync(path.resolve(String(casesRoot)));
-  } catch {
-    return null;
-  }
-  // Les deux côtés doivent être résolus : sur macOS `/var/…` est un lien vers
-  // `/private/var/…`, si bien qu'une racine résolue et une cible qui ne l'est
-  // pas ne se recouvrent jamais — le dossier passait alors pour hors racine et
-  // rien n'était protégé.
-  const absolute = realpathOrParent(path.resolve(String(target)));
-  if (absolute === root || !absolute.startsWith(`${root}${path.sep}`)) return null;
-  const [caseName, ...rest] = path.relative(root, absolute).split(path.sep);
-  if (!caseName || caseName.startsWith('.')) return null;
-  const caseRoot = path.join(root, caseName);
-  try {
-    if (!fs.statSync(caseRoot).isDirectory()) return null;
-  } catch {
-    return null;
-  }
-  return { casesRoot: root, caseName, caseRoot, absolute, relative: rest.join('/') };
-}
-
 /** Normalise une liste de chemins relatifs en Set de clés POSIX. */
 function normalizeKeySet(list) {
   return new Set(
@@ -244,26 +213,76 @@ function readProtection(caseRoot) {
  * que `unprotected` — l'initialisation d'un dossier — n'efface pas les
  * ressources déjà déclarées.
  */
-function writeProtection(caseRoot, { unprotected, resources } = {}) {
+function writeProtection(caseRoot, lists = {}) {
+  return mutateProtection(caseRoot, () => lists);
+}
+
+const PROTECTION_LOCK_TIMEOUT_MS = 3000;
+const PROTECTION_LOCK_STALE_MS = 10000;
+const PROTECTION_LOCK_RETRY_MS = 25;
+
+function sleepSync(milliseconds) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+
+function acquireProtectionLock(lockFile) {
+  const deadline = Date.now() + PROTECTION_LOCK_TIMEOUT_MS;
+  for (;;) {
+    try {
+      fs.closeSync(fs.openSync(lockFile, 'wx'));
+      return;
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+    }
+    try {
+      if (Date.now() - fs.statSync(lockFile).mtimeMs > PROTECTION_LOCK_STALE_MS) {
+        fs.rmSync(lockFile, { force: true });
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    if (Date.now() > deadline) throw new Error(`Le fichier de protection est verrouillé : ${lockFile}`);
+    sleepSync(PROTECTION_LOCK_RETRY_MS);
+  }
+}
+
+function mutateProtection(caseRoot, mutate) {
   const file = protectionFile(caseRoot);
-  const existing = readProtection(caseRoot);
-  const clean = (list, fallback) => [...new Set(
-    (Array.isArray(list) ? list : [...fallback])
-      .map((entry) => String(entry || '').replaceAll('\\', '/').trim())
-      .filter((entry) => entry && !entry.startsWith('../') && !path.isAbsolute(entry))
-  )].sort((a, b) => a.localeCompare(b, 'fr'));
-  // Une pièce ne peut être à la fois « espace de travail » et « ressource » :
-  // `resources` a priorité, on la retire donc de `unprotected`.
-  const resourcesList = clean(resources, existing.resources);
-  const resourceSet = new Set(resourcesList);
-  const unprotectedList = clean(unprotected, existing.unprotected).filter((key) => !resourceSet.has(key));
+  const lockFile = `${file}.lock`;
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(
-    file,
-    `${JSON.stringify({ version: 1, unprotected: unprotectedList, resources: resourcesList }, null, 2)}\n`,
-    'utf8'
-  );
-  return { file, unprotected: new Set(unprotectedList), resources: resourceSet };
+  acquireProtectionLock(lockFile);
+  try {
+    const existing = readProtection(caseRoot);
+    const next = mutate(existing);
+    if (!next) return { file, unprotected: existing.unprotected, resources: existing.resources };
+    const { unprotected, resources } = next;
+    const clean = (list, fallback) => [...new Set(
+      (Array.isArray(list) ? list : [...fallback])
+        .map((entry) => String(entry || '').replaceAll('\\', '/').trim())
+        .filter((entry) => entry && !entry.startsWith('../') && !path.isAbsolute(entry))
+    )].sort((a, b) => a.localeCompare(b, 'fr'));
+    // Une pièce ne peut être à la fois « espace de travail » et « ressource » :
+    // `resources` a priorité, on la retire donc de `unprotected`.
+    const resourcesList = clean(resources, existing.resources);
+    const resourceSet = new Set(resourcesList);
+    const unprotectedList = clean(unprotected, existing.unprotected).filter((key) => !resourceSet.has(key));
+    const temporaryFile = `${file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      fs.writeFileSync(
+        temporaryFile,
+        `${JSON.stringify({ version: 1, unprotected: unprotectedList, resources: resourcesList }, null, 2)}\n`,
+        'utf8'
+      );
+      fs.renameSync(temporaryFile, file);
+    } catch (error) {
+      fs.rmSync(temporaryFile, { force: true });
+      throw error;
+    }
+    return { file, unprotected: new Set(unprotectedList), resources: resourceSet };
+  } finally {
+    fs.rmSync(lockFile, { force: true });
+  }
 }
 
 /** Vrai pour un chemin recevable dans une des deux listes d'exceptions. */
@@ -367,9 +386,9 @@ function markdownCounterpart(absolutePath, caseRoot) {
  * de naître au coffre-fort, elle ne pourrait plus se relire.
  *
  * Ne fait rien, et retourne pourquoi, quand le chemin n'est pas une pièce
- * classable : hors dossier, `.md`/`.json` (déjà lisibles), dotfile, mapping ou
- * scan PII (jamais déclassés), espace de travail OOXML implicite, ou clé déjà
- * inscrite. `resources` est prioritaire : une ressource n'est jamais
+ * classable : hors dossier, extension jamais protégée (seuls PDF et images le
+ * sont), dotfile, mapping ou scan PII (jamais déclassés), espace de travail
+ * OOXML implicite, ou clé déjà inscrite. `resources` est prioritaire : une ressource n'est jamais
  * rétrogradée en espace de travail. Idempotent, ne lève jamais.
  */
 function classifyAsWorkspace(absolutePath, caseRoot) {
@@ -378,12 +397,15 @@ function classifyAsWorkspace(absolutePath, caseRoot) {
     if (isMappingFile(absolutePath)) return { classified: false, key: null, reason: 'mapping' };
     const key = exceptionKey(absolutePath, caseRoot);
     if (!key) return { classified: false, key: null, reason: 'non-classable' };
+    if (!PROTECTED_EXTENSIONS.has(path.extname(key).toLowerCase())) return { classified: false, key, reason: 'jamais protégée' };
     if (isOoxmlWorkspacePath(absolutePath, caseRoot)) return { classified: false, key, reason: 'ooxml' };
-    const { unprotected, resources } = readProtection(caseRoot);
-    if (resources.has(key)) return { classified: false, key, reason: 'ressource' };
-    if (unprotected.has(key)) return { classified: false, key, reason: 'déjà classée' };
-    writeProtection(caseRoot, { unprotected: [...unprotected, key] });
-    return { classified: true, key, reason: null };
+    let reason = null;
+    mutateProtection(caseRoot, ({ unprotected, resources }) => {
+      if (resources.has(key)) reason = 'ressource';
+      else if (unprotected.has(key)) reason = 'déjà classée';
+      return reason ? null : { unprotected: [...unprotected, key] };
+    });
+    return { classified: !reason, key, reason };
   } catch (error) {
     return { classified: false, key: null, reason: error?.message || 'erreur' };
   }
@@ -395,7 +417,6 @@ module.exports = {
   exceptionKey,
   isMappingFile,
   isSecretFile,
-  locateCase,
   isProtectedFile,
   isProtectionBypassed,
   isOoxmlWorkspacePath,