@piecemaker-legal/piecemaker 1.0.6 → 1.0.7

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

@@ -6,6 +6,7 @@ import { spawn } from 'node:child_process';
 import { APP, LOG_DIR, PIECEMAKER_HOME, PORTS } from './config.mjs';
 import { waitUntil } from './exec.mjs';
 import { npmPath, runtimeEnv } from './node-runtime.mjs';
+import { freePort } from './ports.mjs';
 
 export const APP_LOG = path.join(LOG_DIR, 'application.log');
 export const APP_PID_FILE = path.join(PIECEMAKER_HOME, 'application.pid');
@@ -32,6 +33,53 @@ 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') {
+    try { process.kill(pid, 'SIGTERM'); return true; } catch { return false; }
+  }
+  try { process.kill(-pid, 'SIGTERM'); return true; } catch {
+    try { process.kill(pid, 'SIGTERM'); return true; } catch { return false; }
+  }
+}
+
+export async function stopApplication() {
+  const killed = [];
+  const occupied = [];
+  try {
+    const pid = Number.parseInt(fs.readFileSync(APP_PID_FILE, 'utf8'), 10);
+    if (stopPid(pid)) killed.push(pid);
+  } catch {
+  }
+
+  for (const port of [PORTS.appClient, PORTS.appServer, anonymizerPort()]) {
+    const result = await freePort(port);
+    killed.push(...result.killed);
+    if (!result.released) occupied.push(port);
+  }
+
+  try { fs.rmSync(APP_PID_FILE, { force: true }); } catch { }
+  return { killed: [...new Set(killed)], occupied };
+}
+
+function readLogTail(file, maxLines = 40) {
+  try {
+    const lines = fs.readFileSync(file, 'utf8').trimEnd().split(/\n/);
+    return lines.slice(-maxLines).join('\n');
+  } catch {
+    return '';
+  }
+}
+
 export async function startApplication(runtime, report) {
   const alreadyRunning = await appClientReachable() && await appServerReachable();
   if (alreadyRunning) {
@@ -61,11 +109,24 @@ export async function startApplication(runtime, report) {
     fs.closeSync(logHandle);
   }
 
-  child.unref();
   fs.writeFileSync(APP_PID_FILE, String(child.pid), 'utf8');
 
-  const serverUp = await waitUntil(appServerReachable, { timeoutMs: 120_000 });
-  const clientUp = await waitUntil(appClientReachable, { timeoutMs: 120_000 });
+  const death = new Promise((resolve) => {
+    child.once('error', () => resolve('died'));
+    child.once('exit', () => resolve('died'));
+  });
+
+  await Promise.race([
+    waitUntil(appServerReachable, { timeoutMs: 120_000 }),
+    death,
+  ]);
+  const serverUp = await appServerReachable();
+  if (!serverUp) {
+    child.unref();
+    return { started: true, pid: child.pid, serverUp: false, clientUp: false, logTail: readLogTail(APP_LOG) };
+  }
 
-  return { started: true, pid: child.pid, serverUp, clientUp };
+  const clientUp = await waitUntil(appClientReachable, { timeoutMs: 120_000 });
+  child.unref();
+  return { started: true, pid: child.pid, serverUp: true, clientUp, logTail: clientUp ? '' : readLogTail(APP_LOG) };
 }

package/scripts/piecemaker/cli/piecemaker-command.test.mjs

@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+import { BIN_DIR } from './lib/config.mjs';
+import { piecemakerExecutable } from './install-command.mjs';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+test('the curl bootstrap installs the piecemaker command before launching', () => {
+  const posix = fs.readFileSync(path.join(here, 'piecemaker.sh'), 'utf8');
+  const windows = fs.readFileSync(path.join(here, 'piecemaker.ps1'), 'utf8');
+  assert.match(posix, /install-command\.mjs/);
+  assert.match(windows, /install-command\.mjs/);
+});
+
+test('the desktop launcher binds to the installed piecemaker binary', () => {
+  const executable = piecemakerExecutable();
+  assert.equal(path.basename(executable).startsWith('piecemaker'), true);
+  if (executable !== 'piecemaker') {
+    assert.equal(executable.startsWith(BIN_DIR) || executable.includes(`${path.sep}node${path.sep}` ) || executable.includes('versions/node'), true);
+  }
+});

package/scripts/piecemaker/cli/piecemaker.mjs

@@ -1,22 +1,22 @@
 #!/usr/bin/env node
 
+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';
-import { freePort } from './lib/ports.mjs';
 import { ensureDependencies, ensureRepository, rebuildNativeModules } from './lib/repos.mjs';
-import { APP_LOG, appClientReachable, appServerReachable, startApplication } from './lib/services.mjs';
-import { installApplicationEntry, openApplication, verifyPwaAssets } from './lib/pwa.mjs';
+import { APP_LOG, appClientReachable, appServerReachable, startApplication, stopApplication } from './lib/services.mjs';
+import { applicationWindowIsOpen, installApplicationEntry, openApplication, verifyPwaAssets } from './lib/pwa.mjs';
 import { banner, blank, c, detail, fail, ok, step, warn } from './lib/ui.mjs';
 
 const report = { step, ok, warn, detail };
 
-const HELP = `${c.bold('piecemaker')} — installe, met à jour et lance toute la plateforme.
+const HELP = `${c.bold('piecemaker')} — installe, met à jour, répare et lance toute la plateforme.
 
-  piecemaker                 tout faire : ports, dépôts, dépendances, PWA, serveurs
-  piecemaker --launch-only   ne relance que les serveurs manquants
-  piecemaker --no-open       ne pas ouvrir l application à la fin
+  piecemaker                 reset propre, puis installation et lancement
+  piecemaker --launch-only   répare et relance seulement si l'application est arrêtée
   piecemaker --help          cette aide
 `;
 
@@ -24,27 +24,9 @@ function parseArguments(argv) {
   return {
     help: argv.includes('--help') || argv.includes('-h'),
     launchOnly: argv.includes('--launch-only'),
-    open: !argv.includes('--no-open'),
   };
 }
 
-async function cleanPorts(launchOnly) {
-  step('Libération des ports');
-  const targets = launchOnly
-    ? [PORTS.appServer, PORTS.appClient]
-    : [PORTS.appClient, PORTS.appServer];
-
-  for (const port of targets) {
-    const result = await freePort(port);
-    if (!result.released) {
-      warn(`port ${port} toujours occupé`);
-      continue;
-    }
-    if (result.killed.length > 0) detail(`port ${port} libéré (${result.killed.join(', ')})`);
-  }
-  ok('Ports disponibles');
-}
-
 async function synchroniseRepositories(runtime) {
   if (!gitAvailable()) {
     throw new Error('git est requis et introuvable.');
@@ -63,32 +45,43 @@ async function synchroniseRepositories(runtime) {
   rebuildNativeModules(APP, runtime, report, ['better-sqlite3', 'node-pty']);
 }
 
-async function launchServices(runtime) {
-  const applicationAlreadyRunning = await appServerReachable() && await appClientReachable();
-
-  if (applicationAlreadyRunning) {
-    ok(`Application déjà active — ${APP_URL}`);
-    detail('socle laissé en l état : le routage des clients IA appartient à l application en cours');
-    return true;
+function printLogTail(logTail) {
+  if (!logTail) {
+    detail(`journal : ${APP_LOG}`);
+    return;
+  }
+  detail(`journal : ${APP_LOG}`);
+  for (const line of logTail.split('\n')) {
+    if (line.trim()) detail(line);
   }
+}
+
+async function applicationIsRunning() {
+  return await appServerReachable() && await appClientReachable();
+}
+
+async function resetAndLaunch(runtime) {
+  step('Reset de l application');
+  const stopped = await stopApplication();
+  if (stopped.killed.length) detail(`arrêtés : ${stopped.killed.join(', ')}`);
+  for (const port of stopped.occupied) warn(`port ${port} toujours occupé`);
+  ok('Processus précédents arrêtés');
 
   const application = await startApplication(runtime, report);
   if (application.alreadyRunning) {
     ok(`Application déjà active — ${APP_URL}`);
     return true;
   }
-
   if (!application.serverUp) {
     fail(`Serveur applicatif injoignable sur le port ${PORTS.appServer}`);
-    detail(`journal : ${APP_LOG}`);
+    printLogTail(application.logTail);
     return false;
   }
   if (!application.clientUp) {
     fail(`Client applicatif injoignable sur le port ${PORTS.appClient}`);
-    detail(`journal : ${APP_LOG}`);
+    printLogTail(application.logTail);
     return false;
   }
-
   ok(`Application active — serveur :${PORTS.appServer}, client ${APP_URL}`);
   return true;
 }
@@ -111,6 +104,7 @@ async function installPwa() {
   for (const location of entry.locations || []) {
     if (location !== entry.location) detail(`également posé : ${location}`);
   }
+  detail(`icône liée à ${piecemakerExecutable()}`);
   if (!entry.standalone) detail('navigateur Chromium absent : ouverture en onglet classique');
   if (!entry.verified) warn('installation incomplète : un emplacement attendu est introuvable après coup');
 }
@@ -127,7 +121,19 @@ async function main() {
   const runtime = resolveNodeRuntime();
   detail(`Node ${runtime.version}`);
 
-  await cleanPorts(options.launchOnly);
+  step('Commande piecemaker');
+  const command = installPiecemakerCommand();
+  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;
+  } else {
+    ok(`Application déjà active — ${APP_URL}`);
+  }
 
   if (!options.launchOnly) {
     await synchroniseRepositories(runtime);
@@ -135,19 +141,14 @@ async function main() {
     await installPlugins(runtime, report);
   }
 
-  const running = await launchServices(runtime);
-  if (!running) return 1;
-
-  if (!options.launchOnly) {
-    await installPwa();
-  }
+  await installPwa();
 
   blank();
   ok(`Application  ${c.bold(APP_URL)}`);
   detail('Configuration du socle : onglet Dossier › Configuration.');
   blank();
 
-  if (options.open) openApplication();
+  if (!options.launchOnly && !applicationWindowIsOpen()) openApplication();
   return 0;
 }
 

package/scripts/piecemaker/cli/piecemaker.ps1

@@ -59,5 +59,13 @@ if (-not (Test-Path $EntryPath)) {
   exit 1
 }
 
+$Installer = Join-Path $AppDir 'scripts\piecemaker\cli\install-command.mjs'
+if (Test-Path $Installer) {
+  & $NodeBin $Installer
+}
+
+$BinDir = Join-Path $HOME '.piecemaker\bin'
+$env:PATH = "$(Split-Path $NodeBin -Parent);$BinDir;$env:PATH"
+
 & $NodeBin $EntryPath @args
 exit $LASTEXITCODE

package/scripts/piecemaker/cli/piecemaker.sh

@@ -54,7 +54,12 @@ if [ ! -f "$APP_DIR/$ENTRY" ]; then
   exit 1
 fi
 
-PATH="$(dirname "$NODE_BIN"):$PATH"
+INSTALLER="$APP_DIR/scripts/piecemaker/cli/install-command.mjs"
+if [ -f "$INSTALLER" ]; then
+  "$NODE_BIN" "$INSTALLER" || true
+fi
+
+PATH="$(dirname "$NODE_BIN"):${HOME}/.piecemaker/bin:${PATH:-}"
 export PATH
 
 exec "$NODE_BIN" "$APP_DIR/$ENTRY" "$@"

package/server/index.ts

@@ -30,7 +30,7 @@ import { commandsRoutes } from './modules/commands/index.js';
 import { settingsRoutes } from './modules/settings/index.js';
 import { createSystemModule } from './modules/system/index.js';
 import { createAgentModule } from './modules/agent/index.js';
-import { createPieceMakerRouter } from './piecemaker/index.js';
+import { createPieceMakerRouter, stopOriginalsJobs } from './piecemaker/index.js';
 import projectModuleRoutes from './modules/projects/projects.routes.js';
 import notificationRoutes from './modules/notifications/notifications.routes.js';
 import { userRoutes } from './modules/user/index.js';
@@ -378,29 +378,58 @@ async function startServer() {
             });
         });
 
-        await closeSessionsWatcher();
-        closeScheduledMessageDispatcher();
-        // Clean up plugin processes on shutdown
-        const shutdownRuntimeServices = async () => {
-            try {
-                await browserUseService.stopAllSessions();
-            } catch (err) {
-                console.error('[Browser] Error stopping sessions during shutdown:', getErrorMessage(err));
-            }
-            try {
-                await stopAllPlugins();
-            } catch (err) {
-                console.error('[Plugins] Error stopping plugins during shutdown:', getErrorMessage(err));
-            }
-            try {
-                await removeLocalServerMarker();
-            } catch (err) {
-                console.error('[Local Server] Error removing server marker during shutdown:', getErrorMessage(err));
-            }
-            process.exit(0);
+        let shutdownPromise: Promise<void> | null = null;
+        const shutdownRuntimeServices = () => {
+            if (shutdownPromise) return shutdownPromise;
+            shutdownPromise = (async () => {
+                // Stop accepting HTTP work first. Existing requests may finish while
+                // the process pipelines and background services are being drained.
+                const serverClosed = new Promise<void>((resolve, reject) => {
+                    server.close((error) => {
+                        if (error && getErrorCode(error) !== 'ERR_SERVER_NOT_RUNNING') reject(error);
+                        else resolve();
+                    });
+                }).catch((err) => {
+                    console.error('[Server] Error closing HTTP server during shutdown:', getErrorMessage(err));
+                });
+
+                try {
+                    await closeSessionsWatcher();
+                } catch (err) {
+                    console.error('[Sessions] Error stopping watchers during shutdown:', getErrorMessage(err));
+                }
+                try {
+                    closeScheduledMessageDispatcher();
+                } catch (err) {
+                    console.error('[Scheduled messages] Error stopping dispatcher during shutdown:', getErrorMessage(err));
+                }
+                try {
+                    await stopOriginalsJobs();
+                } catch (err) {
+                    console.error('[PieceMaker] Error stopping pipeline jobs during shutdown:', getErrorMessage(err));
+                }
+                try {
+                    await browserUseService.stopAllSessions();
+                } catch (err) {
+                    console.error('[Browser] Error stopping sessions during shutdown:', getErrorMessage(err));
+                }
+                try {
+                    await stopAllPlugins();
+                } catch (err) {
+                    console.error('[Plugins] Error stopping plugins during shutdown:', getErrorMessage(err));
+                }
+                await serverClosed;
+                try {
+                    await removeLocalServerMarker();
+                } catch (err) {
+                    console.error('[Local Server] Error removing server marker during shutdown:', getErrorMessage(err));
+                }
+                process.exit(0);
+            })();
+            return shutdownPromise;
         };
-        process.on('SIGTERM', () => void shutdownRuntimeServices());
-        process.on('SIGINT', () => void shutdownRuntimeServices());
+        process.on('SIGTERM', () => { void shutdownRuntimeServices(); });
+        process.on('SIGINT', () => { void shutdownRuntimeServices(); });
     } catch (error) {
         console.error('[ERROR] Failed to start server:', error);
         process.exit(1);

package/server/modules/database/repositories/projects.db.ts

@@ -15,6 +15,22 @@ function normalizeProjectDisplayName(projectPath: string, customProjectName: str
     return directoryName || projectPath;
 }
 
+function ensureAnonymizationStatusTable(db: ReturnType<typeof getConnection>): void {
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS piecemaker_anonymization_status (
+            project_id TEXT PRIMARY KEY NOT NULL,
+            completed_at TEXT NOT NULL,
+            FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE CASCADE
+        )
+    `);
+    const mappingsExist = db.prepare(`SELECT 1 AS ok FROM sqlite_master WHERE type='table' AND name='piecemaker_mappings'`).get() as { ok: number } | undefined;
+    if (!mappingsExist) return;
+    db.prepare(`
+        INSERT OR IGNORE INTO piecemaker_anonymization_status(project_id, completed_at)
+        SELECT DISTINCT project_id, ? FROM piecemaker_mappings
+    `).run(new Date().toISOString());
+}
+
 export const projectsDb = {
     createProjectPath(projectPath: string, customProjectName: string | null = null): CreateProjectPathResult {
         const db = getConnection();
@@ -88,10 +104,13 @@ export const projectsDb = {
 
     getProjectPaths(): ProjectRepositoryRow[] {
         const db = getConnection();
+        ensureAnonymizationStatusTable(db);
         return db.prepare(`
-            SELECT project_id, project_path, custom_project_name, isStarred, isArchived
-            FROM projects
-            WHERE isArchived = 0
+            SELECT p.project_id, p.project_path, p.custom_project_name, p.isStarred, p.isArchived,
+                   CASE WHEN s.project_id IS NULL THEN 0 ELSE 1 END AS anonymization_complete
+            FROM projects p
+            LEFT JOIN piecemaker_anonymization_status s ON s.project_id = p.project_id
+            WHERE p.isArchived = 0
         `).all() as ProjectRepositoryRow[];
     },
 
@@ -101,10 +120,13 @@ export const projectsDb = {
      */
     getArchivedProjectPaths(): ProjectRepositoryRow[] {
         const db = getConnection();
+        ensureAnonymizationStatusTable(db);
         return db.prepare(`
-            SELECT project_id, project_path, custom_project_name, isStarred, isArchived
-            FROM projects
-            WHERE isArchived = 1
+            SELECT p.project_id, p.project_path, p.custom_project_name, p.isStarred, p.isArchived,
+                   CASE WHEN s.project_id IS NULL THEN 0 ELSE 1 END AS anonymization_complete
+            FROM projects p
+            LEFT JOIN piecemaker_anonymization_status s ON s.project_id = p.project_id
+            WHERE p.isArchived = 1
         `).all() as ProjectRepositoryRow[];
     },
 

package/server/modules/database/tests/projects.db.integration.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
 
-import { closeConnection } from '@/modules/database/connection.js';
+import { closeConnection, getConnection } from '@/modules/database/connection.js';
 import { initializeDatabase } from '@/modules/database/init-db.js';
 import { projectsDb } from '@/modules/database/repositories/projects.db.js';
 
@@ -70,3 +70,65 @@ test('projectsDb.createProjectPath returns active_conflict for active duplicates
     assert.equal(conflict.project?.isArchived, 0);
   });
 });
+
+test('projectsDb.getProjectPaths reads anonymization completion directly from SQLite', async () => {
+  await withIsolatedDatabase(() => {
+    const created = projectsDb.createProjectPath('/workspace/anonymized-project');
+    assert.ok(created.project);
+
+    projectsDb.getProjectPaths();
+    getConnection().prepare(`
+      INSERT INTO piecemaker_anonymization_status (project_id, completed_at)
+      VALUES (?, ?)
+    `).run(created.project.project_id, new Date().toISOString());
+
+    const project = projectsDb.getProjectPaths()[0];
+    assert.equal(project.anonymization_complete, 1);
+  });
+});
+
+test('projectsDb.getProjectPaths backfills anonymization completion from existing mappings', async () => {
+  await withIsolatedDatabase(() => {
+    const created = projectsDb.createProjectPath('/workspace/legacy-scanned-project');
+    assert.ok(created.project);
+    const db = getConnection();
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS piecemaker_nodes (
+        project_id TEXT NOT NULL,
+        id TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        label TEXT NOT NULL,
+        search_text TEXT NOT NULL DEFAULT '',
+        aliases_json TEXT NOT NULL DEFAULT '[]',
+        data_json TEXT NOT NULL DEFAULT '{}',
+        origin TEXT NOT NULL DEFAULT 'gliner',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (project_id, id)
+      );
+      CREATE TABLE IF NOT EXISTS piecemaker_mappings (
+        project_id TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        real_value TEXT NOT NULL,
+        masked_value TEXT NOT NULL,
+        search_text TEXT NOT NULL DEFAULT '',
+        data_json TEXT NOT NULL DEFAULT '{}',
+        origin TEXT NOT NULL DEFAULT 'gliner',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (project_id, node_id, real_value)
+      );
+    `);
+    db.prepare(`
+      INSERT INTO piecemaker_nodes(project_id,id,kind,label,search_text,aliases_json,data_json,origin,created_at,updated_at)
+      VALUES (?, 'person-1', 'person', 'Alice', 'alice', '[]', '{}', 'gliner', ?, ?)
+    `).run(created.project.project_id, new Date().toISOString(), new Date().toISOString());
+    db.prepare(`
+      INSERT INTO piecemaker_mappings(project_id,node_id,real_value,masked_value,search_text,data_json,origin,created_at,updated_at)
+      VALUES (?, 'person-1', 'Alice', 'PERSONNE_PHYSIQUE_01', 'alice', '{}', 'gliner', ?, ?)
+    `).run(created.project.project_id, new Date().toISOString(), new Date().toISOString());
+
+    const project = projectsDb.getProjectPaths()[0];
+    assert.equal(project.anonymization_complete, 1);
+  });
+});

package/server/modules/plugins/plugins.routes.ts

@@ -26,8 +26,15 @@ export function createPluginsRouter(service: ReturnType<typeof createPluginsServ
   router.get('/:name/assets/*', async (req, res, next) => {
     try {
       const asset = service.resolveAsset(routeParameter(req.params.name), wildcardPath(req));
+      const stats = fs.statSync(asset.path);
+      const etag = `"${stats.mtimeMs.toString(16)}-${stats.size.toString(16)}"`;
       res.setHeader('Content-Type', asset.contentType);
-      res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
+      res.setHeader('ETag', etag);
+      res.setHeader('Cache-Control', 'private, max-age=0, must-revalidate');
+      if (req.headers['if-none-match'] === etag) {
+        res.status(304).end();
+        return;
+      }
       const stream = fs.createReadStream(asset.path);
       stream.on('error', next);
       stream.pipe(res);

package/server/modules/projects/services/projects-with-sessions-fetch.service.ts

@@ -29,6 +29,7 @@ export type ProjectListItem = {
   displayName: string;
   fullPath: string;
   isStarred: boolean;
+  anonymizationComplete: boolean;
   sessions: SessionSummary[];
   sessionMeta: {
     hasMore: boolean;
@@ -189,6 +190,7 @@ export async function getProjectsWithSessions(
     project_path: string;
     custom_project_name?: string | null;
     isStarred?: number;
+    anonymization_complete?: number;
   }>;
   const totalProjects = projectRows.length;
   const projects: ProjectListItem[] = [];
@@ -223,6 +225,7 @@ export async function getProjectsWithSessions(
       displayName,
       fullPath: projectPath,
       isStarred: Boolean(row.isStarred),
+      anonymizationComplete: Boolean(row.anonymization_complete),
       sessions: sessionsPage.sessions,
       sessionMeta: {
         hasMore: sessionsPage.hasMore,
@@ -257,6 +260,7 @@ export async function getArchivedProjectsWithSessions(
     project_path: string;
     custom_project_name?: string | null;
     isStarred?: number;
+    anonymization_complete?: number;
   }>;
 
   const archivedProjects: ArchivedProjectListItem[] = [];
@@ -275,6 +279,7 @@ export async function getArchivedProjectsWithSessions(
       displayName,
       fullPath: row.project_path,
       isStarred: Boolean(row.isStarred),
+      anonymizationComplete: Boolean(row.anonymization_complete),
       isArchived: true,
       sessions: sessionsPage.sessions,
       sessionMeta: {

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

@@ -138,10 +138,18 @@ function configureCodexProxy({
 
   const managedTable = lines.findIndex((line) => line.trim() === `[model_providers.${CODEX_PROVIDER_ID}]`);
   const managedStart = lines.findIndex((line) => line.trim() === CODEX_BLOCK_START);
-  const managedEnd = lines.findIndex((line) => line.trim() === CODEX_BLOCK_END);
-  if (managedTable >= 0 && (managedStart < 0 || managedEnd < managedTable)) {
+  let managedEnd = lines.findIndex((line) => line.trim() === CODEX_BLOCK_END);
+  if (managedTable >= 0 && managedStart < 0) {
     return { configured: false, changed: false, conflict: true, file: configFile, reason: 'provider-table-conflict' };
   }
+  if (managedStart >= 0 && managedEnd < managedStart) {
+    let end = managedTable >= managedStart ? managedTable : managedStart;
+    for (let index = end + 1; index < lines.length; index += 1) {
+      if (/^\s*\[/.test(lines[index])) break;
+      end = index;
+    }
+    managedEnd = end;
+  }
 
   if (provider) {
     lines[provider.index] = `model_provider = ${tomlString(CODEX_PROVIDER_ID)} # géré par PieceMaker`;