@piecemaker-legal/piecemaker 2.0.9 → 2.0.10

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,

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)) {