@piecemaker-legal/piecemaker 2.0.9 → 2.0.11

package/scripts/piecemaker/cli/disable-anonymizer.mjs

@@ -0,0 +1,19 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { removeLegacyProxyConfig } from '../../../server/piecemaker/anonymizer/client-config.cjs';
+
+const userHome = os.homedir();
+const homeDir = path.join(userHome, '.piecemaker');
+const configFile = path.join(homeDir, 'config.json');
+const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+if (!config || typeof config !== 'object' || Array.isArray(config)) throw new Error('Configuration PieceMaker invalide');
+
+const next = { ...config, anonymizer: { ...config.anonymizer, enabled: false } };
+const temporary = `${configFile}.piecemaker-${process.pid}-${Date.now()}`;
+fs.writeFileSync(temporary, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+fs.renameSync(temporary, configFile);
+
+removeLegacyProxyConfig({ userHome, homeDir });
+process.stdout.write('Proxy PII PieceMaker désactivé.\n');

package/scripts/piecemaker/cli/lib/config.mjs

@@ -25,7 +25,6 @@ export const INSTALLER_ENTRY = path.join(APP.directory, 'server', 'piecemaker',
 export const PORTS = {
   appServer: numberFromEnv('PIECEMAKER_APP_PORT', 3003),
   appClient: numberFromEnv('PIECEMAKER_VITE_PORT', 5173),
-  anonymizer: numberFromEnv('PIECEMAKER_PII_PORT', 4111),
 };
 
 export const APP_URL = `http://localhost:${PORTS.appClient}`;

package/scripts/piecemaker/cli/lib/plugins.mjs

@@ -12,6 +12,7 @@ export const PLUGINS = [
   { id: 'piecemaker-tampon', label: 'Plugin Bordereau' },
   { id: 'piecemaker-dossier', label: 'Plugin Dossier' },
   { id: 'piecemaker-library', label: 'Plugin Bibliothèque' },
+  { id: 'piecemaker-telegram', label: 'Plugin Telegram' },
 ];
 
 export async function installPlugins(runtime, report) {

package/scripts/piecemaker/cli/lib/services.mjs

@@ -33,15 +33,6 @@ export function appClientReachable() {
   return httpReachable(`http://127.0.0.1:${PORTS.appClient}/`);
 }
 
-function anonymizerPort() {
-  try {
-    const port = Number.parseInt(JSON.parse(fs.readFileSync(path.join(PIECEMAKER_HOME, 'config.json'), 'utf8')).mikePiiPort, 10);
-    if (Number.isInteger(port) && port > 0) return port;
-  } catch {
-  }
-  return PORTS.anonymizer;
-}
-
 function stopPid(pid) {
   if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
   if (process.platform === 'win32') {
@@ -61,7 +52,7 @@ export async function stopApplication() {
   } catch {
   }
 
-  for (const port of [PORTS.appClient, PORTS.appServer, anonymizerPort()]) {
+  for (const port of [PORTS.appClient, PORTS.appServer]) {
     const result = await freePort(port);
     killed.push(...result.killed);
     if (!result.released) occupied.push(port);

package/scripts/piecemaker/cli/piecemaker.mjs

@@ -2,7 +2,6 @@
 
 import { installPiecemakerCommand, piecemakerExecutable } from './install-command.mjs';
 import { APP, APP_URL, PORTS } from './lib/config.mjs';
-import { repairClientProxies } from './lib/piecemaker-anonymizer.mjs';
 import { installComponents } from './lib/composants.mjs';
 import { installPlugins } from './lib/plugins.mjs';
 import { gitAvailable, resolveNodeRuntime } from './lib/node-runtime.mjs';
@@ -130,8 +129,6 @@ async function main() {
   if (command.shims.length) ok(`installée : ${command.executable}`);
   else warn('commande absente du PATH — relancez node scripts/piecemaker/cli/install-command.mjs');
 
-  await repairClientProxies({ appDir: APP.directory, report });
-
   if (!options.launchOnly || !(await applicationIsRunning())) {
     const running = await resetAndLaunch(runtime);
     if (!running) return 1;

package/server/modules/providers/list/mistral/mistral-models.provider.ts

@@ -1,3 +1,4 @@
+import { VIBE_MODEL_PRESETS, vibeModelOption } from '@/modules/providers/list/mistral/mistral-vibe-models.js';
 import type { IProviderModels } from '@/shared/interfaces.js';
 import type {
   ProviderCurrentActiveModel,
@@ -8,60 +9,10 @@ import { buildDefaultProviderCurrentActiveModel } from '@/shared/utils.js';
 /** Curated Mistral catalog shipped as immutable CloudCLI defaults. */
 export const MISTRAL_PREDEFINED_MODELS: ProviderModelsDefinition = {
   OPTIONS: [
-    {
-      value: 'mistral-large-latest',
-      label: 'Mistral Large',
-      description: 'Most powerful Mistral model for complex reasoning and advanced tasks.',
-      effort: {
-        default: 'medium',
-        values: [
-          { value: 'low' },
-          { value: 'medium' },
-          { value: 'high' },
-        ],
-      },
-    },
-    {
-      value: 'mistral-medium-latest',
-      label: 'Mistral Medium',
-      description: 'Balanced model for everyday tasks and coding.',
-      effort: {
-        default: 'medium',
-        values: [
-          { value: 'low' },
-          { value: 'medium' },
-          { value: 'high' },
-        ],
-      },
-    },
-    {
-      value: 'mistral-small-latest',
-      label: 'Mistral Small',
-      description: 'Fast and efficient model for simpler tasks.',
-      effort: {
-        default: 'medium',
-        values: [
-          { value: 'low' },
-          { value: 'medium' },
-          { value: 'high' },
-        ],
-      },
-    },
-    {
-      value: 'codestral-latest',
-      label: 'Codestral',
-      description: 'Mistral model specialized for coding and development tasks.',
-      effort: {
-        default: 'medium',
-        values: [
-          { value: 'low' },
-          { value: 'medium' },
-          { value: 'high' },
-        ],
-      },
-    },
+    ...VIBE_MODEL_PRESETS.map((preset) => vibeModelOption(preset.alias, preset.display_name, preset.name)),
+    vibeModelOption('local', 'Devstral (local)', 'devstral'),
   ],
-  DEFAULT: 'mistral-large-latest',
+  DEFAULT: 'mistral-medium-3.5',
 };
 
 /** Provider registry model adapter for Mistral predefined models. */

package/server/modules/providers/list/mistral/mistral-runtime.provider.ts

@@ -1,5 +1,6 @@
 import crossSpawn from 'cross-spawn';
 
+import { buildVibeModelsEnvironment } from '@/modules/providers/list/mistral/mistral-vibe-models.js';
 import { notifyRunFailed, notifyRunStopped } from '@/modules/notifications/index.js';
 import type { IProviderRuntime } from '@/shared/interfaces.js';
 import type { AnyRecord, ProviderRuntimeContext, ProviderRuntimeWriter } from '@/shared/types.js';
@@ -300,9 +301,7 @@ async function spawnVibe(
       if (resolvedModel) {
         env.VIBE_ACTIVE_MODEL = resolvedModel;
       }
-      if (resolvedEffort) {
-        env.VIBE_EFFORT = resolvedEffort;
-      }
+      env.VIBE_MODELS = buildVibeModelsEnvironment(resolvedModel ?? undefined, resolvedEffort);
 
       vibeProcess = spawnFunction('vibe', args, {
         cwd: workingDir,

package/server/modules/providers/list/mistral/mistral-vibe-models.ts

@@ -0,0 +1,43 @@
+import type { ProviderModelOption } from '@/shared/types.js';
+
+type VibeModelPreset = {
+  name: string;
+  provider: string;
+  alias: string;
+  display_name: string;
+  adjustableReasoning: boolean;
+};
+
+export const VIBE_MODEL_PRESETS: readonly VibeModelPreset[] = [
+  { name: 'mistral-vibe-cli-latest', provider: 'mistral', alias: 'mistral-medium-3.5', display_name: 'Mistral Medium 3.5', adjustableReasoning: true },
+  { name: 'zai-glm-5-3', provider: 'mistral', alias: 'glm-5.3', display_name: 'Z.ai GLM 5.3', adjustableReasoning: false },
+  { name: 'zai-glm-5-2', provider: 'mistral', alias: 'glm-5.2', display_name: 'Z.ai GLM 5.2', adjustableReasoning: false },
+];
+
+export const VIBE_REASONING_EFFORT: NonNullable<ProviderModelOption['effort']> = {
+  default: 'high',
+  values: [
+    { value: 'none', description: 'Minimal thinking, no reasoning trace.' },
+    { value: 'high', description: 'Full reasoning before answering.' },
+  ],
+};
+
+const VIBE_THINKING_BY_EFFORT: Record<string, string> = { none: 'low', high: 'high' };
+
+export function vibeModelOption(alias: string, label: string, description?: string): ProviderModelOption {
+  const preset = VIBE_MODEL_PRESETS.find((candidate) => candidate.alias === alias);
+  return {
+    value: alias,
+    label,
+    ...(description ? { description } : {}),
+    ...(preset?.adjustableReasoning ? { effort: VIBE_REASONING_EFFORT } : {}),
+  };
+}
+
+export function buildVibeModelsEnvironment(selectedAlias?: string, effort?: string): string {
+  const thinking = effort ? VIBE_THINKING_BY_EFFORT[effort] : undefined;
+  return JSON.stringify(Object.fromEntries(VIBE_MODEL_PRESETS.map(({ adjustableReasoning, ...model }) => [
+    model.alias,
+    adjustableReasoning && thinking && model.alias === selectedAlias ? { ...model, thinking } : model,
+  ])));
+}

package/server/modules/providers/tests/mistral-vibe-models.test.ts

@@ -0,0 +1,27 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { MISTRAL_PREDEFINED_MODELS } from '@/modules/providers/list/mistral/mistral-models.provider.js';
+import { buildVibeModelsEnvironment } from '@/modules/providers/list/mistral/mistral-vibe-models.js';
+
+test('Vibe receives the GLM models alongside Mistral Medium without overriding thinking by default', () => {
+  const models = JSON.parse(buildVibeModelsEnvironment());
+  assert.deepEqual(Object.keys(models), ['mistral-medium-3.5', 'glm-5.3', 'glm-5.2']);
+  assert.deepEqual(models['glm-5.3'], { name: 'zai-glm-5-3', provider: 'mistral', alias: 'glm-5.3', display_name: 'Z.ai GLM 5.3' });
+  assert.equal(models['mistral-medium-3.5'].thinking, undefined);
+});
+
+test('the selected effort becomes Vibe thinking only on models with adjustable reasoning', () => {
+  assert.equal(JSON.parse(buildVibeModelsEnvironment('mistral-medium-3.5', 'none'))['mistral-medium-3.5'].thinking, 'low');
+  assert.equal(JSON.parse(buildVibeModelsEnvironment('mistral-medium-3.5', 'high'))['mistral-medium-3.5'].thinking, 'high');
+  assert.equal(JSON.parse(buildVibeModelsEnvironment('glm-5.3', 'high'))['glm-5.3'].thinking, undefined);
+  assert.equal(JSON.parse(buildVibeModelsEnvironment('mistral-medium-3.5', 'bogus'))['mistral-medium-3.5'].thinking, undefined);
+});
+
+test('the curated Mistral catalog lists GLM 5.3 and 5.2 and offers effort on Medium 3.5 only', () => {
+  const byValue = Object.fromEntries(MISTRAL_PREDEFINED_MODELS.OPTIONS.map((option) => [option.value, option]));
+  assert.deepEqual(Object.keys(byValue), ['mistral-medium-3.5', 'glm-5.3', 'glm-5.2', 'local']);
+  assert.deepEqual(byValue['mistral-medium-3.5'].effort?.values.map((value) => value.value), ['none', 'high']);
+  assert.equal(byValue['glm-5.3'].effort, undefined);
+  assert.equal(MISTRAL_PREDEFINED_MODELS.DEFAULT, 'mistral-medium-3.5');
+});

package/server/piecemaker/agent-instructions.ts

@@ -0,0 +1,148 @@
+import { constants, watch, type FSWatcher } from 'fs';
+import { copyFile, lstat, readFile, realpath, rename, stat, writeFile } from 'fs/promises';
+import path from 'path';
+
+import express, { type Request, type Response } from 'express';
+
+import { projectsDb } from '@/modules/database/index.js';
+
+const CLAUDE_FILE = 'CLAUDE.md';
+const AGENTS_FILE = 'AGENTS.md';
+const WATCHED_FILES = new Set([CLAUDE_FILE, AGENTS_FILE]);
+const PROJECT_REFRESH_INTERVAL_MS = 5000;
+const MIRROR_DEBOUNCE_MS = 300;
+
+async function isPresent(filePath: string): Promise<boolean> {
+  try {
+    await lstat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function agentInstructionsTemplate(sharedInstructionsFile: string): string {
+  return [
+    `@${sharedInstructionsFile}`,
+    '',
+    '# Ce dossier',
+    '<!-- Éléments propres à ce dossier : parties, juridiction, échéances, particularités. À compléter. -->',
+    '',
+  ].join('\n');
+}
+
+export async function ensureAgentInstructionFiles(projectRoot: string, sharedInstructionsFile: string): Promise<string[]> {
+  const claudePath = path.join(projectRoot, CLAUDE_FILE);
+  const agentsPath = path.join(projectRoot, AGENTS_FILE);
+  const [hasClaude, hasAgents] = await Promise.all([isPresent(claudePath), isPresent(agentsPath)]);
+  if (hasClaude && hasAgents) return [];
+  if (hasClaude) {
+    await copyFile(claudePath, agentsPath, constants.COPYFILE_EXCL);
+    return [AGENTS_FILE];
+  }
+  if (hasAgents) {
+    await copyFile(agentsPath, claudePath, constants.COPYFILE_EXCL);
+    return [CLAUDE_FILE];
+  }
+  const template = agentInstructionsTemplate(sharedInstructionsFile);
+  await writeFile(claudePath, template, { flag: 'wx' });
+  await writeFile(agentsPath, template, { flag: 'wx' });
+  return [CLAUDE_FILE, AGENTS_FILE];
+}
+
+const lastMirroredContents = new Map<string, Buffer>();
+
+export async function mirrorAgentInstructionFiles(projectRoot: string): Promise<void> {
+  try {
+    const claudePath = path.join(projectRoot, CLAUDE_FILE);
+    const agentsPath = path.join(projectRoot, AGENTS_FILE);
+    await Promise.all([stat(claudePath), stat(agentsPath)]);
+    if ((await realpath(claudePath)) === (await realpath(agentsPath))) return;
+    const [claudeContent, agentsContent] = await Promise.all([readFile(claudePath), readFile(agentsPath)]);
+    if (claudeContent.equals(agentsContent)) {
+      lastMirroredContents.set(projectRoot, claudeContent);
+      return;
+    }
+    const lastMirrored = lastMirroredContents.get(projectRoot);
+    if (!lastMirrored) return;
+    const claudeChanged = agentsContent.equals(lastMirrored);
+    if (!claudeChanged && !claudeContent.equals(lastMirrored)) return;
+    const [content, targetPath] = claudeChanged ? [claudeContent, agentsPath] : [agentsContent, claudePath];
+    const temporaryPath = `${targetPath}.piecemaker-${process.pid}.tmp`;
+    await writeFile(temporaryPath, content);
+    await rename(temporaryPath, targetPath);
+    lastMirroredContents.set(projectRoot, content);
+  } catch {
+    return;
+  }
+}
+
+export function startAgentInstructionsMirror(listProjectRoots: () => string[]): () => void {
+  const watchers = new Map<string, FSWatcher>();
+  const pendingMirrors = new Map<string, NodeJS.Timeout>();
+
+  const scheduleMirror = (projectRoot: string) => {
+    clearTimeout(pendingMirrors.get(projectRoot));
+    pendingMirrors.set(projectRoot, setTimeout(() => {
+      pendingMirrors.delete(projectRoot);
+      void mirrorAgentInstructionFiles(projectRoot);
+    }, MIRROR_DEBOUNCE_MS).unref());
+  };
+
+  const forget = (projectRoot: string) => {
+    watchers.get(projectRoot)?.close();
+    watchers.delete(projectRoot);
+  };
+
+  const refreshWatchers = () => {
+    let projectRoots: Set<string>;
+    try {
+      projectRoots = new Set(listProjectRoots().map((projectRoot) => path.resolve(projectRoot)));
+    } catch {
+      return;
+    }
+    for (const projectRoot of watchers.keys()) {
+      if (!projectRoots.has(projectRoot)) forget(projectRoot);
+    }
+    for (const projectRoot of projectRoots) {
+      if (watchers.has(projectRoot)) continue;
+      try {
+        const watcher = watch(projectRoot, { persistent: false }, (_event, fileName) => {
+          if (!fileName || WATCHED_FILES.has(fileName.toString())) scheduleMirror(projectRoot);
+        });
+        watcher.on('error', () => forget(projectRoot));
+        watchers.set(projectRoot, watcher);
+        scheduleMirror(projectRoot);
+      } catch {
+        continue;
+      }
+    }
+  };
+
+  refreshWatchers();
+  const interval = setInterval(refreshWatchers, PROJECT_REFRESH_INTERVAL_MS).unref();
+  return () => {
+    clearInterval(interval);
+    for (const timer of pendingMirrors.values()) clearTimeout(timer);
+    for (const projectRoot of [...watchers.keys()]) forget(projectRoot);
+  };
+}
+
+export function createAgentInstructionsRouter(sharedInstructionsFile: string) {
+  const router = express.Router();
+
+  router.post('/agent-instructions', async (request: Request, response: Response) => {
+    const projectId = typeof request.body?.projectId === 'string' ? request.body.projectId : '';
+    const projectRoot = projectId ? projectsDb.getProjectPathById(projectId) : null;
+    if (!projectRoot) return response.status(404).json({ error: 'Projet introuvable.' });
+    try {
+      const created = await ensureAgentInstructionFiles(projectRoot, sharedInstructionsFile);
+      await mirrorAgentInstructionFiles(projectRoot);
+      response.json({ ok: true, created });
+    } catch (error) {
+      response.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+
+  return router;
+}

package/server/piecemaker/anonymizer/client-config.cjs

@@ -1,119 +1,119 @@
 const fs = require('node:fs');
-const os = require('node:os');
 const path = require('node:path');
 
-function atomicWrite(file, content, mode = 0o600) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
+const LEGACY_PROXY_KEYS = [
+  'HTTPS_PROXY', 'HTTP_PROXY', 'ALL_PROXY', 'NO_PROXY', 'NODE_USE_ENV_PROXY',
+  'NODE_EXTRA_CA_CERTS', 'SSL_CERT_FILE', 'CODEX_CA_CERTIFICATE', 'REQUESTS_CA_BUNDLE',
+];
+
+function readObject(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeObject(file, value) {
   const temporary = `${file}.piecemaker-${process.pid}-${Date.now()}`;
-  fs.writeFileSync(temporary, content, { encoding: 'utf8', mode });
+  fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
   fs.renameSync(temporary, file);
 }
 
-const PROXY_ENV = {
-  HTTPS_PROXY: (proxyUrl) => proxyUrl,
-  HTTP_PROXY: (proxyUrl) => proxyUrl,
-  ALL_PROXY: (proxyUrl) => proxyUrl,
-  NO_PROXY: () => 'localhost,127.0.0.1,::1',
-  NODE_USE_ENV_PROXY: () => '1',
-  NODE_EXTRA_CA_CERTS: (_proxyUrl, caFile) => caFile,
-  SSL_CERT_FILE: (_proxyUrl, caFile, trustBundle) => trustBundle || caFile,
-  CODEX_CA_CERTIFICATE: (_proxyUrl, caFile) => caFile,
-  REQUESTS_CA_BUNDLE: (_proxyUrl, caFile, trustBundle) => trustBundle || caFile,
-};
-
-function isLoopbackProxy(value) {
+function isLoopback(value) {
   try {
-    const url = new URL(String(value || ''));
-    return ['127.0.0.1', 'localhost'].includes(url.hostname);
+    return ['127.0.0.1', 'localhost'].includes(new URL(String(value || '')).hostname);
   } catch {
     return false;
   }
 }
 
-function configureClaudeCodeProxy({ proxyUrl, caFile, trustBundle, userHome = os.homedir() } = {}) {
-  const settingsFile = path.join(userHome, '.claude', 'settings.json');
-  let settings = {};
-  try {
-    if (fs.existsSync(settingsFile)) {
-      const parsed = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
-      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('objet JSON attendu');
-      settings = parsed;
-    }
-  } catch {
-    return { configured: false, changed: false, conflict: true, file: settingsFile, reason: 'settings-invalid' };
-  }
+function isProxyGuard(hook) {
+  return [hook?.command, hook?.commandWindows].some((command) => typeof command === 'string' && command.includes('proxy-guard.mjs'));
+}
 
-  if (settings.env !== undefined
-    && (!settings.env || typeof settings.env !== 'object' || Array.isArray(settings.env))) {
-    return { configured: false, changed: false, conflict: true, file: settingsFile, reason: 'env-invalid' };
-  }
-  if (!settings.env) settings.env = {};
-  const existingProxy = settings.env.HTTPS_PROXY;
-  if (existingProxy && existingProxy !== proxyUrl && !isLoopbackProxy(existingProxy)) {
-    return { configured: false, changed: false, conflict: true, file: settingsFile, reason: 'proxy-conflict' };
-  }
+function withoutProxyGuard(groups) {
+  if (!Array.isArray(groups)) return groups;
+  return groups
+    .map((group) => (Array.isArray(group?.hooks) ? { ...group, hooks: group.hooks.filter((hook) => !isProxyGuard(hook)) } : group))
+    .filter((group) => !Array.isArray(group?.hooks) || group.hooks.length);
+}
 
+function cleanClaudeSettings(file) {
+  const settings = readObject(file);
+  if (!settings) return false;
   let changed = false;
-  for (const [key, produce] of Object.entries(PROXY_ENV)) {
-    const value = produce(proxyUrl, caFile, trustBundle);
-    if (!value) continue;
-    if (settings.env[key] !== value) {
-      settings.env[key] = value;
-      changed = true;
-    }
+  if (settings.env && isLoopback(settings.env.HTTPS_PROXY)) {
+    for (const key of LEGACY_PROXY_KEYS) delete settings.env[key];
+    if (!Object.keys(settings.env).length) delete settings.env;
+    changed = true;
   }
-  if (!changed) return { configured: true, changed: false, conflict: false, file: settingsFile };
-  atomicWrite(settingsFile, `${JSON.stringify(settings, null, 2)}\n`);
-  return { configured: true, changed: true, conflict: false, file: settingsFile };
-}
-
-function bypassClaudeCodeProxy({ userHome = os.homedir() } = {}) {
-  const settingsFile = path.join(userHome, '.claude', 'settings.json');
-  if (!fs.existsSync(settingsFile)) {
-    return { bypassed: true, changed: false, conflict: false, file: settingsFile };
+  const current = settings.hooks?.SessionStart;
+  const sessionStart = withoutProxyGuard(current);
+  if (Array.isArray(current) && JSON.stringify(sessionStart) !== JSON.stringify(current)) {
+    if (sessionStart.length) settings.hooks.SessionStart = sessionStart;
+    else delete settings.hooks.SessionStart;
+    changed = true;
   }
+  if (changed) writeObject(file, settings);
+  return changed;
+}
 
-  let settings;
-  try {
-    settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
-    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) throw new Error('objet JSON attendu');
-  } catch {
-    return { bypassed: false, changed: false, conflict: true, file: settingsFile, reason: 'settings-invalid' };
-  }
+function cleanCodexHooks(file) {
+  const document = readObject(file);
+  const current = document?.hooks?.SessionStart;
+  const sessionStart = withoutProxyGuard(current);
+  if (!Array.isArray(current) || JSON.stringify(sessionStart) === JSON.stringify(current)) return false;
+  if (sessionStart.length) document.hooks.SessionStart = sessionStart;
+  else delete document.hooks.SessionStart;
+  writeObject(file, document);
+  return true;
+}
 
-  const env = settings.env;
-  if (!env || typeof env !== 'object' || Array.isArray(env)) {
-    if (env === undefined) return { bypassed: true, changed: false, conflict: false, file: settingsFile };
-    return { bypassed: false, changed: false, conflict: true, file: settingsFile, reason: 'env-invalid' };
-  }
-  if (!isLoopbackProxy(env.HTTPS_PROXY)) return { bypassed: true, changed: false, conflict: false, file: settingsFile };
+const LEGACY_CONFIG_KEYS = [
+  'mikePiiPort',
+  'caseFolders',
+  'anonymization',
+  'litellmPort',
+  'litellmVenvPath',
+  'mxcPath',
+  'mxcEnabled',
+  'adminTheme',
+  'port',
+];
 
+function cleanPieceMakerConfig(homeDir) {
+  const file = path.join(homeDir, 'config.json');
+  const config = readObject(file);
   let changed = false;
-  if (isLoopbackProxy(env.HTTPS_PROXY)) {
-    for (const key of Object.keys(PROXY_ENV)) {
-      if (env[key] !== undefined) {
-        delete env[key];
-        changed = true;
-      }
-    }
+  const legacyKeys = config ? LEGACY_CONFIG_KEYS.filter((key) => key in config) : [];
+  if (legacyKeys.length) {
+    for (const key of legacyKeys) delete config[key];
+    writeObject(file, config);
+    changed = true;
   }
-  if (!changed) return { bypassed: true, changed: false, conflict: false, file: settingsFile };
-  if (Object.keys(env).length === 0) delete settings.env;
-  atomicWrite(settingsFile, `${JSON.stringify(settings, null, 2)}\n`);
-  return { bypassed: true, changed: true, conflict: false, file: settingsFile };
-}
-
-function configureCodexProxy() {
-  return { configured: true, changed: false, conflict: false, file: null };
+  const statuslineCache = path.join(homeDir, 'proxy-statusline.json');
+  if (fs.existsSync(statuslineCache)) {
+    fs.rmSync(statuslineCache, { force: true });
+    changed = true;
+  }
+  return changed;
 }
 
-function bypassCodexProxy() {
-  return { bypassed: true, changed: false, conflict: false, file: null };
+function removeLegacyProxyConfig({ userHome, homeDir = path.join(userHome, '.piecemaker') }) {
+  const cleaned = [];
+  const attempt = (name, run) => {
+    try {
+      if (run()) cleaned.push(name);
+    } catch {
+      return;
+    }
+  };
+  attempt('claude', () => cleanClaudeSettings(path.join(userHome, '.claude', 'settings.json')));
+  attempt('codex', () => cleanCodexHooks(path.join(process.env.CODEX_HOME || path.join(userHome, '.codex'), 'hooks.json')));
+  attempt('piecemaker', () => cleanPieceMakerConfig(homeDir));
+  return cleaned;
 }
 
-module.exports = {
-  configureClaudeCodeProxy,
-  bypassClaudeCodeProxy,
-  configureCodexProxy,
-  bypassCodexProxy,
-};
+module.exports = { removeLegacyProxyConfig };

package/server/piecemaker/anonymizer/dictionary.cjs

@@ -30,6 +30,19 @@ const EMPTY = Object.freeze({
   empty: true,
 });
 
+const MEMO_MIN_LENGTH = 256;
+const MEMO_BUDGET = 16 * 1024 * 1024;
+const memos = new WeakMap();
+
+function memoFor(dictionary) {
+  let memo = memos.get(dictionary);
+  if (!memo) {
+    memo = { entries: new Map(), size: 0 };
+    memos.set(dictionary, memo);
+  }
+  return memo;
+}
+
 function plainObject(value) {
   return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
@@ -49,8 +62,9 @@ function plainObject(value) {
  * ne part pas codé serait un mensonge à l'écran.
  */
 function buildDictionary(document, stamp) {
-  const mapping = plainObject(document?.mapping);
-  const reverse = plainObject(document?.reverse_mapping);
+  const mapping = Object.freeze({ ...plainObject(document?.mapping) });
+  const reverse = Object.freeze(Object.fromEntries(Object.entries(plainObject(document?.reverse_mapping))
+    .map(([code, variants]) => [code, Array.isArray(variants) ? Object.freeze([...variants]) : variants])));
   const canonical = {};
   for (const [code, variants] of Object.entries(reverse)) {
     const name = Array.isArray(variants) ? variants[0] : variants;
@@ -89,7 +103,24 @@ function buildDictionary(document, stamp) {
 
 /** Nom réel → code, sur tout ce qui part vers l'API. */
 function anonymize(text, dictionary) {
-  return dictionary.empty ? text : applyMapping(text, dictionary.mapping);
+  if (dictionary.empty) return text;
+  if (typeof text !== 'string' || text.length < MEMO_MIN_LENGTH) return applyMapping(text, dictionary.mapping);
+  const memo = memoFor(dictionary);
+  const cached = memo.entries.get(text);
+  if (cached !== undefined) {
+    memo.entries.delete(text);
+    memo.entries.set(text, cached);
+    return cached;
+  }
+  const result = applyMapping(text, dictionary.mapping);
+  memo.entries.set(text, result);
+  memo.size += text.length + (result === text ? 0 : result.length);
+  for (const [key, value] of memo.entries) {
+    if (memo.size <= MEMO_BUDGET) break;
+    memo.entries.delete(key);
+    memo.size -= key.length + (value === key ? 0 : value.length);
+  }
+  return result;
 }
 
 /** Code → nom réel, sur tout ce qui revient de l'API vers la machine. */