agentic-api 2.0.645 → 2.0.684

package/dist/src/agents/simulator.js

@@ -59,6 +59,127 @@ class AgentSimulator {
         });
     }
     // ============================================================================
+    // WORKER API : runJob(input) — exécution de mission autonome
+    // ============================================================================
+    /**
+     * Exécuter un WorkerJob — boucle Worker LLM ↔ Agent LLM
+     *
+     * Parallèle à testCase() mais pour des missions de production :
+     * - Le Worker LLM formule des questions pour l'Agent
+     * - L'Agent répond avec ses tools (RAG, DB, emails, calendar...)
+     * - Le Worker LLM évalue et continue ou termine avec [WORKER_COMPLETE]
+     *
+     * @param input - Paramètres du job (query, maxIterations, agentContext)
+     * @returns WorkerResult
+     *
+     * @example
+     * ```typescript
+     * const worker = new AgentSimulator({
+     *   agents: [...], start: 'PR-knowledge', verbose: false,
+     *   mode: 'worker',
+     *   instructionEx: 'Consulter tous les mails du jour et résumer les actions'
+     * });
+     *
+     * const result = await worker.runJob({
+     *   query: 'Commence par lister les mails du jour',
+     *   maxIterations: 10,
+     *   agentContext: realContext
+     * });
+     * ```
+     */
+    async runJob(input) {
+        const startTime = Date.now();
+        const maxIterations = input.maxIterations ?? 10;
+        //
+        // Initialiser les contextes avec le contexte réel de l'agent
+        const context = await this.executor.initializeContexts({ goals: '', persona: '', result: '' }, input.agentContext);
+        const allMessages = [];
+        let exchangeCounter = 0;
+        try {
+            let currentUserQuery = input.query;
+            //
+            // Stocker le message initial
+            const initialMsg = { content: currentUserQuery, role: 'user' };
+            allMessages.push(initialMsg);
+            if (input.onMessage) {
+                input.onMessage(initialMsg);
+            }
+            //
+            // Boucle Worker — maxIterations échanges (parallèle à executeSimulation)
+            while (exchangeCounter < maxIterations) {
+                //
+                // Agent répond à la question
+                const agentResponse = await this.executor.executeAgent(context, currentUserQuery);
+                const agentMsg = { content: agentResponse, role: 'assistant' };
+                allMessages.push(agentMsg);
+                if (input.onMessage) {
+                    input.onMessage(agentMsg);
+                }
+                exchangeCounter++;
+                //
+                // Worker LLM évalue la réponse de l'Agent
+                const workerResponse = await this.executor.executeSimulator(context, agentResponse);
+                //
+                // Vérifier [WORKER_COMPLETE]
+                if (this.isWorkerComplete(workerResponse)) {
+                    const parsed = this.parseWorkerResult(workerResponse);
+                    this.lastExecution = context.lastExecution;
+                    return {
+                        success: true,
+                        deliverable: parsed.deliverable,
+                        summary: parsed.summary,
+                        confidence: parsed.confidence,
+                        iterations: exchangeCounter,
+                        maxIterations,
+                        duration: Date.now() - startTime,
+                        execution: context.lastExecution,
+                        messages: allMessages
+                    };
+                }
+                //
+                // Pas terminé — extraire la prochaine question pour l'Agent
+                currentUserQuery = this.extractConversationalPart(workerResponse);
+                if (currentUserQuery) {
+                    const workerMsg = { content: currentUserQuery, role: 'user' };
+                    allMessages.push(workerMsg);
+                    if (input.onMessage) {
+                        input.onMessage(workerMsg);
+                    }
+                }
+            }
+            //
+            // Timeout — maxIterations atteint sans [WORKER_COMPLETE]
+            this.lastExecution = context.lastExecution;
+            return {
+                success: false,
+                deliverable: '',
+                summary: `Max iterations reached (${maxIterations})`,
+                confidence: 0,
+                iterations: exchangeCounter,
+                maxIterations,
+                duration: Date.now() - startTime,
+                execution: context.lastExecution,
+                messages: allMessages,
+                error: 'Max iterations reached without [WORKER_COMPLETE]'
+            };
+        }
+        catch (error) {
+            this.lastExecution = context.lastExecution;
+            return {
+                success: false,
+                deliverable: '',
+                summary: '',
+                confidence: 0,
+                iterations: exchangeCounter,
+                maxIterations,
+                duration: Date.now() - startTime,
+                execution: context.lastExecution,
+                messages: allMessages,
+                error: `Erreur d'exécution: ${error.message || error}`
+            };
+        }
+    }
+    // ============================================================================
     // ANCIENNE API : executeSimulation(options) - deprecated
     // ============================================================================
     /**
@@ -118,12 +239,18 @@ class AgentSimulator {
                     const parsed = this.parseSimulationResult(simulatorResult, expectedFormat, context);
                     this.lastExecution = context.lastExecution;
                     // Validation des tools si expectedTool est fourni
-                    if (options.expectedTool) {
+                    if (options.expectedTool && Object.keys(options.expectedTool).length > 0) {
                         const validation = this.validateExpectedTools(options.expectedTool);
+                        //
+                        // Toujours définir toolValidation pour inspection par les tests
+                        parsed.toolValidation = validation;
                         if (!validation.passed) {
                             parsed.success = false;
-                            parsed.error = validation.errors.join('; ');
-                            parsed.toolValidation = validation;
+                            //
+                            // Préserver l'erreur LLM si présente, ajouter l'erreur de validation
+                            const llmError = parsed.error || '';
+                            const toolError = validation.errors.join('; ');
+                            parsed.error = llmError ? `${llmError} | Tool validation: ${toolError}` : toolError;
                         }
                     }
                     // Ajouter l'historique des messages au résultat
@@ -149,12 +276,16 @@ class AgentSimulator {
             const timeout = await this.generateTimeoutReport(context, expectedFormat);
             this.lastExecution = context.lastExecution;
             // Validation des tools même en cas de timeout
-            if (options.expectedTool) {
+            if (options.expectedTool && Object.keys(options.expectedTool).length > 0) {
                 const validation = this.validateExpectedTools(options.expectedTool);
+                //
+                // Toujours définir toolValidation pour inspection par les tests
+                timeout.toolValidation = validation;
                 if (!validation.passed) {
                     timeout.success = false;
-                    timeout.error = validation.errors.join('; ');
-                    timeout.toolValidation = validation;
+                    const llmError = timeout.error || '';
+                    const toolError = validation.errors.join('; ');
+                    timeout.error = llmError ? `${llmError} | Tool validation: ${toolError}` : toolError;
                 }
             }
             return { ...timeout, exchangeCount: exchangeCounter, messages: allMessages }; // Utiliser notre compteur      
@@ -222,6 +353,29 @@ class AgentSimulator {
     isSimulationComplete(response) {
         return response.includes('[DONE]') || response.includes('[SIMULATION_COMPLETE]') || response.includes('[TERMINE]');
     }
+    isWorkerComplete(response) {
+        return response.includes('[WORKER_COMPLETE]');
+    }
+    parseWorkerResult(response) {
+        const match = response.match(/\[WORKER_COMPLETE\]\s*\n?([\s\S]*)/);
+        if (match) {
+            const content = match[1].trim();
+            try {
+                const parsed = JSON.parse(content);
+                return {
+                    deliverable: parsed.deliverable || content,
+                    summary: parsed.summary || '',
+                    confidence: parsed.confidence ?? 0.5
+                };
+            }
+            catch {
+                //
+                // Fallback : contenu brut comme deliverable
+                return { deliverable: content, summary: '', confidence: 0.5 };
+            }
+        }
+        return { deliverable: '', summary: '', confidence: 0 };
+    }
     parseSimulationResult(response, expectedFormat, context) {
         // Le simulateur produit directement le résultat et rapport
         // Parsing pour détecter la fin et extraire le contenu JSON
@@ -286,7 +440,7 @@ class AgentSimulator {
     extractConversationalPart(response) {
         // Extraire la partie conversationnelle avant les tags d'évaluation ou d'observation
         // Filtrer tous les tags système : [DONE], [OBSERVATEUR SILENCIEUX], [À NOTER], etc.
-        const tagIndex = response.search(/\[(DONE|SIMULATION_COMPLETE|TERMINE|BUG_|OBSERVATEUR|À NOTER|NOTE|ANALYSE)/i);
+        const tagIndex = response.search(/\[(DONE|SIMULATION_COMPLETE|TERMINE|WORKER_COMPLETE|BUG_|OBSERVATEUR|À NOTER|NOTE|ANALYSE)/i);
         if (tagIndex !== -1) {
             return response.substring(0, tagIndex).trim();
         }

package/dist/src/agents/simulator.prompts.d.ts

@@ -16,3 +16,21 @@ export declare function GENERIC_SIMULATOR_PROMPT(scenario: SimulationScenario, i
 export declare const PERSONA_PATIENT = "Utilisateur patient et poli qui prend le temps d'expliquer sa situation";
 export declare const PERSONA_PRESSE = "Utilisateur press\u00E9 qui veut une solution rapide, r\u00E9pond bri\u00E8vement";
 export declare const PERSONA_ENERVE = "Utilisateur \u00E9nerv\u00E9 et frustr\u00E9, c'est son 3\u00E8me appel pour le m\u00EAme probl\u00E8me, ton direct et impatient";
+/**
+ * Persona collaborateur professionnel et méthodique
+ */
+export declare const PERSONA_EMPLOYEE = "Collaborateur professionnel et m\u00E9thodique, tu formules des demandes claires et pr\u00E9cises, tu analyses les r\u00E9ponses de mani\u00E8re critique, et tu identifies les lacunes pour poser des questions de suivi.";
+/**
+ * Prompt interne fixe du WorkerJob — system prompt pour le Worker LLM
+ *
+ * Parallèle à GENERIC_SIMULATOR_PROMPT : même pattern, différent rôle.
+ * - GENERIC_SIMULATOR_PROMPT → testeur automatisé, détecte [DONE]
+ * - WORKER_INTERNAL_PROMPT → collaborateur, détecte [WORKER_COMPLETE]
+ *
+ * Le brief est injecté une fois dans les instructions système.
+ * La mémoire est gérée par l'historique de conversation (comme le simulateur).
+ *
+ * @param brief - Le cahier des charges du worker (= instructionEx de SimulatorConfig)
+ * @param instructionEx - Instructions additionnelles (optionnel)
+ */
+export declare function WORKER_INTERNAL_PROMPT(brief: string, instructionEx?: string): string;

package/dist/src/agents/simulator.prompts.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PERSONA_ENERVE = exports.PERSONA_PRESSE = exports.PERSONA_PATIENT = void 0;
+exports.PERSONA_EMPLOYEE = exports.PERSONA_ENERVE = exports.PERSONA_PRESSE = exports.PERSONA_PATIENT = void 0;
 exports.GENERIC_SIMULATOR_PROMPT = GENERIC_SIMULATOR_PROMPT;
+exports.WORKER_INTERNAL_PROMPT = WORKER_INTERNAL_PROMPT;
 /**
  * Génère le prompt du simulateur générique avec le scenario intégré
  *
@@ -56,9 +57,16 @@ Exemple de conversation:
   Tu retournes le trigger de fin: \`[DONE] {"success": true, "explain": "..."}\` ou \`[DONE] {"success": false, "error": "..."}\`.
 
 ### CONTEXT (\`<agent-context>\` invisible pour le CLIENT)
-- Le tag \`<agent-context>\` contient des données techniques de l'agent testé (outils appelés, nombre d'échanges, etc).  
-- Ces informations sont **strictement réservées à toi l'observateur.  
-**AUTORISÉ** : les exploiter pour valider les objectifs ou décider de la fin du test.  
+- Le tag \`<agent-context>\` contient les **APPELS RÉELS** des outils effectués par l'agent testé.
+- Le champ \`tools\` liste les **noms exacts des outils appelés** pendant cet échange.
+- **CRITIQUE**: Si un outil apparaît dans \`<agent-context>.tools\`, c'est qu'il a **réellement été exécuté** par l'agent.
+- Ces informations sont **strictement réservées à toi l'observateur**.
+- **AUTORISÉ** : les exploiter pour valider les objectifs ou décider de la fin du test.  
+
+Exemple avec validation d'outil:
+> Agent répond avec une information  
+> \`<agent-context>{"tools": ["lookupKnowledge"], "exchangeCount": 1}</agent-context>\`  
+> → L'outil \`lookupKnowledge\` a été **réellement appelé** par l'agent ✅
 
 Exemple avec sortie pour <simulation_goals>CONDITION DE FIN: L'agent demande si l'utilisateur souhaite chercher sur internet</simulation_goals>:
 > Toi : "Quelle est la température du lac à Genève ?"  
@@ -86,3 +94,72 @@ ${instructionEx ? `\n\n${instructionEx}` : ''}`;
 exports.PERSONA_PATIENT = 'Utilisateur patient et poli qui prend le temps d\'expliquer sa situation';
 exports.PERSONA_PRESSE = 'Utilisateur pressé qui veut une solution rapide, répond brièvement';
 exports.PERSONA_ENERVE = 'Utilisateur énervé et frustré, c\'est son 3ème appel pour le même problème, ton direct et impatient';
+// ============================================================================
+// WORKER PROMPT — Prompt interne fixe pour WorkerJob
+// ============================================================================
+/**
+ * Persona collaborateur professionnel et méthodique
+ */
+exports.PERSONA_EMPLOYEE = 'Collaborateur professionnel et méthodique, tu formules des demandes claires et précises, tu analyses les réponses de manière critique, et tu identifies les lacunes pour poser des questions de suivi.';
+/**
+ * Prompt interne fixe du WorkerJob — system prompt pour le Worker LLM
+ *
+ * Parallèle à GENERIC_SIMULATOR_PROMPT : même pattern, différent rôle.
+ * - GENERIC_SIMULATOR_PROMPT → testeur automatisé, détecte [DONE]
+ * - WORKER_INTERNAL_PROMPT → collaborateur, détecte [WORKER_COMPLETE]
+ *
+ * Le brief est injecté une fois dans les instructions système.
+ * La mémoire est gérée par l'historique de conversation (comme le simulateur).
+ *
+ * @param brief - Le cahier des charges du worker (= instructionEx de SimulatorConfig)
+ * @param instructionEx - Instructions additionnelles (optionnel)
+ */
+function WORKER_INTERNAL_PROMPT(brief, instructionEx) {
+    return `# IDENTITÉ
+Tu es un **COLLABORATEUR** chargé d'une mission. Tu travailles de manière autonome en formulant des demandes précises à un Agent qui dispose de tous les outils nécessaires (recherche, bases de données, emails, calendrier, documents...).
+
+# MISSION
+Tu dois accomplir le cahier des charges décrit dans <worker_brief> en utilisant l'Agent comme exécutant.
+À chaque échange, tu formules UNE question ou instruction précise pour l'Agent.
+Tu analyses sa réponse, accumules les informations utiles, et décides de ta prochaine action.
+
+# MÉTHODE
+1. **Analyser** le brief et les réponses précédentes
+2. **Identifier** la prochaine information nécessaire ou action à réaliser
+3. **Formuler** une question/instruction claire et précise pour l'Agent
+4. **Évaluer** la réponse : est-ce suffisant pour atteindre l'objectif ?
+
+# RÈGLES
+- Formule UNE seule question/instruction par échange
+- Sois précis et contextuel dans tes demandes
+- N'invente pas d'information — base-toi uniquement sur les réponses de l'Agent
+- Si l'Agent ne peut pas répondre, reformule ou change d'approche
+- Accumule les faits clés de chaque réponse pour les réutiliser
+
+# TRIGGERS DE SORTIE
+Quand tu estimes que l'objectif du brief est atteint, ou que tu as accumulé suffisamment d'information pour produire le livrable, termine avec :
+\`[WORKER_COMPLETE]\`
+Suivi immédiatement du JSON de résultat (voir format ci-dessous).
+
+Si tu n'as pas terminé, formule simplement ta prochaine question/instruction pour l'Agent.
+
+# FORMAT DE SORTIE (uniquement quand terminé)
+\`\`\`
+[WORKER_COMPLETE]
+{"deliverable": "...", "summary": "...", "confidence": 0.95}
+\`\`\`
+
+Où :
+- \`deliverable\` : le résultat complet de la mission (texte, données, rapport...)
+- \`summary\` : résumé court de ce qui a été accompli
+- \`confidence\` : niveau de confiance (0.0 à 1.0) que l'objectif est atteint
+
+---
+
+<worker_brief>
+${brief}
+</worker_brief>
+
+**CRITICAL**: Si tu termines, le contenu après [WORKER_COMPLETE] doit être du JSON valide uniquement.
+${instructionEx ? `\n\n${instructionEx}` : ''}`;
+}

package/dist/src/agents/simulator.types.d.ts

@@ -1,10 +1,15 @@
 import { AgentMessage } from "../stategraph";
 import { AgentConfig, AgenticContext, ExecutionResult } from "../types";
 import { RAGManagerConfig } from "../rag";
+export declare const SIMULATOR_AGENT_NAME = "simple-simulator";
+export declare const SIMULATOR_AGENT_DESCRIPTION = "Simulateur simple pour tests - TOUJOURS retourner JSON valide";
+export declare const WORKER_AGENT_NAME = "worker-agent";
+export declare const WORKER_AGENT_DESCRIPTION = "Worker collaborateur pour missions autonomes";
 export interface SimulatorConfig {
     agents: AgentConfig[];
     start: string;
     verbose: boolean;
+    mode?: 'simulator' | 'worker';
     instructionEx?: string;
     mockCacheInitializer?: (sessionId: string) => Promise<void>;
     ragConfig?: RAGManagerConfig;
@@ -38,6 +43,30 @@ export interface TestCaseInput {
     expectedTools?: Record<string, ToolConstraint>;
     onMessage?: (message: AgentMessage) => void;
 }
+/**
+ * Input pour worker.runJob() — parallèle à TestCaseInput
+ */
+export interface WorkerJobInput {
+    query: string;
+    maxIterations?: number;
+    agentContext: AgenticContext;
+    onMessage?: (message: AgentMessage) => void;
+}
+/**
+ * Résultat d'un WorkerJob — parallèle à SimulationResult
+ */
+export interface WorkerResult {
+    success: boolean;
+    deliverable: string;
+    summary: string;
+    confidence: number;
+    iterations: number;
+    maxIterations: number;
+    duration: number;
+    execution: ExecutionResult;
+    messages: AgentMessage[];
+    error?: string;
+}
 /**
  * @deprecated Utiliser TestScenario à la place
  */

package/dist/src/agents/simulator.types.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKER_AGENT_DESCRIPTION = exports.WORKER_AGENT_NAME = exports.SIMULATOR_AGENT_DESCRIPTION = exports.SIMULATOR_AGENT_NAME = void 0;
+exports.SIMULATOR_AGENT_NAME = 'simple-simulator';
+exports.SIMULATOR_AGENT_DESCRIPTION = 'Simulateur simple pour tests - TOUJOURS retourner JSON valide';
+exports.WORKER_AGENT_NAME = 'worker-agent';
+exports.WORKER_AGENT_DESCRIPTION = 'Worker collaborateur pour missions autonomes';

package/dist/src/execute/helpers.js

@@ -45,7 +45,7 @@ function accumulateUsageTokens(stateGraph, discussion, agentName, model, usage)
 function stepsToActions(stateGraph, agentName) {
     return stateGraph.steps(agentName).map(step => ({
         action: step.tool,
-        content: step.context,
+        content: step.reason,
         feedback: step.reason
     }));
 }

package/dist/src/execute/responses.js

@@ -196,7 +196,7 @@ async function readCompletionsStream(params) {
             const transferredAgent = agents.find(a => a.name === transferAgentName) || agentConfig;
             const instructions = transferredAgent.instructions;
             const enrichedInstructions = (await params.enrichWithMemory?.("system", transferredAgent, context)) || '';
-            // ✅ Set préserve le trail existant via updateSystemMessage()
+            // ✅ Set préserve le trail existant via updateSystemContextTrail()
             stateGraph.set(discussionRootAgent, instructions + '\n' + enrichedInstructions);
         }
         //
@@ -236,12 +236,11 @@ async function readCompletionsStream(params) {
             for (let i = 0; i < results.length; i++) {
                 const result = results[i];
                 const toolCall = parsedCalls[i];
+                const reason = result.context ? `${result.context} (${toolCall.args.justification})` : toolCall.args.justification;
                 if (result.name) {
                     stateGraph.addStep(discussionRootAgent, {
                         tool: result.name,
-                        context: result.context || '',
-                        reason: toolCall.args.justification || '',
-                        id: result.id
+                        reason
                     });
                 }
             }
@@ -355,7 +354,7 @@ async function executeAgentSet(agentSet, context, params) {
     else if (enrichedInstructions) {
         //
         // Existing discussion: only update system message if enrichedInstructions exists
-        // stateGraph.set() preserves context-trail via updateSystemMessage()
+        // stateGraph.set() preserves context-trail via updateSystemContextTrail()
         const instructions = currentAgentConfig.instructions + '\n' + enrichedInstructions;
         stateGraph.set(discussionRootAgent, instructions);
     }

package/dist/src/rag/rag.manager.js

@@ -34,6 +34,9 @@ class RAGManager {
         if (!config.baseDir || !(0, fs_1.existsSync)(config.baseDir)) {
             throw new Error(`Le dossier du registre RAG n'existe pas: ${config.baseDir}`);
         }
+        if (!config.defaultName || config.defaultName.trim() === '') {
+            throw new Error('RAGManagerConfig.defaultName est obligatoire et ne peut pas être vide');
+        }
         this.config = {
             tempDir: path_1.default.join(config.baseDir, 'temp'),
             archiveDir: path_1.default.join(config.baseDir, 'archives'),
@@ -49,7 +52,10 @@ class RAGManager {
         // store instance in memory
         DEFAULT_RAG_INSTANCE[this.config.baseDir] = this;
         const registry = this.getRegistry();
-        const defaultName = registry.defaultName || 'RAGRegistry';
+        const defaultName = registry.defaultName;
+        if (!defaultName || defaultName.trim() === '') {
+            throw new Error('registry.json invalide: defaultName manquant');
+        }
         DEFAULT_RAG_INSTANCE[defaultName] = this;
     }
     static get(config) {
@@ -101,7 +107,7 @@ class RAGManager {
                 registry = {
                     version: '1.0',
                     registries: {},
-                    defaultName: 'RAGRegistry'
+                    defaultName: this.config.defaultName
                 };
             }
         }
@@ -109,12 +115,12 @@ class RAGManager {
             registry = {
                 version: '1.0',
                 registries: {},
-                defaultName: 'RAGRegistry'
+                defaultName: this.config.defaultName
             };
         }
-        // Définir defaultName par défaut s'il n'est pas défini
+        // Fail-fast: defaultName doit toujours être défini explicitement
         if (!registry.defaultName) {
-            registry.defaultName = 'RAGRegistry';
+            throw new Error('registry.json invalide: defaultName manquant. Fournir defaultName dans la config RAG.');
         }
         // Scanner les dossiers pour découvrir les RAG existants
         this.scanDirectoriesForRAGs(registry);
@@ -732,8 +738,15 @@ class RAGManager {
         }
         //
         // Charger le metadata pour obtenir la liste des documents
+        // Ignorer les dossiers temporaires (temp/) sans metadata
         const metadataFile = path_1.default.join(entry.configPath, types_1.RAG_FILES.METADATA);
         if (!(0, fs_1.existsSync)(metadataFile)) {
+            //
+            // Si c'est un dossier temporaire (temp/rule-validation-*), retourner vide au lieu d'erreur
+            if (entry.configPath.includes('/temp/') || entry.status === 'building') {
+                console.warn(`⚠️ Dossier temporaire sans metadata ignoré: ${entry.configPath}`);
+                return { documents: {}, totalQueries: 0 };
+            }
             throw new Error(`Fichier metadata manquant: ${metadataFile}`);
         }
         let metadata;
@@ -990,7 +1003,7 @@ class RAGManager {
             // Changer le défaut si nécessaire
             if (registry.defaultName === name) {
                 const remainingRAGs = Object.keys(registry.registries);
-                registry.defaultName = remainingRAGs.length > 0 ? remainingRAGs[0] : 'RAGRegistry';
+                registry.defaultName = remainingRAGs.length > 0 ? remainingRAGs[0] : this.config.defaultName;
             }
             this.saveRegistry(registry);
             console.log(`✅ RAG supprimé: ${name}`);
@@ -1420,7 +1433,10 @@ class RAGManager {
      */
     getDefault() {
         const registry = this.getRegistry();
-        return registry.defaultName || 'RAGRegistry';
+        if (!registry.defaultName || registry.defaultName.trim() === '') {
+            throw new Error('registry.json invalide: defaultName manquant');
+        }
+        return registry.defaultName;
     }
     /**
      * Obtient les statistiques de tous les RAG

package/dist/src/rag/types.d.ts

@@ -278,13 +278,15 @@ export interface RAGRegistry {
     version: string;
     /** Liste des RAG disponibles */
     registries: Record<string, RAGRegistryEntry>;
-    /** RAG par défaut (par défaut: 'RAGRegistry') */
+    /** RAG par défaut (obligatoire) */
     defaultName?: string;
 }
 /** Configuration du gestionnaire RAG */
 export interface RAGManagerConfig {
     /** Répertoire de base du registre */
     baseDir: string;
+    /** Nom du RAG par défaut (obligatoire) */
+    defaultName?: string;
     /** Répertoire temporaire pour les constructions */
     tempDir?: string;
     /** Répertoire d'archives */

package/dist/src/rules/git/git.e2e.helper.js

@@ -156,14 +156,14 @@ Temporary repository for E2E testing.`;
         return (0, index_1.gitCheckConfiguration)(this.git);
     }
     async isPRClosed(branch) {
-        return (0, index_1.gitIsPRClosed)(this.git, branch);
+        return (0, index_1.gitIsPRClosedRobust)(this.git, branch, this.config);
     }
     async isPRClosedRobust(branch, config) {
         return (0, index_1.gitIsPRClosedRobust)(this.git, branch, config || this.config);
     }
     async closePR(branch, author, message) {
         console.log(`[DEBUG][E2EHelper.closePR] Closing PR: ${branch} by ${author.name}`);
-        return (0, index_1.gitClosePR)(this.git, branch, author, message);
+        return (0, index_1.gitClosePRRobust)(this.git, branch, author, message || `Closed by ${author.name}`, this.config);
     }
     async closePRRobust(branch, closedBy, message, config) {
         return (0, index_1.gitClosePRRobust)(this.git, branch, closedBy, message, config || this.config);
@@ -174,7 +174,47 @@ Temporary repository for E2E testing.`;
         return (0, index_1.gitGetAllPR)(this.git, options);
     }
     async getNextPRNumber(validationPrefix) {
-        return (0, index_1.gitGetNextPRNumber)(this.git, validationPrefix);
+        const initialPRCounter = 60;
+        const registryPath = (0, path_1.join)(this.config.repoPath, '.git', 'with-ids.json');
+        const now = new Date().toISOString();
+        const allBranches = await this.getAllBranches();
+        const numbers = allBranches
+            .filter((branch) => branch.startsWith(validationPrefix))
+            .map((branch) => parseInt(branch.substring(validationPrefix.length).split('-')[0], 10))
+            .filter((num) => !isNaN(num));
+        const maxBranchNumber = numbers.length > 0 ? Math.max(...numbers) : initialPRCounter;
+        let registry = {
+            last: 980,
+            lastPR: initialPRCounter,
+            used: [],
+            updated: now,
+            matters: {}
+        };
+        if ((0, fs_1.existsSync)(registryPath)) {
+            try {
+                registry = JSON.parse(await fs_1.promises.readFile(registryPath, 'utf8'));
+            }
+            catch {
+                // Rebuild minimal registry fallback
+            }
+        }
+        if (!Number.isInteger(registry.lastPR)) {
+            registry.lastPR = initialPRCounter;
+        }
+        if (!Number.isInteger(registry.last)) {
+            registry.last = 980;
+        }
+        if (!Array.isArray(registry.used)) {
+            registry.used = [];
+        }
+        if (!registry.matters || typeof registry.matters !== 'object') {
+            registry.matters = {};
+        }
+        const nextPR = Math.max(registry.lastPR, maxBranchNumber, initialPRCounter) + 1;
+        registry.lastPR = nextPR;
+        registry.updated = now;
+        await fs_1.promises.writeFile(registryPath, JSON.stringify(registry, null, 2), 'utf8');
+        return nextPR;
     }
     async newPR(files, description, author, options) {
         //console.log(`[DEBUG][E2EHelper.newPR] Creating new PR by ${author.name} for files: ${files.join(', ')}`);
@@ -220,7 +260,11 @@ Temporary repository for E2E testing.`;
     async editFile(filePath, content, branch) {
         const user = { name: 'E2E Test', email: 'e2e@test.com' };
         const targetBranch = branch || this.config.draftBranch;
-        return (0, index_1.gitEditFile)(this.git, filePath, targetBranch, content, user, this.config);
+        const exists = await (0, index_1.gitFileExistsInBranch)(this.git, filePath, targetBranch);
+        if (!exists) {
+            throw new Error(`File "${filePath}" not found in branch "${targetBranch}"`);
+        }
+        return (0, index_1.gitCreateOrEditFile)(this.git, filePath, targetBranch, content, user, this.config);
     }
     async validateRepositoryState() {
         const errors = [];

package/dist/src/rules/git/git.health.js

@@ -608,10 +608,12 @@ class GitHealthManager {
                     // Parser le matter complet
                     const parsed = (0, utils_matter_1.matterParse)(fileData.content);
                     const { matter: fullMatter, content } = parsed;
-                    // ✅ CORRECTION: Utiliser gitEnsureMatterID() pour réutiliser l'ID existant du fichier
-                    // Si le fichier existe déjà dans une autre branche, son ID sera réutilisé
-                    // Sinon, un nouvel ID sera généré automatiquement
-                    const matterWithID = (0, git_1.gitEnsureMatterID)(fullMatter, this.config, branchName, file);
+                    // ✅ CORRECTION: En cas de doublon détecté, éviter la réutilisation via cache fichier
+                    // pour forcer une réallocation d'ID. Sinon, garder la logique d'identité stable.
+                    const isDuplicateIssue = report.duplicateID.some((entry) => entry.startsWith(fileRef));
+                    const matterWithID = isDuplicateIssue
+                        ? (0, git_1.gitEnsureMatterID)(fullMatter, this.config)
+                        : (0, git_1.gitEnsureMatterID)(fullMatter, this.config, branchName, file);
                     if (matterWithID.id !== fullMatter.id) {
                         if (fullMatter.id && fullMatter.id > 999) {
                             console.log(`   🔧 ${file}: ID ${fullMatter.id} remplacé par ID existant ${matterWithID.id}`);

package/dist/src/rules/git/index.d.ts

@@ -1,6 +1,6 @@
 export { lock, unlock, gitLoad, isValidInt, gitIsFileMerged, gitLastCommit, gitListFilesInBranch, gitListFilesOutsideRepo, gitFileExistsInBranch, gitGetFilesSummary, gitGetFileContent, gitGetFilePreview, gitGetFileHistory, gitReadFileOutsideRepo, gitGetUnmergedBranchesForFile, gitGetAllBranches, gitGetDiffFiles, gitReadNote, gitWriteNote, gitDeleteNote, } from './repo.tools';
-export { gitInit, gitEnsureRepositoryConfiguration, gitEnsureRemoteConfiguration, gitSetupRepository, gitShowConfiguration, gitCheckConfiguration, gitGetBranchHealth, gitGetValidationBranchHealth, gitCreateOrEditFile, gitEditFile, gitRenameFile, gitDeleteFile, gitGenerateNextID, gitReloadIDRegistry, gitRegisterExistingID, gitEnsureMatterID, gitFileStrictMatter, gitIDRegistryExists, gitIDRegistryRename, } from './repo';
-export { gitSyncPR, gitIsPRClosed, gitIsPRClosedRobust, gitGetPRMetadata, gitGetAllPR, gitGetClosedPRs, gitLoadPR, gitPRUpdateComments, gitClosePR, gitClosePRRobust, gitGetNextPRNumber, gitNewValidationRequest, gitNewPR, } from './repo.pr';
+export { gitInit, gitEnsureRepositoryConfiguration, gitEnsureRemoteConfiguration, gitSetupRepository, gitShowConfiguration, gitCheckConfiguration, gitGetBranchHealth, gitGetValidationBranchHealth, gitCreateOrEditFile, gitEditFile, gitRenameFile, gitDeleteFile, gitGenerateNextID, gitAllocateNextPRNumber, gitReloadIDRegistry, gitRegisterExistingID, gitEnsureMatterID, gitFileStrictMatter, gitIDRegistryExists, gitIDRegistryRename, } from './repo';
+export { gitSyncPR, gitIsPRClosed, gitIsPRClosedRobust, gitGetPRMetadata, gitGetAllPR, gitGetClosedPRs, gitLoadPR, gitPRUpdateComments, gitClosePR, gitClosePRRobust, gitNewValidationRequest, gitNewPR, } from './repo.pr';
 export * from './git.e2e.helper';
 export * from './git.health';
 export * from './git.helper';