@piecemaker-legal/piecemaker 2.0.9 → 2.0.11

package/server/piecemaker/model-discovery/codex-catalog.ts

@@ -0,0 +1,67 @@
+import { createRequire } from 'node:module';
+
+import type { ProviderModelOption, ProviderModelsDefinition } from '@/shared/types.js';
+
+import { withStdioRpcServer, type RpcCall, type StdioRpcServer } from './stdio-rpc.js';
+
+type CodexListedModel = {
+  model: string;
+  displayName?: string;
+  description?: string;
+  hidden?: boolean;
+  isDefault?: boolean;
+  defaultReasoningEffort?: string;
+  supportedReasoningEfforts?: { reasoningEffort: string; description?: string }[];
+};
+
+type CodexModelListPage = {
+  data?: CodexListedModel[];
+  nextCursor?: string | null;
+};
+
+const MAX_PAGES = 10;
+
+function bundledCodexAppServer(): StdioRpcServer {
+  const launcher = createRequire(import.meta.url).resolve('@openai/codex/bin/codex.js');
+  return { command: process.execPath, args: [launcher, 'app-server'] };
+}
+
+function toModelOption(listed: CodexListedModel): ProviderModelOption {
+  const efforts = listed.supportedReasoningEfforts ?? [];
+  return {
+    value: listed.model,
+    label: listed.displayName || listed.model,
+    ...(listed.description ? { description: listed.description } : {}),
+    ...(efforts.length > 0 ? {
+      effort: {
+        ...(listed.defaultReasoningEffort ? { default: listed.defaultReasoningEffort } : {}),
+        values: efforts.map(({ reasoningEffort, description }) => ({
+          value: reasoningEffort,
+          ...(description ? { description } : {}),
+        })),
+      },
+    } : {}),
+  };
+}
+
+export async function listCodexModels(call: RpcCall): Promise<ProviderModelsDefinition> {
+  const listed: CodexListedModel[] = [];
+  let cursor: string | null = null;
+  for (let page = 0; page < MAX_PAGES; page += 1) {
+    const result = await call('model/list', { cursor, includeHidden: false }) as CodexModelListPage;
+    listed.push(...(result.data ?? []));
+    cursor = result.nextCursor ?? null;
+    if (!cursor) break;
+  }
+
+  const visible = listed.filter((model) => model.model && !model.hidden);
+  if (visible.length === 0) throw new Error('codex app-server listed no models');
+  return {
+    OPTIONS: visible.map(toModelOption),
+    DEFAULT: (visible.find((model) => model.isDefault) ?? visible[0]).model,
+  };
+}
+
+export function discoverCodexModels(timeoutMs: number): Promise<ProviderModelsDefinition> {
+  return withStdioRpcServer(bundledCodexAppServer(), listCodexModels, timeoutMs);
+}

package/server/piecemaker/model-discovery/index.ts

@@ -0,0 +1,69 @@
+import type { IProvider } from '@/shared/interfaces.js';
+import type { ProviderModelsDefinition } from '@/shared/types.js';
+
+import { discoverCodexModels } from './codex-catalog.js';
+import { discoverMistralModels } from './mistral-catalog.js';
+
+type Discover = (timeoutMs: number) => Promise<ProviderModelsDefinition>;
+
+type ProviderLookup = {
+  resolveProvider(provider: string): Pick<IProvider, 'models'>;
+};
+
+type ModelDiscoveryOptions = {
+  discoverers?: Record<string, Discover>;
+  refreshAfterMs?: number;
+  retryAfterMs?: number;
+  timeoutMs?: number;
+  now?: () => number;
+  warn?: (message: string) => void;
+};
+
+const DEFAULT_DISCOVERERS: Record<string, Discover> = {
+  codex: discoverCodexModels,
+  mistral: discoverMistralModels,
+};
+
+export function installModelDiscovery(registry: ProviderLookup, options: ModelDiscoveryOptions = {}) {
+  const {
+    discoverers = DEFAULT_DISCOVERERS,
+    refreshAfterMs = 10 * 60_000,
+    retryAfterMs = 60_000,
+    timeoutMs = 20_000,
+    now = Date.now,
+    warn = (message) => console.warn(message),
+  } = options;
+
+  for (const [provider, discover] of Object.entries(discoverers)) {
+    const models = registry.resolveProvider(provider).models;
+    const curated = models.getSupportedModels.bind(models);
+    let lastDiscovered: ProviderModelsDefinition | null = null;
+    let served: ProviderModelsDefinition | null = null;
+    let expiresAt = 0;
+    let refreshing: Promise<ProviderModelsDefinition> | null = null;
+
+    const refresh = () => {
+      refreshing ??= (async () => {
+        try {
+          lastDiscovered = await discover(timeoutMs);
+          served = lastDiscovered;
+          expiresAt = now() + refreshAfterMs;
+        } catch (error) {
+          warn(`[PieceMaker] ${provider} model discovery failed: ${error instanceof Error ? error.message : String(error)}`);
+          served = lastDiscovered ?? await curated();
+          expiresAt = now() + retryAfterMs;
+        }
+        return served;
+      })().finally(() => { refreshing = null; });
+      return refreshing;
+    };
+
+    models.getSupportedModels = async () => {
+      if (!served) return refresh();
+      if (now() >= expiresAt) void refresh();
+      return served;
+    };
+
+    void models.getSupportedModels();
+  }
+}

package/server/piecemaker/model-discovery/mistral-catalog.ts

@@ -0,0 +1,36 @@
+import { buildVibeModelsEnvironment, vibeModelOption } from '@/modules/providers/list/mistral/mistral-vibe-models.js';
+import type { ProviderModelsDefinition } from '@/shared/types.js';
+
+import { withStdioRpcServer, type RpcCall } from './stdio-rpc.js';
+
+type VibeModelView = {
+  name: string;
+  alias: string;
+  displayName?: string;
+};
+
+type VibeConfigRead = {
+  config?: {
+    models?: VibeModelView[];
+    activeModel?: { alias?: string } | null;
+    defaultModelAlias?: string;
+  };
+};
+
+export async function listVibeModels(call: RpcCall): Promise<ProviderModelsDefinition> {
+  const { config } = await call('config/read', {}) as VibeConfigRead;
+  const models = (config?.models ?? []).filter((model) => model.alias);
+  if (models.length === 0) throw new Error('vibe-app-server listed no models');
+
+  const aliases = new Set(models.map((model) => model.alias));
+  const preferred = [config?.activeModel?.alias, config?.defaultModelAlias].find((alias) => alias && aliases.has(alias));
+  return {
+    OPTIONS: models.map((model) => vibeModelOption(model.alias, model.displayName || model.alias, model.name)),
+    DEFAULT: preferred ?? models[0].alias,
+  };
+}
+
+export function discoverMistralModels(timeoutMs: number): Promise<ProviderModelsDefinition> {
+  const env = { ...process.env, VIBE_MODELS: buildVibeModelsEnvironment() };
+  return withStdioRpcServer({ command: 'vibe-app-server', args: [], env }, listVibeModels, timeoutMs);
+}

package/server/piecemaker/model-discovery/stdio-rpc.ts

@@ -0,0 +1,79 @@
+import readline from 'node:readline';
+
+import crossSpawn from 'cross-spawn';
+
+type RpcReply = {
+  id?: number;
+  result?: unknown;
+  error?: { message?: string };
+};
+
+export type RpcCall = (method: string, params: unknown) => Promise<unknown>;
+
+export type StdioRpcServer = {
+  command: string;
+  args: string[];
+  env?: NodeJS.ProcessEnv;
+};
+
+const CLIENT_INFO = { name: 'piecemaker', title: 'PieceMaker', version: '1' };
+
+export async function withStdioRpcServer<T>(
+  server: StdioRpcServer,
+  exchange: (call: RpcCall) => Promise<T>,
+  timeoutMs: number,
+): Promise<T> {
+  const child = crossSpawn(server.command, server.args, { env: server.env ?? process.env, stdio: ['pipe', 'pipe', 'pipe'] });
+  const pending = new Map<number, (reply: RpcReply) => void>();
+  let nextId = 1;
+  let stderr = '';
+
+  const failAll = (reason: string) => {
+    for (const settle of pending.values()) settle({ error: { message: reason } });
+    pending.clear();
+  };
+
+  child.stderr?.on('data', (chunk) => { stderr = (stderr + String(chunk)).slice(-1000); });
+  child.on('error', (error) => failAll(error.message));
+  child.on('exit', (code) => failAll(`${server.command} exited (code ${code ?? 'null'}) ${stderr.trim().split('\n').pop() ?? ''}`.trim()));
+  child.stdin?.on('error', (error) => failAll(error.message));
+  child.stdout?.on('error', (error) => failAll(error.message));
+  child.stderr?.on('error', () => {});
+
+  const reader = readline.createInterface({ input: child.stdout! });
+  reader.on('line', (line) => {
+    let reply: RpcReply;
+    try { reply = JSON.parse(line) as RpcReply; } catch { return; }
+    if (typeof reply.id !== 'number') return;
+    pending.get(reply.id)?.(reply);
+    pending.delete(reply.id);
+  });
+
+  const call: RpcCall = (method, params) => new Promise((resolve, reject) => {
+    const id = nextId++;
+    pending.set(id, (reply) => (reply.error
+      ? reject(new Error(reply.error.message || `${server.command} rejected ${method}`))
+      : resolve(reply.result)));
+    child.stdin?.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+  });
+
+  let timer: NodeJS.Timeout | undefined;
+  const deadline = new Promise<never>((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`${server.command} did not answer within ${timeoutMs} ms`)), timeoutMs);
+  });
+
+  try {
+    return await Promise.race([
+      (async () => {
+        await call('initialize', { clientInfo: CLIENT_INFO, capabilities: {} });
+        child.stdin?.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'initialized', params: {} })}\n`);
+        return exchange(call);
+      })(),
+      deadline,
+    ]);
+  } finally {
+    clearTimeout(timer);
+    reader.close();
+    child.kill();
+  }
+}

package/server/piecemaker/project-registry.ts

@@ -0,0 +1,34 @@
+import path from 'path';
+
+import { projectsDb } from '@/modules/database/index.js';
+
+const PUBLISH_INTERVAL_MS = 5000;
+
+type PublishProjectSource = (sourceId: string, folders: string[] | null) => void;
+
+export function startProjectRegistry(publishProjectSource: PublishProjectSource): () => void {
+  const sourceId = `database:${path.resolve(process.env.DATABASE_PATH || 'auth.db')}`;
+  let publishedSignature: string | null = null;
+
+  const publishProjects = () => {
+    const folders = [...projectsDb.getProjectPaths(), ...projectsDb.getArchivedProjectPaths()]
+      .map((row) => row.project_path)
+      .sort();
+    const signature = folders.join('\n');
+    if (signature === publishedSignature) return;
+    publishProjectSource(sourceId, folders);
+    publishedSignature = signature;
+  };
+
+  const publishProjectsSafely = () => {
+    try {
+      publishProjects();
+    } catch (error) {
+      console.error('[PieceMaker] Publication des projets impossible :', error);
+    }
+  };
+
+  publishProjectsSafely();
+  setInterval(publishProjectsSafely, PUBLISH_INTERVAL_MS).unref();
+  return publishProjectsSafely;
+}

package/server/piecemaker/router.cjs

@@ -13,10 +13,10 @@ const path = require('path');
 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 { resolveCaseReference } = require('./vendor/websocket-server/case-registry.cjs');
+const { publishProjectSource } = require('./vendor/piecemaker-plugin/scripts/lib/case-folders.cjs');
 const protectionLibrary = require('./vendor/piecemaker-plugin/scripts/lib/protection.cjs');
 const { createProtectionBypassRouter } = require('./protection/routes.cjs');
 const { createActivationRouter } = require('./activation/index.cjs');
@@ -53,7 +53,7 @@ function piecemakerHome() {
  * @param {() => object} [options.getRuntimeStatus] Ce que la carte des composants
  *   affiche du serveur hôte (port, hôte, dépendances système).
  */
-function createPieceMakerRouter({ getRuntimeStatus = defaultRuntimeStatus, anonymizer: applicationAnonymizer } = {}) {
+function createPieceMakerRouter({ getRuntimeStatus = defaultRuntimeStatus, anonymizer, publishProjects = () => {} } = {}) {
   const express = require('express');
   const router = express.Router();
 
@@ -64,9 +64,9 @@ function createPieceMakerRouter({ getRuntimeStatus = defaultRuntimeStatus, anony
   // l'app de bureau (origine `file://`) comme l'accès depuis le réseau local.
   router.post('/repository/cases/selected', async (request, response) => {
     try {
+      publishProjects();
       const result = await registerLegalCase({
         folder: request.body?.folder,
-        configFile: path.join(homeDir, 'config.json'),
         homeDir,
       });
       response.status(201).json({ ok: true, ...result });
@@ -78,7 +78,7 @@ function createPieceMakerRouter({ getRuntimeStatus = defaultRuntimeStatus, anony
   // Levée de protection à l'échelle du dossier : ajout PieceMaker monté avant
   // le vendor, qui n'expose que le classement pièce par pièce.
   router.use(createProtectionBypassRouter({
-    resolveCase: (reference) => resolveCaseReference(readRegistryConfig(path.join(homeDir, 'config.json')), reference),
+    resolveCase: (reference) => resolveCaseReference(reference),
     protection: protectionLibrary,
   }));
 
@@ -98,11 +98,9 @@ function createPieceMakerRouter({ getRuntimeStatus = defaultRuntimeStatus, anony
 
   router.use(createStampingRouter({ homeDir }));
 
-  const anonymizer = applicationAnonymizer || createAnonymizerService({ homeDir });
-  if (!applicationAnonymizer) void anonymizer.start();
   router.use(createAnonymizerRouter({ service: anonymizer }));
 
   return router;
 }
 
-module.exports = { createPieceMakerRouter, piecemakerHome, stopOriginalsJobs, VENDOR_ROOT };
+module.exports = { createPieceMakerRouter, piecemakerHome, publishProjectSource, stopOriginalsJobs, VENDOR_ROOT };

package/server/piecemaker/vendor/installer/bin/piecemaker.mjs

@@ -37,14 +37,12 @@ import { COMMANDS, CHRONOLOGY_ACTIONS } from '../lib/commandes.mjs';
 import { loadConfig, readEnv, markStep, loadState, CONFIG_FILE } from '../lib/state.mjs';
 import { scheduleStepResume, selectStepsToResume } from '../lib/resume-steps.mjs';
 import { appServerPort, readLocalScanJob, startLocalScan } from '../lib/conversion-client.mjs';
-import { restartTelegramDaemon, checkForUpdate, updateRepository } from '../lib/service.mjs';
+import { checkForUpdate, updateRepository } from '../lib/service.mjs';
 
 const require = createRequire(import.meta.url);
 const CLAUDE_ASSETS_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/claude-assets.cjs');
 const CLAUDE_HOOKS_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/claude-hooks.cjs');
-const CENTRAL_MAPPING_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../piecemaker-plugin/scripts/lib/central-mapping.cjs');
 const DOCUMENT_INDEX_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/document-index.cjs');
-const CASE_INSTRUCTIONS_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/case-instructions.cjs');
 const ORIGINALS_PIPELINE_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/originals-pipeline.cjs');
 const APP_CLI_LIB = path.join(GIT_REPO_ROOT, 'scripts', 'piecemaker', 'cli', 'lib');
 
@@ -62,18 +60,7 @@ function loadClaudeIntegrations() {
     : null;
 }
 
-/** Recharge le générateur du mapping central après un reset Git. */
-function loadCentralMappingIntegration() {
-  if (!fs.existsSync(CENTRAL_MAPPING_MODULE)) return null;
-  try {
-    const integration = require(CENTRAL_MAPPING_MODULE);
-    return typeof integration.syncCentralMapping === 'function' ? integration : null;
-  } catch {
-    return null;
-  }
-}
-
-function reconcileCentralMapping() {
+function removeDeprecatedClaudeHooks() {
   let hooksRemoved = false;
   const claude = loadClaudeIntegrations();
   if (typeof claude?.removeDeprecatedHooks === 'function') {
@@ -82,31 +69,9 @@ function reconcileCentralMapping() {
     if (!cleanup.ok) log.warn(`Hooks hérités non nettoyés (${cleanup.reason}).`);
     else if (cleanup.changed) log.ok('Hooks hérités Claude Code retirés.');
   }
-
-  const integration = loadCentralMappingIntegration();
-  const central = integration?.syncCentralMapping(loadConfig());
-  if (central) log.ok(`Mapping central du proxy reconstruit (${central.entities || 0} entité(s)).`);
-  else log.warn('Mapping central du proxy non reconstruit ; relancez « piecemaker ».');
   return hooksRemoved;
 }
 
-function reconcileCaseInstructions() {
-  if (!fs.existsSync(CASE_INSTRUCTIONS_MODULE)) return false;
-  try {
-    const { refreshRegisteredCaseRules } = require(CASE_INSTRUCTIONS_MODULE);
-    if (typeof refreshRegisteredCaseRules !== 'function') return false;
-    const result = refreshRegisteredCaseRules(REPO_ROOT, loadConfig());
-    if (result.failed.length) {
-      log.warn(`${result.failed.length} règle(s) de dossier n’ont pas pu être actualisées.`);
-    }
-    if (result.refreshed) log.ok(`${result.refreshed} règle(s) de dossier PieceMaker actualisée(s).`);
-    return result.failed.length === 0;
-  } catch (error) {
-    log.warn(`Règles de dossier non actualisées (${error.message}).`);
-    return false;
-  }
-}
-
 /**
  * Reprend en tâche de fond les étapes d'installation restées incomplètes.
  *
@@ -427,8 +392,8 @@ function formatChronologyText(chronology) {
 }
 
 function locateChronologyCase(flags) {
-  const { locateConfiguredCase } = require('../../piecemaker-plugin/scripts/lib/case-folders.cjs');
-  const located = locateConfiguredCase(loadConfig(), flags.caseTarget || process.cwd());
+  const { locateProjectCase } = require('../../piecemaker-plugin/scripts/lib/case-folders.cjs');
+  const located = locateProjectCase(flags.caseTarget || process.cwd());
   if (!located) {
     throw new Error('Lancez la commande depuis un dossier juridique enregistré ou passez --case <chemin>.');
   }
@@ -625,8 +590,8 @@ async function runConversionCommand(flags) {
   if (!fs.existsSync(ORIGINALS_PIPELINE_MODULE)) {
     throw new Error('Le module de conversion PieceMaker est introuvable.');
   }
-  const { locateConfiguredCase } = require('../../piecemaker-plugin/scripts/lib/case-folders.cjs');
-  const located = locateConfiguredCase(loadConfig(), flags.caseTarget || process.cwd());
+  const { locateProjectCase } = require('../../piecemaker-plugin/scripts/lib/case-folders.cjs');
+  const located = locateProjectCase(flags.caseTarget || process.cwd());
   if (!located) {
     throw new Error('Lancez la commande depuis un dossier juridique enregistré ou passez --case <chemin>.');
   }
@@ -666,8 +631,7 @@ async function runOperationalCommand(command, knownUpdate = null, flags = {}) {
     const pending = knownUpdate ?? checkForUpdate();
     if (!pending.available) {
       log.ok(`PieceMaker est déjà à jour (${pending.ref}, ${pending.current.slice(0, 7)}).`);
-      reconcileCaseInstructions();
-      if (reconcileCentralMapping()) {
+      if (removeDeprecatedClaudeHooks()) {
         log.info('Rouvrez les sessions Claude Code actives pour oublier les hooks hérités.');
       }
       // « update » reste le geste de remise à niveau : même sans nouveau commit,
@@ -681,44 +645,34 @@ async function runOperationalCommand(command, knownUpdate = null, flags = {}) {
       log.info(`Restauration de l’installation depuis le dépôt distant (${pending.localChanges} fichier(s) localement modifié(s)).`);
     }
 
-    try {
-      const result = updateRepository(pending);
-      log.ok(`PieceMaker mis à jour (${result.ref}, ${result.target.slice(0, 7)}).`);
-
-      reconcileCaseInstructions();
+    const result = updateRepository(pending);
+    log.ok(`PieceMaker mis à jour (${result.ref}, ${result.target.slice(0, 7)}).`);
 
-      if (result.pythonChanged) {
-        log.warn('Une dépendance Python a changé : relancez « piecemaker install » (étape 03 si elle est installée).');
-      }
-
-      // Les composants PieceMaker sont découverts directement dans
-      // ~/.claude/{skills,agents}. Les liens symboliques suivent déjà le dépôt ;
-      // cet appel rafraîchit aussi le repli par copie sur les plateformes qui ne
-      // peuvent pas créer de liens.
-      const claudeIntegrations = loadClaudeIntegrations();
-      if (commandExists('claude', ['--version']) && claudeIntegrations) {
-        const claudeAssets = claudeIntegrations.syncClaudeAssets(REPO_ROOT, os.homedir());
-        if (claudeAssets.conflicts.length) {
-          log.warn(`${claudeAssets.conflicts.length} skill(s)/agent(s) Claude personnel(s) homonyme(s) conservé(s).`);
-        } else {
-          log.ok(`${claudeAssets.registered} skill(s)/agent(s) PieceMaker synchronisé(s) pour Claude Code.`);
-        }
-        const claudeHooks = claudeIntegrations.installClaudeHooks(REPO_ROOT, os.homedir());
-        if (!claudeHooks.ok) log.warn(`Hooks Claude Code non synchronisés (${claudeHooks.reason}).`);
-        else if (claudeHooks.changed) log.ok(`${claudeHooks.registered} hook(s) PieceMaker synchronisé(s) pour Claude Code.`);
-      }
+    if (result.pythonChanged) {
+      log.warn('Une dépendance Python a changé : relancez « piecemaker install » (étape 03 si elle est installée).');
+    }
 
-      reconcileCentralMapping();
-      log.info('Rouvrez les sessions Claude Code/Codex actives pour charger les hooks et le MCP mis à jour.');
-    } finally {
-      const daemon = restartTelegramDaemon();
-      if (daemon.restarted) log.ok('Moniteur Telegram redémarré.');
-      else if (daemon.reason && daemon.reason !== 'absent' && daemon.reason !== 'unsupported') {
-        log.warn(`Le moniteur Telegram n’a pas redémarré : ${daemon.reason}`);
+    // Les composants PieceMaker sont découverts directement dans
+    // ~/.claude/{skills,agents}. Les liens symboliques suivent déjà le dépôt ;
+    // cet appel rafraîchit aussi le repli par copie sur les plateformes qui ne
+    // peuvent pas créer de liens.
+    const claudeIntegrations = loadClaudeIntegrations();
+    if (commandExists('claude', ['--version']) && claudeIntegrations) {
+      const claudeAssets = claudeIntegrations.syncClaudeAssets(REPO_ROOT, os.homedir());
+      if (claudeAssets.conflicts.length) {
+        log.warn(`${claudeAssets.conflicts.length} skill(s)/agent(s) Claude personnel(s) homonyme(s) conservé(s).`);
+      } else {
+        log.ok(`${claudeAssets.registered} skill(s)/agent(s) PieceMaker synchronisé(s) pour Claude Code.`);
       }
+      const claudeHooks = claudeIntegrations.installClaudeHooks(REPO_ROOT, os.homedir());
+      if (!claudeHooks.ok) log.warn(`Hooks Claude Code non synchronisés (${claudeHooks.reason}).`);
+      else if (claudeHooks.changed) log.ok(`${claudeHooks.registered} hook(s) PieceMaker synchronisé(s) pour Claude Code.`);
     }
-    // Après le `finally` : une mise à jour qui a échoué ne doit pas enchaîner
-    // sur une réinstallation en fond, l'exception traverse d'abord.
+
+    removeDeprecatedClaudeHooks();
+    log.info('Rouvrez les sessions Claude Code/Codex actives pour charger les hooks et le MCP mis à jour.');
+    // Une mise à jour qui a échoué ne doit pas enchaîner sur une
+    // réinstallation en fond : l'exception traverse d'abord.
     await resumePendingStepsAfterUpdate();
     return 0;
   }

package/server/piecemaker/vendor/installer/lib/codex-skills.mjs

@@ -11,8 +11,6 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-import { GIT_REPO_ROOT } from './platform.mjs';
-
 const PLUGIN_DIRECTORY = 'piecemaker-plugin';
 const PLUGIN_SKILL_PATH = /(^|[\\/])piecemaker-plugin[\\/]skills[\\/][^\\/]+$/;
 
@@ -32,32 +30,6 @@ export function codexHooksFile(userHome = os.homedir()) {
   return path.join(userHome, '.codex', 'hooks.json');
 }
 
-/** Script unifié Claude/Codex, à la racine du dépôt — pas une copie vendorisée. */
-function codexProxyGuardScript() {
-  return path.join(GIT_REPO_ROOT, 'scripts', 'piecemaker', 'hooks', 'proxy-guard.mjs');
-}
-
-function isPieceMakerProxyGuard(handler) {
-  const command = typeof handler?.command === 'string' ? handler.command : '';
-  const commandWindows = typeof handler?.commandWindows === 'string' ? handler.commandWindows : '';
-  return (command.includes('proxy-guard.mjs') || commandWindows.includes('proxy-guard.mjs'))
-    && (command.includes('PIECEMAKER_HOOK_CLIENT=codex') || commandWindows.includes('PIECEMAKER_HOOK_CLIENT=codex'));
-}
-
-function codexProxyGuardGroup() {
-  const script = codexProxyGuardScript();
-  return {
-    matcher: 'startup|resume|clear',
-    hooks: [{
-      type: 'command',
-      command: `PIECEMAKER_HOOK_CLIENT=codex node ${JSON.stringify(script)}`,
-      commandWindows: `set "PIECEMAKER_HOOK_CLIENT=codex" && node ${JSON.stringify(script)}`,
-      timeout: 45,
-      statusMessage: 'Vérification de l’anonymisation PieceMaker',
-    }],
-  };
-}
-
 function readCodexHooks(userHome) {
   const file = codexHooksFile(userHome);
   if (!fs.existsSync(file)) return { file, document: { hooks: {} } };
@@ -68,7 +40,7 @@ function readCodexHooks(userHome) {
     }
     if (document.hooks === undefined) document.hooks = {};
     if (!document.hooks || typeof document.hooks !== 'object' || Array.isArray(document.hooks)
-      || (document.hooks.SessionStart !== undefined && !Array.isArray(document.hooks.SessionStart))) {
+      || (document.hooks.PreToolUse !== undefined && !Array.isArray(document.hooks.PreToolUse))) {
       return { file, error: 'hooks-invalides' };
     }
     return { file, document };
@@ -77,60 +49,6 @@ function readCodexHooks(userHome) {
   }
 }
 
-export function codexSessionHookStatus(repoRoot, userHome = os.homedir()) {
-  const loaded = readCodexHooks(userHome);
-  if (loaded.error) return { ok: false, changed: false, file: loaded.file, reason: loaded.error };
-  const expected = codexProxyGuardGroup(repoRoot);
-  const groups = Array.isArray(loaded.document.hooks.SessionStart)
-    ? loaded.document.hooks.SessionStart
-    : [];
-  const managed = groups.flatMap((group) => Array.isArray(group?.hooks) ? group.hooks : [])
-    .filter(isPieceMakerProxyGuard);
-  const exact = groups.some((group) => group?.matcher === expected.matcher
-    && Array.isArray(group.hooks)
-    && group.hooks.some((handler) => JSON.stringify(handler) === JSON.stringify(expected.hooks[0])));
-  return {
-    ok: exact && managed.length === 1,
-    changed: false,
-    file: loaded.file,
-    reason: exact && managed.length === 1 ? null : 'hook-absent-ou-perime',
-  };
-}
-
-/** Fusionne uniquement la sentinelle SessionStart ; tous les hooks personnels sont conservés. */
-export function installCodexSessionHook(repoRoot, userHome = os.homedir()) {
-  const loaded = readCodexHooks(userHome);
-  if (loaded.error) return { ok: false, changed: false, file: loaded.file, reason: loaded.error };
-  const document = loaded.document;
-  const groups = Array.isArray(document.hooks.SessionStart)
-    ? document.hooks.SessionStart
-    : [];
-  const preserved = [];
-  for (const group of groups) {
-    if (!group || typeof group !== 'object' || Array.isArray(group)) {
-      preserved.push(group);
-      continue;
-    }
-    const hooks = Array.isArray(group.hooks) ? group.hooks.filter((handler) => !isPieceMakerProxyGuard(handler)) : [];
-    if (hooks.length || !Array.isArray(group.hooks)) preserved.push({ ...group, hooks });
-  }
-  document.description ||= 'Hooks locaux Codex, dont la sentinelle d’anonymisation PieceMaker.';
-  document.hooks.SessionStart = [...preserved, codexProxyGuardGroup(repoRoot)];
-  const output = `${JSON.stringify(document, null, 2)}\n`;
-  let current = null;
-  try { current = fs.readFileSync(loaded.file, 'utf8'); } catch { /* fichier absent */ }
-  if (current === output) return { ok: true, changed: false, file: loaded.file, registered: 1 };
-  try {
-    fs.mkdirSync(path.dirname(loaded.file), { recursive: true });
-    const temporary = `${loaded.file}.tmp-${process.pid}`;
-    fs.writeFileSync(temporary, output, 'utf8');
-    fs.renameSync(temporary, loaded.file);
-    return { ok: true, changed: true, file: loaded.file, registered: 1 };
-  } catch (error) {
-    return { ok: false, changed: false, file: loaded.file, reason: error?.message || 'ecriture-impossible' };
-  }
-}
-
 /** Même script que la protection Claude Code : contrat PreToolUse deny identique. */
 function codexProtectionScript(repoRoot) {
   return path.join(pluginRoot(repoRoot), 'scripts', 'protect-originals.mjs');
@@ -194,7 +112,7 @@ export function installCodexProtectionHook(repoRoot, userHome = os.homedir()) {
     const hooks = Array.isArray(group.hooks) ? group.hooks.filter((handler) => !isPieceMakerProtection(handler)) : [];
     if (hooks.length || !Array.isArray(group.hooks)) preserved.push({ ...group, hooks });
   }
-  document.description ||= 'Hooks locaux Codex, dont la sentinelle d’anonymisation PieceMaker.';
+  document.description ||= 'Hooks locaux Codex, dont la protection des pièces PieceMaker.';
   document.hooks.PreToolUse = [...preserved, codexProtectionGroup(repoRoot)];
   const output = `${JSON.stringify(document, null, 2)}\n`;
   let current = null;