@piecemaker-legal/piecemaker 1.0.6 → 1.0.8

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

@@ -1,6 +1,9 @@
+import path from 'node:path';
+
 import { providerSkillsService } from '@/modules/providers/index.js';
 import type { LLMProvider, ProviderSkillListOptions } from '@/shared/types.js';
 
+import { importLibraryDirectory } from './migrate.js';
 import type { createLibraryStore } from './store.js';
 
 const LIBRARY_SKILL_PROVIDERS: LLMProvider[] = ['claude', 'codex', 'cursor', 'mistral', 'opencode'];
@@ -35,14 +38,20 @@ export async function scanAndPersistLibraryProviderSkills(
   store: ReturnType<typeof createLibraryStore>,
   workspacePath: string | undefined,
   reader: ProviderSkillsReader = providerSkillsService,
+  userHome?: string,
 ) {
   const result = await listLibraryProviderSkills(workspacePath, reader);
   for (const provider of result.providers) {
     for (const skill of provider.skills) {
-      if (!skill.sourcePath) continue;
+      if (!skill.sourcePath || skill.scope !== 'user' || skill.pluginId || skill.pluginName) continue;
       try { store.importFile(skill.sourcePath, 'skill'); }
       catch { try { store.importFile(skill.sourcePath, 'skill', false); } catch {} }
     }
   }
+  if (userHome) {
+    try { importLibraryDirectory(store, path.join(userHome, '.grok', 'skills'), 'skill', false); } catch {}
+  }
   return result;
 }
+
+export { scanAndPersistLibraryClaudeAgents, scanAndPersistLibraryProviderAgents } from './provider-agents.js';

package/server/piecemaker/library/store.ts

@@ -6,17 +6,26 @@ import Database from 'better-sqlite3';
 
 import { parseFrontMatter } from '@/shared/frontmatter.js';
 
+import { parseConnectorConfig, prepareConnectorInstallation, type LibraryConnectorConfig } from './connector-installation.js';
 import { prepareWorkspaceInstallation } from './workspace-installation.js';
 
 type StoredLibraryEntry = {
   id: string;
-  kind: 'skill' | 'agent';
+  kind: 'skill' | 'agent' | 'connector';
   name: string;
   description: string;
   content: string;
   assets: string;
 };
 
+type LibraryConnectorInput = {
+  name: string;
+  description: string;
+  config: LibraryConnectorConfig;
+  source: string;
+  namespace?: string;
+};
+
 type LibraryEntry = Omit<StoredLibraryEntry, 'assets'> & { assets: Record<string, string> };
 
 type LibraryCollectionEntry = {
@@ -112,14 +121,39 @@ export function createLibraryStore(home: string) {
   function list(workspacePath?: string) {
     const selected = workspacePath ? workspace(workspacePath) : '';
     return db.prepare(`SELECT e.id, e.kind, e.name, e.description,
-      EXISTS(SELECT 1 FROM activation a WHERE a.entry_id = e.id AND a.workspace = ?) AS enabled
+      EXISTS(SELECT 1 FROM activation a WHERE a.entry_id = e.id AND a.workspace = ?) AS enabled,
+      (SELECT ce.collection_id FROM collection_entries ce WHERE ce.entry_id = e.id LIMIT 1) AS collectionId
       FROM entries e ORDER BY e.name COLLATE NOCASE`).all(selected).map((row) => {
-        const entry = row as Omit<StoredLibraryEntry, 'content' | 'assets'> & { enabled: number };
-        return { ...entry, enabled: Boolean(entry.enabled) };
+        const entry = row as Omit<StoredLibraryEntry, 'content' | 'assets'> & { enabled: number; collectionId: string | null };
+        return { ...entry, enabled: Boolean(entry.enabled), collectionId: entry.collectionId || null };
       });
   }
 
-  function importFile(source: string, kind: StoredLibraryEntry['kind'], includeAssets = true) {
+  function persistImportedEntry(source: string, kind: StoredLibraryEntry['kind'], name: string, description: string, content: string, assets: Record<string, string>, id: string) {
+    const serialized = JSON.stringify(Object.fromEntries(Object.entries(assets).sort(([left], [right]) => left.localeCompare(right))));
+    const sourceHash = createHash('sha256').update(`${kind}\0${content}\0${serialized}`).digest('hex');
+    const originSource = !path.isAbsolute(source) || source.includes('#') ? source : path.resolve(source);
+    const existingOrigin = db.prepare('SELECT entry_id AS entryId, source_hash AS sourceHash FROM origins WHERE source = ?').get(originSource) as { entryId: string; sourceHash: string | null } | undefined;
+    if (existingOrigin) {
+      if (existingOrigin.sourceHash === null || existingOrigin.sourceHash === sourceHash) return existingOrigin.entryId;
+      const existingEntry = document(existingOrigin.entryId);
+      const existingAssets = JSON.stringify(Object.fromEntries(Object.entries(existingEntry.assets).sort(([left], [right]) => left.localeCompare(right))));
+      const existingHash = createHash('sha256').update(`${existingEntry.kind}\0${existingEntry.content}\0${existingAssets}`).digest('hex');
+      if (existingHash !== existingOrigin.sourceHash) return existingOrigin.entryId;
+      db.transaction(() => {
+        db.prepare('UPDATE entries SET name = ?, description = ?, content = ?, assets = ? WHERE id = ?').run(name, description, content, serialized, existingOrigin.entryId);
+        db.prepare('UPDATE origins SET source_hash = ? WHERE source = ?').run(sourceHash, originSource);
+      })();
+      return existingOrigin.entryId;
+    }
+    db.transaction(() => {
+      db.prepare('INSERT OR IGNORE INTO entries VALUES (?, ?, ?, ?, ?, ?)').run(id, kind, name, description, content, serialized);
+      db.prepare('INSERT INTO origins (source, entry_id, source_hash) VALUES (?, ?, ?)').run(originSource, id, sourceHash);
+    })();
+    return id;
+  }
+
+  function importFile(source: string, kind: 'skill' | 'agent', includeAssets = true) {
     const resolved = fs.realpathSync(source);
     const content = decodeUtf8File(fs.readFileSync(resolved));
     const parsed = parseFrontMatter(content);
@@ -147,30 +181,30 @@ export function createLibraryStore(home: string) {
       }
     }
     if (kind === 'skill' && includeAssets) collect(path.dirname(resolved));
-    const serialized = JSON.stringify(Object.fromEntries(Object.entries(assets).sort(([a], [b]) => a.localeCompare(b))));
-    const id = createHash('sha256').update(`${kind}\0${content}\0${serialized}`).digest('hex');
-    const sourceHash = id;
-    const existingOrigin = db.prepare('SELECT entry_id AS entryId, source_hash AS sourceHash FROM origins WHERE source = ?').get(path.resolve(source)) as { entryId: string; sourceHash: string | null } | undefined;
-    if (existingOrigin) {
-      if (existingOrigin.sourceHash === null || existingOrigin.sourceHash === sourceHash) return existingOrigin.entryId;
-      const existingEntry = document(existingOrigin.entryId);
-      const existingAssets = JSON.stringify(Object.fromEntries(Object.entries(existingEntry.assets).sort(([a], [b]) => a.localeCompare(b))));
-      const existingHash = createHash('sha256').update(`${existingEntry.kind}\0${existingEntry.content}\0${existingAssets}`).digest('hex');
-      if (existingHash !== existingOrigin.sourceHash) return existingOrigin.entryId;
-      db.transaction(() => {
-        db.prepare('UPDATE entries SET name = ?, description = ?, content = ?, assets = ? WHERE id = ?').run(name, description, content, serialized, existingOrigin.entryId);
-        db.prepare('UPDATE origins SET source_hash = ? WHERE source = ?').run(sourceHash, path.resolve(source));
-      })();
-      return existingOrigin.entryId;
-    }
-    db.transaction(() => {
-      db.prepare('INSERT OR IGNORE INTO entries VALUES (?, ?, ?, ?, ?, ?)').run(id, kind, name, description, content, serialized);
-      db.prepare('INSERT INTO origins (source, entry_id, source_hash) VALUES (?, ?, ?)').run(path.resolve(source), id, sourceHash);
-    })();
-    return id;
+    const id = createHash('sha256').update(`${kind}\0${content}\0${JSON.stringify(Object.fromEntries(Object.entries(assets).sort(([left], [right]) => left.localeCompare(right))))}`).digest('hex');
+    return persistImportedEntry(resolved, kind, name, description, content, assets, id);
+  }
+
+  function importContent(source: string, kind: 'skill' | 'agent', content: string) {
+    const parsed = parseFrontMatter(content);
+    const data = parsed.data;
+    const sourceName = path.basename(source, path.extname(source));
+    const name = String(data.metadata?.title || data.name || sourceName);
+    const description = typeof data.description === 'string' ? data.description : '';
+    const id = createHash('sha256').update(`${kind}\0${content}\0{}`).digest('hex');
+    return persistImportedEntry(source, kind, name, description, content, {}, id);
+  }
+
+  function importConnector(input: LibraryConnectorInput) {
+    const name = input.name.trim();
+    if (!name) throw new Error('Nom requis.');
+    const content = `${JSON.stringify(input.config, null, 2)}\n`;
+    const description = input.description.trim() || (input.config.url || input.config.command || name);
+    const id = createHash('sha256').update(`connector\0${input.namespace || ''}\0${name}`).digest('hex');
+    return persistImportedEntry(input.source, 'connector', name, description, content, {}, id);
   }
 
-  function createEntry(kind: StoredLibraryEntry['kind'], name: string, description: string) {
+  function createEntry(kind: 'skill' | 'agent', name: string, description: string) {
     const trimmedName = name.trim();
     if (!trimmedName) throw new Error('Nom requis.');
     const trimmedDescription = description.trim();
@@ -185,10 +219,16 @@ export function createLibraryStore(home: string) {
     return db.transaction(() => {
       const entry = document(id);
       if (entry.content !== previousContent) throw new Error('Le document a été modifié ailleurs. Rouvrez-le avant d’enregistrer.');
-      const { data } = parseFrontMatter(content);
-      const name = String(data.metadata?.title || data.name || entry.name);
-      const description = typeof data.description === 'string' ? data.description : '';
-      db.prepare('UPDATE entries SET name = ?, description = ?, content = ? WHERE id = ?').run(name, description, content, id);
+      if (entry.kind === 'connector') {
+        const config = parseConnectorConfig(content);
+        const description = config.url || config.command || entry.name;
+        db.prepare('UPDATE entries SET description = ?, content = ? WHERE id = ?').run(description, `${JSON.stringify(config, null, 2)}\n`, id);
+      } else {
+        const { data } = parseFrontMatter(content);
+        const name = String(data.metadata?.title || data.name || entry.name);
+        const description = typeof data.description === 'string' ? data.description : '';
+        db.prepare('UPDATE entries SET name = ?, description = ?, content = ? WHERE id = ?').run(name, description, content, id);
+      }
       const active = db.prepare('SELECT workspace FROM activation WHERE entry_id = ?').all(id) as Array<{ workspace: string }>;
       for (const { workspace: selected } of active) setEnabled(selected, id, true);
       return document(id);
@@ -228,7 +268,7 @@ export function createLibraryStore(home: string) {
   }
 
   function upsertCollection(input: LibraryCollectionInput) {
-    if (!input.id || (!input.entries.length && !input.files.length)) return null;
+    if (!input.id || (!input.entries.length && !input.files.length && !input.source)) return null;
     return db.transaction(() => {
       db.prepare(`INSERT INTO collections (id, name, description, source) VALUES (?, ?, ?, ?)
         ON CONFLICT(id) DO UPDATE SET name = excluded.name, description = excluded.description, source = excluded.source`)
@@ -236,9 +276,11 @@ export function createLibraryStore(home: string) {
       db.prepare('DELETE FROM collection_entries WHERE collection_id = ?').run(input.id);
       const insert = db.prepare('INSERT INTO collection_entries (collection_id, entry_id, root_path) VALUES (?, ?, ?)');
       for (const entry of input.entries) insert.run(input.id, entry.entryId, normalizedCollectionPath(entry.rootPath));
-      db.prepare('DELETE FROM collection_files WHERE collection_id = ?').run(input.id);
-      const insertFile = db.prepare('INSERT INTO collection_files (collection_id, path, content) VALUES (?, ?, ?)');
-      for (const file of input.files) insertFile.run(input.id, normalizedCollectionPath(file.path), file.content);
+      if (input.files.length) {
+        db.prepare('DELETE FROM collection_files WHERE collection_id = ?').run(input.id);
+        const insertFile = db.prepare('INSERT INTO collection_files (collection_id, path, content) VALUES (?, ?, ?)');
+        for (const file of input.files) insertFile.run(input.id, normalizedCollectionPath(file.path), file.content);
+      }
       return input.id;
     })();
   }
@@ -275,7 +317,48 @@ export function createLibraryStore(home: string) {
       });
   }
 
+  function collectionSource(id: string): string | null {
+    const row = db.prepare('SELECT source FROM collections WHERE id = ?').get(id) as { source: string } | undefined;
+    return row?.source || null;
+  }
+
+  function collectSourceFiles(source: string): Array<{ path: string; content: Buffer }> {
+    const root = fs.realpathSync(source);
+    const files: Array<{ path: string; content: Buffer }> = [];
+    let totalSize = 0;
+    const walk = (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()) walk(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 : ${path.basename(root)}`);
+          files.push({ path: relativePath, content });
+        }
+      }
+    };
+    walk(root);
+    return files;
+  }
+
+  function ensureCollectionFiles(id: string) {
+    const stored = db.prepare('SELECT 1 FROM collection_files WHERE collection_id = ? LIMIT 1').get(id);
+    if (stored) return;
+    const source = collectionSource(id);
+    if (!source || !fs.existsSync(source) || fs.lstatSync(source).isSymbolicLink()) return;
+    const files = collectSourceFiles(source);
+    if (!files.length) return;
+    const insertFile = db.prepare('INSERT INTO collection_files (collection_id, path, content) VALUES (?, ?, ?)');
+    db.transaction(() => {
+      for (const file of files) insertFile.run(id, normalizedCollectionPath(file.path), file.content);
+    })();
+  }
+
   function collectionFiles(id: string) {
+    ensureCollectionFiles(id);
     const files = new Map<string, { path: string; size: number; editable: boolean }>();
     const storedFiles = db.prepare('SELECT path, content FROM collection_files WHERE collection_id = ?').all(id) as Array<{ path: string; content: Buffer }>;
     for (const file of storedFiles) {
@@ -304,6 +387,7 @@ export function createLibraryStore(home: string) {
   }
 
   function collectionFile(id: string, filePath: string) {
+    ensureCollectionFiles(id);
     const normalized = normalizedCollectionPath(filePath);
     for (const mapping of collectionEntries(id)) {
       const entry = document(mapping.entryId);
@@ -323,6 +407,7 @@ export function createLibraryStore(home: string) {
 
   function updateCollectionFile(id: string, filePath: string, content: string, previousContent: string) {
     if (typeof content !== 'string' || typeof previousContent !== 'string') throw new Error('Contenu et version précédente requis.');
+    ensureCollectionFiles(id);
     const normalized = normalizedCollectionPath(filePath);
     for (const mapping of collectionEntries(id)) {
       const entry = document(mapping.entryId);
@@ -373,6 +458,12 @@ export function createLibraryStore(home: string) {
     if (typeof enabled !== 'boolean') throw new Error('Activation booléenne requise.');
     const selected = workspace(workspacePath);
     const entry = document(id);
+    if (entry.kind === 'connector') {
+      prepareConnectorInstallation(selected, entry.name, parseConnectorConfig(entry.content), enabled)();
+      if (enabled) db.prepare('INSERT OR IGNORE INTO activation VALUES (?, ?)').run(selected, id);
+      else db.prepare('DELETE FROM activation WHERE workspace = ? AND entry_id = ?').run(selected, id);
+      return { ok: true, enabled };
+    }
     const packageRoot = path.join(directory, 'active', createHash('sha256').update(selected).digest('hex'), id);
     const install = prepareWorkspaceInstallation(selected, id, packageRoot, entry.kind, enabled);
     if (enabled) {
@@ -424,7 +515,7 @@ export function createLibraryStore(home: string) {
   function instructions(workspacePath: string) {
     const selected = workspace(workspacePath);
     const entries = db.prepare(`SELECT e.* FROM entries e JOIN activation a ON a.entry_id = e.id
-      WHERE a.workspace = ? ORDER BY e.name`).all(selected) as StoredLibraryEntry[];
+      WHERE a.workspace = ? AND e.kind IN ('skill', 'agent') ORDER BY e.name`).all(selected) as StoredLibraryEntry[];
     return entries.map((entry) => {
       const assets = JSON.parse(entry.assets) as Record<string, string>;
       const references = Object.entries(assets).filter(([name]) => name === 'table-columns.yaml')
@@ -442,6 +533,8 @@ export function createLibraryStore(home: string) {
     deleteEntry,
     updateDocument,
     importFile,
+    importContent,
+    importConnector,
     setEnabled,
     instructions,
     upsertCollection,

package/server/piecemaker/library/workspace-installation.ts

@@ -1,44 +1,69 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+const SKILL_PROVIDERS = ['.claude', '.agents', '.cursor', '.opencode', '.grok'];
+
+const AGENT_TARGETS = [
+  { provider: '.claude', folder: 'agents', extension: '.md', sourceFile: 'agent.md' },
+  { provider: '.codex', folder: 'agents', extension: '.toml', sourceFile: 'agent.toml' },
+  { provider: '.opencode', folder: 'agent', extension: '.md', sourceFile: 'agent.md' },
+  { provider: '.grok', folder: 'agents', extension: '.md', sourceFile: 'agent.md' },
+] as const;
+
+function assertWorkspaceDirectory(workspace: string, directory: string, enabled: boolean) {
+  if (!fs.existsSync(directory)) {
+    if (enabled) fs.mkdirSync(directory);
+    return;
+  }
+  if (!fs.statSync(directory).isDirectory() || !fs.realpathSync(directory).startsWith(workspace + path.sep)) {
+    throw new Error(`Répertoire de composants hors du dossier : ${directory}`);
+  }
+}
+
 export function prepareWorkspaceInstallation(workspace: string, id: string, packageRoot: string, kind: 'skill' | 'agent', enabled: boolean) {
-  const providers = kind === 'skill' ? ['.claude', '.agents'] : ['.claude', '.codex'];
-  const targets = providers.map((provider) => {
-    const parent = path.join(workspace, provider, kind === 'skill' ? 'skills' : 'agents');
-    const extension = kind === 'skill' ? '' : provider === '.claude' ? '.md' : '.toml';
-    const source = kind === 'skill' ? packageRoot : path.join(packageRoot, `agent${extension}`);
-    for (const directory of [path.dirname(parent), parent]) {
-      if (!fs.existsSync(directory)) {
-        if (enabled) fs.mkdirSync(directory);
-        continue;
-      }
-      if (!fs.statSync(directory).isDirectory() || !fs.realpathSync(directory).startsWith(workspace + path.sep)) {
-        throw new Error(`Répertoire de composants hors du dossier : ${directory}`);
-      }
-    }
-    const target = path.join(parent, `piecemaker-${id}${extension}`);
+  const targets = kind === 'skill'
+    ? SKILL_PROVIDERS.map((provider) => {
+      const parent = path.join(workspace, provider, 'skills');
+      for (const directory of [path.dirname(parent), parent]) assertWorkspaceDirectory(workspace, directory, enabled);
+      return {
+        parent,
+        target: path.join(parent, `piecemaker-${id}`),
+        source: packageRoot,
+        kind: 'skill' as const,
+      };
+    })
+    : AGENT_TARGETS.map((entry) => {
+      const parent = path.join(workspace, entry.provider, entry.folder);
+      for (const directory of [path.dirname(parent), parent]) assertWorkspaceDirectory(workspace, directory, enabled);
+      return {
+        parent,
+        target: path.join(parent, `piecemaker-${id}${entry.extension}`),
+        source: path.join(packageRoot, entry.sourceFile),
+        kind: 'agent' as const,
+      };
+    });
+
+  const prepared = targets.map((entry) => {
     let existing: fs.Stats;
-    try { existing = fs.lstatSync(target); }
+    try { existing = fs.lstatSync(entry.target); }
     catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { target, source, installed: false, content: null };
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { ...entry, installed: false, content: null };
       throw error;
     }
-    const content = kind === 'agent' && existing.isFile() ? fs.readFileSync(target) : null;
-    const owned = kind === 'skill'
-      ? existing.isSymbolicLink() && path.resolve(parent, fs.readlinkSync(target)) === source
-      : content && fs.existsSync(source) && content.equals(fs.readFileSync(source));
-    if (!owned) {
-      throw new Error(`Composant personnel préservé : ${target}`);
-    }
-    return { target, source, installed: true, content };
+    const content = entry.kind === 'agent' && existing.isFile() ? fs.readFileSync(entry.target) : null;
+    const owned = entry.kind === 'skill'
+      ? existing.isSymbolicLink() && path.resolve(entry.parent, fs.readlinkSync(entry.target)) === entry.source
+      : content && fs.existsSync(entry.source) && content.equals(fs.readFileSync(entry.source));
+    if (!owned) throw new Error(`Composant personnel préservé : ${entry.target}`);
+    return { ...entry, installed: true, content };
   });
 
   return () => {
-    const changed: typeof targets = [];
+    const changed: typeof prepared = [];
     try {
-      for (const entry of targets) {
-        const { target, source, installed } = entry;
-        if (enabled && kind === 'agent') {
+      for (const entry of prepared) {
+        const { target, source, installed, kind: targetKind } = entry;
+        if (enabled && targetKind === 'agent') {
           fs.copyFileSync(source, target);
           changed.push(entry);
         } else if (enabled && !installed) {

package/server/piecemaker/router.cjs

@@ -15,6 +15,7 @@ const VENDOR_ROOT = path.join(__dirname, 'vendor');
 const { createAnonymizerRouter } = require('./anonymizer/routes.cjs');
 const { createAnonymizerService } = require('./anonymizer/service.cjs');
 const { createAdminRouter, registerLegalCase } = require('./vendor/websocket-server/admin-routes.cjs');
+const { stopOriginalsJobs } = require('./vendor/websocket-server/originals-pipeline.cjs');
 const { readRegistryConfig, resolveCaseReference } = require('./vendor/websocket-server/case-registry.cjs');
 const protectionLibrary = require('./vendor/piecemaker-plugin/scripts/lib/protection.cjs');
 const { createProtectionBypassRouter } = require('./protection/routes.cjs');
@@ -104,4 +105,4 @@ function createPieceMakerRouter({ getRuntimeStatus = defaultRuntimeStatus, anony
   return router;
 }
 
-module.exports = { createPieceMakerRouter, piecemakerHome, VENDOR_ROOT };
+module.exports = { createPieceMakerRouter, piecemakerHome, stopOriginalsJobs, VENDOR_ROOT };

package/server/piecemaker/timesheet/service.ts

@@ -71,24 +71,12 @@ function validTimestamp(value: string | null | undefined): string | null {
   return Number.isNaN(date.getTime()) ? null : date.toISOString();
 }
 
-function hashFile(filePath: string): string {
-  const hash = createHash('sha256');
-  let descriptor: number | undefined;
+function fingerprintFile(filePath: string): string {
   try {
-    descriptor = fs.openSync(filePath, 'r');
-    const buffer = Buffer.allocUnsafe(64 * 1024);
-    let bytesRead = 0;
-    do {
-      bytesRead = fs.readSync(descriptor, buffer, 0, buffer.length, null);
-      if (bytesRead > 0) hash.update(buffer.subarray(0, bytesRead));
-    } while (bytesRead > 0);
-    return hash.digest('hex');
+    const stats = fs.statSync(filePath);
+    return `${stats.size}:${stats.mtimeMs}`;
   } catch {
     return 'missing';
-  } finally {
-    if (descriptor !== undefined) {
-      try { fs.closeSync(descriptor); } catch { }
-    }
   }
 }
 
@@ -115,7 +103,7 @@ function fingerprint(
     createdAt: session.created_at,
     updatedAt: session.updated_at,
     transcript: session.jsonl_path
-      ? { path: session.jsonl_path, content: hashFile(session.jsonl_path) }
+      ? { path: session.jsonl_path, content: fingerprintFile(session.jsonl_path) }
       : { history: messages ? hashHistory(messages) : 'pending' },
   })).digest('hex');
 }

package/server/piecemaker/vendor/installer/steps/03-python-gliner.mjs

@@ -25,7 +25,6 @@ export const meta = {
 const SCRIPTS_DIR = path.join(REPO_ROOT, 'websocket-server', 'scripts');
 const REQUIREMENTS = path.join(SCRIPTS_DIR, 'requirements.txt');
 const WARMUP = path.join(SCRIPTS_DIR, 'warmup.py');
-const BUILD_COREML = path.join(SCRIPTS_DIR, 'presidio-gliner', 'build_coreml.py');
 
 function truncate(text) {
   const width = Math.max(20, columns() - 6);
@@ -184,32 +183,6 @@ export async function install(ctx) {
   }
   spin.succeed('GLiNER2.5 multilingue et modèles spaCy prêts');
 
-  // Encodeur GPU CoreML (macOS) — optionnel. Il fait tourner l'encodeur mdeberta
-  // sur le GPU et libère les cœurs CPU pendant un scan. Best-effort :
-  // le runtime retombe sur torch si le modèle n'est pas généré, donc un échec ne
-  // fait jamais échouer l'étape.
-  if (process.platform === 'darwin' && fs.existsSync(BUILD_COREML)) {
-    const buildIt = await confirm(
-      'Générer le nouvel encodeur GPU CoreML pour GLiNER2.5 maintenant ? (~4 min une fois, ~620 Mo — rend les scans plus rapides et libère le CPU)',
-      true
-    );
-    if (buildIt) {
-      const coremlSpin = spinner('Génération de l\'encodeur GPU CoreML (peut prendre plusieurs minutes)...');
-      const coremlCode = await run(vp.python, [BUILD_COREML], {
-        cwd: path.dirname(BUILD_COREML),
-        onLine: (line) => coremlSpin.update(truncate(line)),
-      });
-      // build_coreml.py sort toujours 0 (best-effort) ; un code non nul signale un
-      // problème d'exécution, mais l'anonymisation reste fonctionnelle sur torch.
-      if (coremlCode === 0) {
-        coremlSpin.succeed('Encodeur GPU CoreML prêt (repli torch automatique si absent)');
-      } else {
-        coremlSpin.fail('Encodeur GPU CoreML non généré — les scans tourneront sur CPU torch');
-        return { status: 'done', note: 'Modèles prêts. Encodeur GPU non généré (scans sur CPU) — relancez l\'étape pour réessayer.' };
-      }
-    }
-  }
-
   return { status: 'done', note: '' };
 }
 

package/server/piecemaker/vendor/installer/steps/14-mxc-sandbox.mjs

@@ -8,7 +8,7 @@
  * PreToolUse hooks, which parse command text and are bypassable (see
  * docs/mxc-sandbox.md).
  *
- * Deliberately best-effort, like the CoreML encoder in step 03: mxc needs the
+ * Deliberately best-effort: mxc needs the
  * Rust toolchain, self-declares "not a security boundary currently", and its
  * value is defence-in-depth. Any failure falls back cleanly to the hooks and
  * never fails the install — the step is `required: false`. The runtime side

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

@@ -6,9 +6,8 @@
  * frontières de mots, des variantes Unicode et du tri longest-entity-first,
  * sinon deux moteurs de substitution divergent silencieusement.
  *
- * Ce moteur CommonJS est partagé par le serveur Word, l'historique et les
- * autres surfaces locales. Le proxy PII possède son
- * implémentation Python équivalente.
+ * Ce moteur CommonJS est partagé par le proxy PII (`anonymizer/dictionary.cjs`),
+ * l'historique et les autres surfaces locales.
  *
  * Deux sens, jamais symétriques dans leur usage :
  *  - `applyMapping`  entité → code, sur tout ce que l'IA s'apprête à lire ;

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

@@ -48,9 +48,9 @@ Bridge (`taskpane/modules/python-bridge.js` →
 
 Pour convertir puis scanner en un seul appel, utiliser
 `websocket-server/scripts/convert_and_scan_pipeline.py <file1> [file2 ...] -o <output_dir> [--engine ...] [--mode ...] [--lang ...]`,
-qui appelle `smart_converter.py` puis
-`websocket-server/scripts/presidio-gliner/presidio-gliner.py` pour chaque
-fichier. Sortie persistante : un Markdown par
+qui appelle `smart_converter.py` puis le worker
+`websocket-server/scripts/presidio-gliner/scanner_worker.py` (GLiNER chargé
+une fois pour tout le lot). Sortie persistante : un Markdown par
 fichier et un unique `{output_dir}/mapping_default.json` cumulatif. Dans le
 pipeline d'administration d'un dossier, `-o` vise le sous-dossier
 `Fichiers convertis PieceMaker/` du dossier (racine réservée aux originaux) ;

package/server/piecemaker/vendor/websocket-server/admin-routes.cjs

@@ -775,15 +775,9 @@ async function configurationOverview({ repoRoot, homeDir, userHome, getRuntimeSt
           .every((name) => fs.existsSync(path.join(glinerModelCache, revision, name))));
     } catch { return false; }
   })();
-  const glinerReady = fs.existsSync(path.join(glinerDir, 'presidio-gliner.py'))
+  const glinerReady = fs.existsSync(path.join(glinerDir, 'scanner_worker.py'))
     && hasPackage('gliner2')
     && glinerModelReady;
-  const coremlDefault = path.join(
-    glinerDir, 'models', 'gliner2.5-multi-v1-encoder_b1_832.mlmodelc',
-  );
-  const coreml = [process.env.PIECEMAKER_COREML_MODEL, coremlDefault]
-    .filter(Boolean)
-    .some((candidate) => fs.existsSync(candidate));
   const mineruReady = hasPackage('mineru') || hasPackage('magic_pdf')
     || fs.existsSync(path.join(venvDir, 'bin', 'mineru'));
   const folders = listConfiguredCases(readRegistryConfig(path.join(homeDir, 'config.json'))).map((entry) => {
@@ -841,11 +835,10 @@ async function configurationOverview({ repoRoot, homeDir, userHome, getRuntimeSt
         name: 'GLiNER2.5 · PII',
         installed: glinerReady,
         summary: glinerReady
-          ? coreml ? 'Détection locale · GPU CoreML' : 'Détection locale · CPU'
+          ? 'Détection locale · PyTorch'
           : 'Modèle d’anonymisation absent',
-        coreml,
         model: glinerModelId,
-        engine: coreml ? 'CoreML (GPU)' : 'torch (CPU)',
+        engine: 'torch',
       },
       mineru: {
         name: 'MinerU · OCR',