@piecemaker-legal/piecemaker 2.0.10 → 2.0.12

package/server/piecemaker/anonymizer/sqlite-dictionary.cjs

@@ -1,31 +1,10 @@
+const fs = require('node:fs');
 const path = require('node:path');
 
 const Database = require('better-sqlite3');
 
 const { buildDictionary, EMPTY_DICTIONARY } = require('./dictionary.cjs');
 
-function codePrefix(code) {
-  const match = /^(.*?)_(\d+)$/.exec(code);
-  return match ? match[1] : code || 'ENTITE';
-}
-
-function codeNumber(code) {
-  const match = /_(\d+)$/.exec(code);
-  return match ? Number(match[1]) : 0;
-}
-
-function allocateCode(localCode, counters, used) {
-  const prefix = codePrefix(localCode);
-  let index = counters.get(prefix) || 0;
-  let candidate;
-  do {
-    index += 1;
-    candidate = `${prefix}_${String(index).padStart(2, '0')}`;
-  } while (used.has(candidate));
-  counters.set(prefix, index);
-  return candidate;
-}
-
 function buildMappingDocument(rows) {
   const grouped = new Map();
   let updatedAt = null;
@@ -37,20 +16,14 @@ function buildMappingDocument(rows) {
     if (!updatedAt || row.updated_at > updatedAt) updatedAt = row.updated_at;
   }
 
-  const used = new Set();
-  const counters = new Map();
   const mapping = {};
   const reverse_mapping = {};
   for (const group of grouped.values()) {
-    const desired = group.localCode;
-    const globalCode = used.has(desired) ? allocateCode(desired, counters, used) : desired;
-    used.add(globalCode);
-    const prefix = codePrefix(globalCode);
-    counters.set(prefix, Math.max(counters.get(prefix) || 0, codeNumber(globalCode)));
+    const code = group.localCode;
     const canonical = group.variants.includes(group.label) ? group.label : group.variants[0];
     const variants = [canonical, ...group.variants.filter((value) => value !== canonical)];
-    reverse_mapping[globalCode] = variants;
-    for (const variant of variants) if (!mapping[variant]) mapping[variant] = globalCode;
+    reverse_mapping[code] = variants;
+    for (const variant of variants) if (!mapping[variant]) mapping[variant] = code;
   }
   return { mapping, reverse_mapping, updated_at: updatedAt };
 }
@@ -62,6 +35,7 @@ function createSqliteDictionaryLoader({ databasePath }) {
   let mappingSignature = null;
   let generation = 0;
   let current = EMPTY_DICTIONARY;
+  let failure = null;
 
   function connection() {
     if (!database) {
@@ -97,15 +71,24 @@ function createSqliteDictionaryLoader({ databasePath }) {
       generation += 1;
       current = buildDictionary(buildMappingDocument(rows), generation);
       dataVersion = nextDataVersion;
+      failure = null;
       return current;
-    } catch {
+    } catch (error) {
+      failure = fs.existsSync(file) ? error : null;
       return current;
     }
   }
 
+  function loadForOutbound() {
+    const dictionary = load(false);
+    if (failure) throw new Error(`dictionnaire illisible : ${failure.message}`);
+    return dictionary;
+  }
+
   return {
     file,
     get: () => load(false),
+    getForOutbound: loadForOutbound,
     refresh: () => load(true),
     exists: () => !load(false).empty,
     close: () => {

package/server/piecemaker/index.ts

@@ -3,11 +3,13 @@ import path from 'path';
 
 import type { Router } from 'express';
 
+import { projectsDb } from '@/modules/database/index.js';
 import { providerRuntimeService, sessionsService } from '@/modules/providers/index.js';
 import { providerRegistry } from '@/modules/providers/provider.registry.js';
 import { findApplicationRoot, getModuleDirectory } from '@/shared/utils.js';
 
 
+import { createAgentInstructionsRouter, startAgentInstructionsMirror } from './agent-instructions.js';
 import { startRequiredAnonymizer } from './anonymizer/lifecycle.js';
 import { createCitationStore } from './harness/citation-store.js';
 import { installChatCitationHarness } from './harness/chat-harness.js';
@@ -43,7 +45,7 @@ type PieceMakerRuntimeStatus = {
 type PieceMakerVendorModule = {
   createPieceMakerRouter(options?: { getRuntimeStatus?: () => PieceMakerRuntimeStatus; anonymizer?: unknown; publishProjects?: () => void }): Router;
   piecemakerHome(): string;
-  publishProjectSource(sourceId: string, folders: string[] | null): void;
+  publishProjectSource(sourceId: string, folders: string[] | null, anonymizedFolders?: string[]): void;
   stopOriginalsJobs(): Promise<void>;
 };
 
@@ -62,6 +64,7 @@ installLibraryRuntime(providerRuntimeService, sessionsService, library.store);
 installModelDiscovery(providerRegistry);
 const timesheet = createTimesheetBackend(piecemakerHome());
 const knowledge = createKnowledgeBackend(applicationRoot);
+startAgentInstructionsMirror(() => projectsDb.getProjectPaths().map((row) => row.project_path));
 
 export function createPieceMakerLocalRouter() {
   return knowledge.localRouter;
@@ -78,6 +81,7 @@ export function createPieceMakerRouter(options: { getRuntimeStatus?: () => Piece
   router.use(createCompanySearchRouter());
   router.use(createBodaccSearchRouter());
   router.use(createDocxDocumentRouter());
+  router.use(createAgentInstructionsRouter(path.join(piecemakerHome(), 'CLAUDE.md')));
   router.use(createShellEnvironmentRouter(shellEnvironment));
   return router;
 }

package/server/piecemaker/knowledge/pipeline.ts

@@ -5,6 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { findApplicationRoot, getModuleDirectory } from '../../shared/utils.js';
+import { resolveKnowledgeDatabasePath } from '../../../plugins/piecemaker-dossier/src/knowledge.js';
 import type { KnowledgeStore } from '../../../plugins/piecemaker-dossier/src/knowledge.js';
 import { persistScanResult, scanResultOperations } from '../../../plugins/piecemaker-dossier/src/scan-result.js';
 import type { GlinerDocument, GlinerMappingDocument, JsonData } from '../../../plugins/piecemaker-dossier/src/types.js';
@@ -25,7 +26,6 @@ type PipelineOptions = {
 type OriginalFile = { path: string; resource?: boolean };
 
 type OriginalsPipeline = {
-  caseMappingFile(caseRoot: string): string;
   listOriginals(caseRoot: string): Promise<OriginalFile[]>;
   runManagedPythonJob(options: {
     action: 'convert' | 'anonymize';
@@ -33,16 +33,15 @@ type OriginalsPipeline = {
     args: string[];
     onProgress?: (progress: KnowledgeScanProgress) => void;
     signal?: AbortSignal;
+    input?: string;
+    onMapping?: (mapping: unknown) => void;
   }): Promise<unknown>;
-  writeCaseMapping(caseRoot: string, document: GlinerMappingDocument): unknown;
 };
 
 const require = createRequire(import.meta.url);
 const {
-  caseMappingFile,
   listOriginals,
   runManagedPythonJob,
-  writeCaseMapping,
 } = require(path.join(
   findApplicationRoot(getModuleDirectory(import.meta.url)),
   'server',
@@ -117,18 +116,7 @@ function pythonExecutable(explicit: string | undefined): string {
   return fs.existsSync(candidate) ? candidate : 'python3';
 }
 
-export function legacyExclusions(projectPath: string): string[] {
-  const candidate = path.join(projectPath, 'Fichiers convertis PieceMaker', 'mapping_default.json');
-  if (!fs.existsSync(candidate)) return [];
-  try {
-    const document = parseObject(candidate);
-    return Array.isArray(document.ignored) ? document.ignored.map(textValue).filter(Boolean) : [];
-  } catch {
-    return [];
-  }
-}
-
-function mappingSeed(projectId: string, projectPath: string, store: KnowledgeStore): GlinerMappingDocument {
+function mappingSeed(projectId: string, store: KnowledgeStore): GlinerMappingDocument {
   const snapshot = store.snapshot(projectId);
   const mapping: Record<string, string> = {};
   const reverseMapping: Record<string, string[]> = {};
@@ -145,7 +133,7 @@ function mappingSeed(projectId: string, projectPath: string, store: KnowledgeSto
     extractedData[category] ||= {};
     extractedData[category][code] = node.data;
   }
-  const ignored = snapshot.exclusionsInitialized ? snapshot.exclusions || [] : legacyExclusions(projectPath);
+  const ignored = snapshot.exclusions || [];
   return { mapping, reverse_mapping: reverseMapping, extracted_data: extractedData, ignored };
 }
 
@@ -174,34 +162,39 @@ export function createKnowledgePipeline(options: PipelineOptions) {
       const explicitFiles = Array.isArray(requestedFiles) && requestedFiles.length > 0;
       const files = await safeFiles(projectPath, requestedFiles);
       if (!files.length) throw new Error('No supported file to scan.');
-      const mappingFile = caseMappingFile(projectPath);
       const stateFile = path.join(projectPath, '.piecemaker', 'anonymization-state.json');
       const outputDirectory = path.join(projectPath, 'Fichiers convertis PieceMaker');
-      fs.mkdirSync(path.dirname(mappingFile), { recursive: true });
       fs.mkdirSync(path.dirname(stateFile), { recursive: true });
       fs.mkdirSync(outputDirectory, { recursive: true });
-      fs.writeFileSync(mappingFile, JSON.stringify(mappingSeed(projectId, projectPath, options.store)), { mode: 0o600 });
+      const seed = mappingSeed(projectId, options.store);
       const args = [
         ...files,
         '-o',
         outputDirectory,
-        '--mapping-file',
-        mappingFile,
+        '--database',
+        resolveKnowledgeDatabasePath(),
         '--case-root',
         projectPath,
         '--state-file',
         stateFile,
       ];
       if (!explicitFiles) args.push('--skip-existing');
-      await withPythonPath(pythonExecutable(options.pythonPath), () => runManagedPythonJob({
-        action: 'anonymize',
-        script,
-        args,
-        onProgress,
-        signal,
-      }));
-      const mapping = parseObject(mappingFile) as GlinerMappingDocument;
-      writeCaseMapping(projectPath, mapping);
+      let received: GlinerMappingDocument | null = null;
+      try {
+        await withPythonPath(pythonExecutable(options.pythonPath), () => runManagedPythonJob({
+          action: 'anonymize',
+          script,
+          args,
+          onProgress,
+          signal,
+          input: JSON.stringify(seed),
+          onMapping: (value) => { received = value as GlinerMappingDocument; },
+        }));
+      } catch (error) {
+        if (received) options.store.update({ projectId, operations: scanResultOperations({ projectId, mapping: received, documents: [] }) });
+        throw error;
+      }
+      const mapping: GlinerMappingDocument = received || seed;
       const documents = documentsFromIndex(projectPath, files, readDocumentIndex(projectPath));
       const scanResult = { projectId, mapping, documents };
       const result = explicitFiles

package/server/piecemaker/knowledge/service.ts

@@ -1,8 +1,6 @@
 import type { KnowledgeStore } from '../../../plugins/piecemaker-dossier/src/knowledge.js';
-import { exclusionNodeOperation } from '../../../plugins/piecemaker-dossier/src/scan-result.js';
 import type { KnowledgeQueryInput, KnowledgeUpdateInput } from '../../../plugins/piecemaker-dossier/src/types.js';
 
-import { legacyExclusions } from './pipeline.js';
 import type { createKnowledgePipeline } from './pipeline.js';
 import { createKnowledgeScanJobs } from './scan-jobs.js';
 
@@ -22,16 +20,6 @@ export function createKnowledgeService(store: KnowledgeStore, projects: ProjectL
     if (!projects.getProjectById(id)) throw new Error('Project not found.');
     return id;
   };
-  const snapshot = (id: string) => {
-    const current = store.snapshot(id);
-    if (current.exclusionsInitialized) return current;
-    const project = projects.getProjectById(id);
-    const values = project ? legacyExclusions(project.project_path) : [];
-    if (!values.length) return current;
-    const operation = exclusionNodeOperation(values);
-    store.update({ projectId: id, operations: [operation] });
-    return store.snapshot(id);
-  };
   return {
     query(input: KnowledgeQueryInput) {
       return store.query({ ...input, projectId: ensureProject(input.projectId), projectPath: undefined });
@@ -40,8 +28,7 @@ export function createKnowledgeService(store: KnowledgeStore, projects: ProjectL
       return store.update({ ...input, projectId: ensureProject(input.projectId) });
     },
     graph(value: unknown) {
-      const id = ensureProject(value);
-      return snapshot(id);
+      return store.snapshot(ensureProject(value));
     },
     scan(value: unknown, files?: unknown) {
       const id = ensureProject(value);

package/server/piecemaker/project-registry.ts

@@ -4,19 +4,19 @@ import { projectsDb } from '@/modules/database/index.js';
 
 const PUBLISH_INTERVAL_MS = 5000;
 
-type PublishProjectSource = (sourceId: string, folders: string[] | null) => void;
+type PublishProjectSource = (sourceId: string, folders: string[] | null, anonymizedFolders?: string[]) => 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');
+    const rows = [...projectsDb.getProjectPaths(), ...projectsDb.getArchivedProjectPaths()];
+    const folders = rows.map((row) => row.project_path).sort();
+    const anonymizedFolders = rows.filter((row) => row.anonymization_complete).map((row) => row.project_path).sort();
+    const signature = `${folders.join('\n')}\n--\n${anonymizedFolders.join('\n')}`;
     if (signature === publishedSignature) return;
-    publishProjectSource(sourceId, folders);
+    publishProjectSource(sourceId, folders, anonymizedFolders);
     publishedSignature = signature;
   };
 

package/server/piecemaker/router.cjs

@@ -67,7 +67,6 @@ function createPieceMakerRouter({ getRuntimeStatus = defaultRuntimeStatus, anony
       publishProjects();
       const result = await registerLegalCase({
         folder: request.body?.folder,
-        configFile: path.join(homeDir, 'config.json'),
         homeDir,
       });
       response.status(201).json({ ok: true, ...result });

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

@@ -8,11 +8,6 @@
  *
  * Usage:
  *   piecemaker                 menu interactif
- *   piecemaker chronology      affiche la chronologie du dossier courant
- *   piecemaker chronology write --path <pièce> --correction-json <json>
- *                              crée une correction de chronologie pour une pièce
- *   piecemaker chronology edit --path <pièce> --correction-json <json>
- *                              modifie une correction de chronologie existante
  *   piecemaker conversion      convertit et pseudonymise les pièces manquantes
  *   piecemaker install         ouvre le menu des composants
  *   piecemaker doctor          diagnostic seul
@@ -33,16 +28,15 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { banner, title, log, write, blank, summary, spinner, badge, c } from '../lib/ui.mjs';
 import { select, confirm, multiSelect, pause, nonInteractive } from '../lib/prompt.mjs';
 import { GIT_REPO_ROOT, HOME_DIR, REPO_ROOT, commandExists, findPython } from '../lib/platform.mjs';
-import { COMMANDS, CHRONOLOGY_ACTIONS } from '../lib/commandes.mjs';
+import { COMMANDS } 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 { adoptRunningServerPort, appServerPort, localServerReachable, readLocalScanJob, startLocalScan } from '../lib/conversion-client.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 DOCUMENT_INDEX_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/document-index.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');
 
@@ -129,11 +123,8 @@ function parseArgs(argv) {
     check: false,
     dryRun: false,
     conversionDocuments: [],
-    correctionJson: null,
     force: false,
-    chronologyAction: 'read',
     json: false,
-    piecePath: null,
     resumeSteps: null,
     step: null,
     yes: false,
@@ -142,18 +133,13 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (!arg.startsWith('-') && !flags.command && COMMANDS.has(arg)) flags.command = arg;
-    else if (!arg.startsWith('-') && flags.command === 'chronology' && flags.chronologyAction === 'read' && CHRONOLOGY_ACTIONS.has(arg)) flags.chronologyAction = arg;
-    else if (!arg.startsWith('-') && flags.command === 'chronology' && !flags.caseTarget) flags.caseTarget = arg;
     else if (!arg.startsWith('-') && flags.command === 'conversion') flags.conversionDocuments.push(arg);
     else if (arg === '--all') flags.all = true;
-    else if (arg === '--action') flags.chronologyAction = argv[++i];
     else if (arg === '--case') flags.caseTarget = argv[++i];
     else if (arg === '--check') flags.check = true;
-    else if (arg === '--correction-json') flags.correctionJson = argv[++i];
     else if (arg === '--dry-run') flags.dryRun = true;
     else if (arg === '--force') flags.force = true;
     else if (arg === '--json') flags.json = true;
-    else if (arg === '--path') flags.piecePath = argv[++i];
     else if (arg === '--yes' || arg === '-y') flags.yes = true;
     else if (arg === '--step') flags.step = argv[++i];
     else if (arg === '--resume-steps') {
@@ -313,20 +299,15 @@ async function runCheck(steps, ctx) {
 function printHelp() {
   write(`  ${c.bold('piecemaker')} — PieceMaker local`);
   blank();
-  write('  chronology [read]        affiche la chronologie pseudonymisée du dossier courant');
-  write('  chronology write --path <pièce> --correction-json <json>  crée une correction de chronologie');
-  write('  chronology edit --path <pièce> --correction-json <json>   modifie une correction existante');
   write('  conversion [pièce…] convertit et pseudonymise les pièces manquantes ou indiquées');
   write('  install         ouvre le menu d’installation/réparation');
   write('  doctor, check   diagnostic seul, n’installe rien');
   write('  update          met à jour PieceMaker');
   blank();
   write('  --all           installe tout sans menu');
-  write('  --case <chemin> cible un dossier enregistré (chronology/conversion)');
-  write('  --path <pièce>  chemin relatif de la pièce (chronology write/edit)');
-  write('  --correction-json <json> correction à appliquer (chronology write/edit)');
+  write('  --case <chemin> cible un dossier enregistré (conversion)');
   write('  --force         retraite les pièces');
-  write('  --json          produit une sortie JSON sans décor (chronology/conversion)');
+  write('  --json          produit une sortie JSON sans décor (conversion)');
   write('  --check         diagnostic seul, n\'installe rien');
   write('  --step <id>     rejoue une seule étape');
   write('  --resume-steps <ids> rejoue les étapes indiquées sans interaction (usage interne)');
@@ -375,135 +356,6 @@ async function installerMenu(steps, ctx, { allowBack = false } = {}) {
   }
 }
 
-function formatChronologyText(chronology) {
-  const lines = [];
-  lines.push(`Chronologie : ${chronology.stats.documents} pièce(s), ${chronology.stats.dated} datée(s), ${chronology.stats.entities} entité(s).`);
-  lines.push('');
-  for (const doc of chronology.documents) {
-    lines.push(`${doc.dateIso || '(date manquante)'}  ${doc.nature || '(nature inconnue)'}  ${doc.name}`);
-  }
-  const missing = chronology.documents.filter((doc) => !doc.dateIso);
-  if (missing.length) {
-    lines.push('');
-    lines.push('Dates manquantes :');
-    for (const doc of missing) lines.push(`  - ${doc.name}`);
-  }
-  return `${lines.join('\n')}\n`;
-}
-
-function locateChronologyCase(flags) {
-  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>.');
-  }
-  return located;
-}
-
-async function runChronologyReadCommand(flags) {
-  if (!fs.existsSync(DOCUMENT_INDEX_MODULE)) {
-    throw new Error('Le module de chronologie PieceMaker est introuvable.');
-  }
-  const located = locateChronologyCase(flags);
-  const { buildChronology } = require(DOCUMENT_INDEX_MODULE);
-  const chronology = await buildChronology(located.caseRoot, { deanonymizeLabels: false, includeManualDecisions: true });
-  const output = flags.json
-    ? `${JSON.stringify(chronology, null, 2)}\n`
-    : formatChronologyText(chronology);
-  process.stdout.write(output);
-  return 0;
-}
-
-function resolveChronologyPiecePath(caseRoot, relativePath) {
-  const relative = String(relativePath || '').replaceAll('\\', '/').replace(/^\.\//, '');
-  if (!relative) throw new Error('Chemin de pièce manquant.');
-  const absolute = path.resolve(caseRoot, ...relative.split('/'));
-  if (absolute !== caseRoot && !absolute.startsWith(`${caseRoot}${path.sep}`)) {
-    throw new Error('Pièce hors du dossier juridique.');
-  }
-  if (!fs.existsSync(absolute)) throw new Error('Pièce introuvable.');
-  return relative;
-}
-
-async function runChronologyCorrectionCommand(flags) {
-  if (!fs.existsSync(DOCUMENT_INDEX_MODULE)) {
-    throw new Error('Le module de chronologie PieceMaker est introuvable.');
-  }
-  const located = locateChronologyCase(flags);
-  const relative = resolveChronologyPiecePath(located.caseRoot, flags.piecePath);
-
-  let correction;
-  try {
-    correction = JSON.parse(flags.correctionJson || '{}');
-  } catch (error) {
-    throw new Error(`Correction JSON invalide : ${error.message}`);
-  }
-
-  const { stateKey } = require('../../piecemaker-plugin/scripts/lib/anonymization-state.cjs');
-  const { applyDocumentIndexCorrection, readDocumentIndex, documentIndexFile } = require(DOCUMENT_INDEX_MODULE);
-  const key = stateKey(relative);
-  const existing = readDocumentIndex(located.caseRoot).overrides[key] || null;
-
-  if (flags.chronologyAction === 'write' && existing) {
-    throw new Error('Une correction existe déjà pour cette pièce ; utilisez edit_chronology pour la modifier.');
-  }
-  if (flags.chronologyAction === 'edit' && !existing) {
-    throw new Error('Aucune correction existante pour cette pièce ; utilisez write_chronology pour en créer une.');
-  }
-
-  const mutation = applyDocumentIndexCorrection(located.caseRoot, relative, correction);
-
-  let history;
-  try {
-    const { createCommit } = require('../../piecemaker-plugin/scripts/lib/commits.cjs');
-    history = await createCommit({
-      casesRoot: located.casesRoot,
-      caseName: located.caseName,
-      homeDir: HOME_DIR,
-      envFile: path.join(REPO_ROOT, '.env'),
-      label: flags.chronologyAction === 'write'
-        ? 'Création d’une correction de chronologie'
-        : 'Modification d’une correction de chronologie',
-      description: `Mise à jour déterministe de la pièce ${mutation.documentKey.slice(0, 12).toUpperCase()}.`,
-      event: 'assistant-chronology-correction',
-      paths: [path.relative(located.caseRoot, documentIndexFile(located.caseRoot)).split(path.sep).join('/')],
-      waitForLockMs: 10_000,
-    });
-  } catch (error) {
-    history = { created: false, error: error.message };
-  }
-
-  const result = {
-    ok: true,
-    action: flags.chronologyAction,
-    path: relative,
-    documentKey: mutation.documentKey,
-    override: mutation.override,
-    entityDecisions: mutation.entityDecisions,
-    editRevision: mutation.editRevision,
-    history: {
-      created: Boolean(history?.created),
-      hash: history?.commit || null,
-      error: history?.error || null,
-    },
-  };
-
-  if (flags.json) {
-    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-  } else {
-    const verb = flags.chronologyAction === 'write' ? 'Correction créée' : 'Correction modifiée';
-    log.ok(`${verb} pour ${relative}.`);
-  }
-  return 0;
-}
-
-async function runChronologyCommand(flags) {
-  if (flags.chronologyAction === 'write' || flags.chronologyAction === 'edit') {
-    return runChronologyCorrectionCommand(flags);
-  }
-  return runChronologyReadCommand(flags);
-}
-
 function normalizedConversionRequest(value, caseRoot) {
   const raw = String(value || '').trim();
   if (!raw) throw new Error('Nom de pièce vide.');
@@ -570,6 +422,8 @@ async function waitForConversionJob({ folder, id }, { json = false } = {}) {
 }
 
 async function ensureServerForConversion({ json = false } = {}) {
+  await adoptRunningServerPort();
+  if (await localServerReachable()) return;
   const servicesModule = path.join(APP_CLI_LIB, 'services.mjs');
   if (!fs.existsSync(servicesModule)) {
     throw new Error(`Le serveur applicatif doit être démarré par la commande « piecemaker » avant la conversion (port ${appServerPort()}).`);
@@ -625,7 +479,6 @@ async function runConversionCommand(flags) {
 }
 
 async function runOperationalCommand(command, knownUpdate = null, flags = {}) {
-  if (command === 'chronology') return runChronologyCommand(flags);
   if (command === 'conversion') return runConversionCommand(flags);
   if (command === 'update') {
     const pending = knownUpdate ?? checkForUpdate();
@@ -749,20 +602,14 @@ async function main() {
     return 1;
   }
 
-  if (!['chronology', 'conversion'].includes(flags.command) && (flags.caseTarget || flags.json)) {
+  if (flags.command !== 'conversion' && (flags.caseTarget || flags.json)) {
     banner();
-    log.error('Les options --case et --json sont réservées aux commandes chronology et conversion.');
-    return 1;
-  }
-
-  if (flags.command === 'chronology' && !CHRONOLOGY_ACTIONS.has(flags.chronologyAction)) {
-    log.error('Action inconnue : utilisez « piecemaker chronology read|write|edit ».');
+    log.error('Les options --case et --json sont réservées à la commande conversion.');
     return 1;
   }
 
   // Les sorties JSON sont directement consommées par les assistants.
-  if ((flags.command === 'chronology' && flags.json)
-      || (flags.command === 'conversion' && flags.json)) {
+  if (flags.command === 'conversion' && flags.json) {
     return runOperationalCommand(flags.command, null, flags);
   }
 

package/server/piecemaker/vendor/installer/lib/commandes.mjs

@@ -7,5 +7,4 @@
  * est importable sans effet de bord.
  */
 
-export const COMMANDS = new Set(['chronology', 'conversion', 'install', 'doctor', 'check', 'update']);
-export const CHRONOLOGY_ACTIONS = new Set(['read', 'write', 'edit']);
+export const COMMANDS = new Set(['conversion', 'install', 'doctor', 'check', 'update']);

package/server/piecemaker/vendor/installer/lib/conversion-client.mjs

@@ -4,20 +4,79 @@
  * La conversion et l'analyse PII n'ont qu'un seul point d'entrée : la route
  * `knowledge/scan` du serveur applicatif. Le CLI en est un client, sur la
  * boucle locale, via le montage `/api/piecemaker/local` placé avant
- * l'authentification. Le serveur applicatif écoute en clair sur le port du
- * CLI (`PIECEMAKER_APP_PORT`, 3003 par défaut) : aucun certificat n'entre en
- * jeu et la requête ne sort jamais de 127.0.0.1.
+ * l'authentification. Le serveur applicatif écoute en clair sur la boucle
+ * locale : celui qui tourne déjà (application de bureau comprise, annoncé par
+ * `local-server.json` dans le dossier de données), sinon le port du CLI
+ * (`PIECEMAKER_APP_PORT`, 3003 par défaut). Aucun certificat n'entre en jeu et
+ * la requête ne sort jamais de 127.0.0.1.
  */
 
+import fs from 'node:fs';
 import http from 'node:http';
+import os from 'node:os';
+import { join } from 'node:path';
+
+import { GIT_REPO_ROOT } from './platform.mjs';
 
 const LOCAL_BASE = '/api/piecemaker/local';
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '::1', '0.0.0.0', '::']);
 
 export function appServerPort() {
   const parsed = Number.parseInt(process.env.PIECEMAKER_APP_PORT || '', 10);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : 3003;
 }
 
+function runningServerMarkerPath() {
+  if (process.env.CLOUDCLI_HOME) return join(process.env.CLOUDCLI_HOME, 'local-server.json');
+  try {
+    const config = JSON.parse(fs.readFileSync(join(GIT_REPO_ROOT, 'product.config.json'), 'utf8'));
+    return join(os.homedir(), config.dataDirectoryName, 'local-server.json');
+  } catch {
+    return null;
+  }
+}
+
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === 'EPERM';
+  }
+}
+
+export function runningServerPort(markerPath = runningServerMarkerPath()) {
+  if (!markerPath) return null;
+  try {
+    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+    const port = Number(marker?.port);
+    const pid = Number(marker?.pid);
+    if (!Number.isInteger(port) || port <= 0 || !LOOPBACK_HOSTS.has(marker?.host)) return null;
+    if (!Number.isInteger(pid) || pid <= 0 || !processAlive(pid)) return null;
+    return port;
+  } catch {
+    return null;
+  }
+}
+
+export function localServerReachable(port = appServerPort()) {
+  return new Promise((resolve) => {
+    const request = http.get({ hostname: '127.0.0.1', port, path: '/api/auth/status', timeout: 2_000 }, (response) => {
+      response.resume();
+      resolve(response.statusCode < 500);
+    });
+    request.on('timeout', () => request.destroy());
+    request.on('error', () => resolve(false));
+  });
+}
+
+export async function adoptRunningServerPort({ markerPath, reachable = localServerReachable } = {}) {
+  if (process.env.PIECEMAKER_APP_PORT) return appServerPort();
+  const port = runningServerPort(markerPath);
+  if (port && await reachable(port)) process.env.PIECEMAKER_APP_PORT = String(port);
+  return appServerPort();
+}
+
 function requestJson({ method, path, body }) {
   const payload = body === undefined ? null : Buffer.from(JSON.stringify(body));
   return new Promise((resolve, reject) => {