agentic-api 2.0.684 → 2.0.885

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentExecutor = void 0;
+exports.buildExecutionContextTag = buildExecutionContextTag;
+const utils_1 = require("../utils");
 const rag_1 = require("../rag");
 const stategraph_1 = require("../stategraph");
 const execute_1 = require("../execute");
@@ -16,7 +18,7 @@ class AgentExecutor {
         // - Mode worker : collaborateur avec WORKER_INTERNAL_PROMPT
         this.simulatorAgentBase = {
             name: this.isWorkerMode ? simulator_types_1.WORKER_AGENT_NAME : simulator_types_1.SIMULATOR_AGENT_NAME,
-            model: ('HIGH-fast'),
+            model: (config.workerModel || 'HIGH-fast'),
             publicDescription: this.isWorkerMode ? simulator_types_1.WORKER_AGENT_DESCRIPTION : simulator_types_1.SIMULATOR_AGENT_DESCRIPTION,
             cancelMemory: true,
             instructions: '', // Sera construit dans initializeContexts
@@ -24,11 +26,35 @@ class AgentExecutor {
             downstreamAgents: []
         };
         //
-        // Mode simulator : annuler la mémoire pour tous les agents en test
-        // Mode worker : conserver la mémoire (agents en production)
-        if (!this.isWorkerMode) {
+        // DANGER: sans ce filtre, le Worker appelle createWorkerJob en boucle
+        // récursive (33 jobs créés en <1s, crash sur la limite de 20).
+        // IMPORTANT: cloner les agents pour ne pas muter l'original (singleton _defaultAgent)
+        // FIXME: remplacer par une construction dynamique du périmètre tools
+        // (ex: excludeTools sur AgentConfig, lu par injectTransferTools)
+        const EXCLUDES_TOOLS = ['searchNoteMemories', 'updateUserMemory', 'createWorkerJob', 'createTaskListJob', 'sendFeedbackEmail'];
+        // const JOB_TOOLS = ['createWorkerJob', 'createTaskListJob'];
+        config.agents = config.agents.map(agent => ({
+            ...agent,
+            tools: agent.tools ? [...agent.tools] : [],
+            //
+            // Override du modèle de l'agent piloté si spécifié
+            ...(this.isWorkerMode && config.agentModel ? { model: config.agentModel } : {})
+        }));
+        if (this.isWorkerMode) {
+            //
+            // Mode worker : supprimer les tools de création de jobs (anti-récursion)
+            // et les tools mémoire (réservés aux interactions directes utilisateur)
+            const excludeWorker = [...EXCLUDES_TOOLS];
+            config.agents.forEach(agent => {
+                agent.tools = agent.tools.filter(t => !excludeWorker.includes(t.function?.name));
+            });
+        }
+        else {
+            //
+            // Mode simulator : supprimer les tools mémoire des agents en test
             config.agents.forEach(agent => {
                 agent.cancelMemory = true;
+                agent.tools = agent.tools.filter(t => !EXCLUDES_TOOLS.includes(t.function?.name));
             });
         }
         //
@@ -59,7 +85,7 @@ class AgentExecutor {
         const agentContext = (this.isWorkerMode && externalAgentContext)
             ? externalAgentContext
             : {
-                user: { id: `test-user`, role: 'user', uid: `test-${sessionId}` },
+                user: { id: `test-user`, role: 'user', uid: `test-${sessionId}`, mail: `test-${sessionId}@simulator.local` },
                 credential: { test: true, sessionId: `agent-${sessionId}` },
                 verbose: this.config.verbose,
                 session: { id: `agent-${sessionId}`, data: {}, messages: [] },
@@ -80,11 +106,11 @@ class AgentExecutor {
         }
         //
         // Construire les instructions selon le mode
-        // - Simulator : GENERIC_SIMULATOR_PROMPT(scenario) + instructionEx
-        // - Worker : WORKER_INTERNAL_PROMPT(instructionEx = brief)
+        // - Simulator : GENERIC_SIMULATOR_PROMPT(scenario) + positionDescription
+        // - Worker : WORKER_INTERNAL_PROMPT(positionDescription + personaResult)
         const fullInstructions = this.isWorkerMode
-            ? (0, simulator_prompts_1.WORKER_INTERNAL_PROMPT)(this.config.instructionEx || '')
-            : (0, simulator_prompts_1.GENERIC_SIMULATOR_PROMPT)(scenario, this.config.instructionEx);
+            ? (0, simulator_prompts_1.WORKER_INTERNAL_PROMPT)(this.config.positionDescription || '', this.config.personaResult, (0, utils_1.extractAgentCapabilities)(this.config.agents, this.config.start))
+            : (0, simulator_prompts_1.GENERIC_SIMULATOR_PROMPT)(scenario, this.config.positionDescription);
         return {
             agentContext,
             simulatorContext: orchestratorContext,
@@ -107,9 +133,13 @@ class AgentExecutor {
      * ✅ Exécuter l'agent testé et retourner sa réponse (extraction de agent-vs-agent.ts)
      */
     async executeAgent(context, query) {
+        //
+        // Mode worker uniquement : signaler à l'Agent qu'il est piloté par un orchestrateur
+        // afin d'éviter les questions de clarification sans réponse possible
+        const finalQuery = this.isWorkerMode ? simulator_prompts_1.WORKER_AUTONOMOUS_PREFIX + query : query;
         // Logique extraite de AgentVsAgentTester.executeAgentWithContext()
         const execResult = await (0, execute_1.executeAgentSet)(this.config.agents, context.agentContext, {
-            query,
+            query: finalQuery,
             home: this.config.start,
             stdout: execute_1.DummyWritable,
             verbose: this.config.verbose,
@@ -150,7 +180,7 @@ class AgentExecutor {
         // ✅ Injecter le contexte technique si disponible
         const agentContextInjection = this.buildAgentContextInjection(context);
         const enrichedQuery = agentContextInjection ? `${query}\n\n${agentContextInjection}` : query;
-        // console.log('DEBUG: Exécution du simulateur avec query:\n', enrichedQuery);
+        // console.log(`📡 Simulator input (turn ${context.exchangeCount}/${context.maxTurns || '?'}):\n  query[${enrichedQuery.length}]: ${enrichedQuery.substring(0, 200)}${enrichedQuery.length > 200 ? '...' : ''}\n  context: ${agentContextInjection.substring(0, 120)}`);
         await (0, execute_1.executeAgentSet)([context.simulatorAgent], context.simulatorContext, {
             query: enrichedQuery,
             home: this.isWorkerMode ? simulator_types_1.WORKER_AGENT_NAME : simulator_types_1.SIMULATOR_AGENT_NAME,
@@ -159,27 +189,16 @@ class AgentExecutor {
             debug: false
         });
         const response = this.getLastAssistantMessage(context.simulatorContext);
+        // console.log(`📡 Simulator output (turn ${context.exchangeCount}): ${response.substring(0, 200)}${response.length > 200 ? '...' : ''}`);
         context.conversationHistory.push(`Simulator: ${response}`);
         return response;
     }
     /**
-     * ✅ Construire l'injection de contexte technique pour le simulateur
-     * Permet au simulateur de connaître les tools utilisés par l'agent testé
+     * Construire l'injection de contexte à chaque tour
      */
     buildAgentContextInjection(context) {
-        if (!context.lastExecution || !context.lastExecution.actions || context.lastExecution.actions.length === 0) {
-            return '';
-        }
-        // Extraire les noms des tools appelés (sans les arguments)
-        const tools = context.lastExecution.actions.map(action => action.action);
-        if (tools.length === 0) {
-            return '';
-        }
-        const contextData = {
-            tools: tools,
-            exchangeCount: context.exchangeCount
-        };
-        return `<agent-context>\n${JSON.stringify(contextData, null, 2)}\n</agent-context>`;
+        const actions = !this.isWorkerMode ? context.lastExecution?.actions : undefined;
+        return buildExecutionContextTag(context.exchangeCount, context.maxTurns, actions);
     }
     /**
      * ✅ Récupérer le dernier message de l'agent testé (extraction de agent-vs-agent.ts ligne 168-191)
@@ -219,3 +238,20 @@ class AgentExecutor {
     }
 }
 exports.AgentExecutor = AgentExecutor;
+/**
+ * Construit le tag <execution-context> injecté à chaque tour.
+ * Exporté pour tests unitaires.
+ */
+function buildExecutionContextTag(exchangeCount, maxTurns, actions) {
+    const max = maxTurns || 10;
+    const contextData = {
+        turn: exchangeCount,
+        maxTurns: max,
+        // Le simulateur doit toujours disposer d'un tour pour évaluer la réponse courante.
+        turnsRemaining: exchangeCount === 0 ? max : Math.max(1, max - exchangeCount)
+    };
+    if (actions?.length) {
+        contextData.tools = actions.map(a => a.action);
+    }
+    return `<execution-context>\n${JSON.stringify(contextData)}\n</execution-context>`;
+}

package/dist/src/agents/simulator.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentSimulator = void 0;
 const simulator_executor_1 = require("./simulator.executor");
+const execute_1 = require("../execute");
 class AgentSimulator {
     constructor(config) {
         this.config = config;
@@ -77,7 +78,7 @@ class AgentSimulator {
      * const worker = new AgentSimulator({
      *   agents: [...], start: 'PR-knowledge', verbose: false,
      *   mode: 'worker',
-     *   instructionEx: 'Consulter tous les mails du jour et résumer les actions'
+     *   positionDescription: 'Consulter tous les mails du jour et résumer les actions'
      * });
      *
      * const result = await worker.runJob({
@@ -90,11 +91,29 @@ class AgentSimulator {
     async runJob(input) {
         const startTime = Date.now();
         const maxIterations = input.maxIterations ?? 10;
+        const stdout = input.agentContext?.stdout || execute_1.DummyWritable;
+        const emptyUsage = { prompt: 0, completion: 0, total: 0, cost: 0 };
+        //
+        // Helper : émettre un WorkerEvent via sendFeedback
+        const emitWorkerEvent = (description, data) => {
+            (0, execute_1.sendFeedback)({
+                agent: 'worker',
+                stdout,
+                description,
+                usage: context.lastExecution?.usage || emptyUsage,
+                state: input.jobId || '',
+                data
+            });
+        };
         //
         // Initialiser les contextes avec le contexte réel de l'agent
         const context = await this.executor.initializeContexts({ goals: '', persona: '', result: '' }, input.agentContext);
+        context.maxTurns = maxIterations;
         const allMessages = [];
         let exchangeCounter = 0;
+        //
+        // Événement : worker_started
+        emitWorkerEvent(input.description || 'Worker démarré', { type: 'worker_started', jobId: input.jobId || '', maxIterations, description: input.description });
         try {
             let currentUserQuery = input.query;
             //
@@ -107,6 +126,9 @@ class AgentSimulator {
             //
             // Boucle Worker — maxIterations échanges (parallèle à executeSimulation)
             while (exchangeCounter < maxIterations) {
+                //
+                // Événement : worker_iteration (avant appel Agent)
+                emitWorkerEvent(currentUserQuery.substring(0, 120), { type: 'worker_iteration', iteration: exchangeCounter + 1, maxIterations, query: currentUserQuery.substring(0, 200) });
                 //
                 // Agent répond à la question
                 const agentResponse = await this.executor.executeAgent(context, currentUserQuery);
@@ -123,17 +145,36 @@ class AgentSimulator {
                 // Vérifier [WORKER_COMPLETE]
                 if (this.isWorkerComplete(workerResponse)) {
                     const parsed = this.parseWorkerResult(workerResponse);
+                    if (this.isWorkerCompletionValid(parsed)) {
+                        this.lastExecution = context.lastExecution;
+                        const duration = Date.now() - startTime;
+                        emitWorkerEvent(parsed.summary || 'Worker terminé', { type: 'worker_completed', success: true, summary: parsed.summary, iterations: exchangeCounter, duration });
+                        return {
+                            success: true,
+                            deliverable: parsed.deliverable,
+                            summary: parsed.summary,
+                            confidence: parsed.confidence,
+                            iterations: exchangeCounter,
+                            maxIterations,
+                            duration,
+                            execution: context.lastExecution,
+                            messages: allMessages
+                        };
+                    }
                     this.lastExecution = context.lastExecution;
+                    const duration = Date.now() - startTime;
+                    emitWorkerEvent('Clôture invalide', { type: 'worker_failed', error: 'deliverable must be concrete and non-empty', iterations: exchangeCounter, duration });
                     return {
-                        success: true,
-                        deliverable: parsed.deliverable,
-                        summary: parsed.summary,
-                        confidence: parsed.confidence,
+                        success: false,
+                        deliverable: '',
+                        summary: 'Invalid [WORKER_COMPLETE] payload',
+                        confidence: 0,
                         iterations: exchangeCounter,
                         maxIterations,
-                        duration: Date.now() - startTime,
+                        duration,
                         execution: context.lastExecution,
-                        messages: allMessages
+                        messages: allMessages,
+                        error: 'Worker completion rejected: deliverable must be concrete and non-empty'
                     };
                 }
                 //
@@ -148,8 +189,34 @@ class AgentSimulator {
                 }
             }
             //
-            // Timeout — maxIterations atteint sans [WORKER_COMPLETE]
+            // Budget épuisé — forcer une conclusion avant de déclarer timeout
+            // On demande au Worker LLM de synthétiser tout ce qui a été collecté
+            const forceConcludeMsg = `[BUDGET ÉPUISÉ — dernier tour obligatoire]\nTu as utilisé ${exchangeCounter}/${maxIterations} tours. Produis maintenant ton [WORKER_COMPLETE] final en synthétisant toutes les informations récoltées.`;
+            const forceResponse = await this.executor.executeSimulator(context, forceConcludeMsg);
+            if (this.isWorkerComplete(forceResponse)) {
+                const parsed = this.parseWorkerResult(forceResponse);
+                if (this.isWorkerCompletionValid(parsed)) {
+                    this.lastExecution = context.lastExecution;
+                    const duration = Date.now() - startTime;
+                    emitWorkerEvent(parsed.summary || 'Worker terminé (budget épuisé)', { type: 'worker_completed', success: true, summary: parsed.summary, iterations: exchangeCounter, duration });
+                    return {
+                        success: true,
+                        deliverable: parsed.deliverable,
+                        summary: parsed.summary,
+                        confidence: parsed.confidence,
+                        iterations: exchangeCounter,
+                        maxIterations,
+                        duration,
+                        execution: context.lastExecution,
+                        messages: allMessages
+                    };
+                }
+            }
+            //
+            // Timeout réel — le Worker n'a pas pu conclure
             this.lastExecution = context.lastExecution;
+            const duration = Date.now() - startTime;
+            emitWorkerEvent(`Limite atteinte (${maxIterations} itérations)`, { type: 'worker_failed', error: 'Max iterations reached', iterations: exchangeCounter, duration });
             return {
                 success: false,
                 deliverable: '',
@@ -157,7 +224,7 @@ class AgentSimulator {
                 confidence: 0,
                 iterations: exchangeCounter,
                 maxIterations,
-                duration: Date.now() - startTime,
+                duration,
                 execution: context.lastExecution,
                 messages: allMessages,
                 error: 'Max iterations reached without [WORKER_COMPLETE]'
@@ -165,6 +232,8 @@ class AgentSimulator {
         }
         catch (error) {
             this.lastExecution = context.lastExecution;
+            const duration = Date.now() - startTime;
+            emitWorkerEvent(`Erreur: ${(error.message || error).substring(0, 80)}`, { type: 'worker_failed', error: error.message || String(error), iterations: exchangeCounter, duration });
             return {
                 success: false,
                 deliverable: '',
@@ -172,7 +241,7 @@ class AgentSimulator {
                 confidence: 0,
                 iterations: exchangeCounter,
                 maxIterations,
-                duration: Date.now() - startTime,
+                duration,
                 execution: context.lastExecution,
                 messages: allMessages,
                 error: `Erreur d'exécution: ${error.message || error}`
@@ -202,6 +271,7 @@ class AgentSimulator {
     async executeSimulation(options) {
         // ✅ Initialiser les contextes avec le scenario complet
         const context = await this.executor.initializeContexts(options.scenario);
+        context.maxTurns = options.maxExchanges;
         const allMessages = [];
         let lastAgentMessage = '';
         let exchangeCounter = 0; // Compteur d'échanges (user+assistant)
@@ -304,7 +374,7 @@ class AgentSimulator {
     }
     /**
      * Compter les occurrences d'une action dans le dernier ExecutionResult
-     * @param name Nom exact de l'action (ex: 'lookupMfilesIntervenant', 'lookupKnowledge', 'sendInternalEmail')
+     * @param name Nom exact de l'action (ex: 'resolveLocataire', 'lookupKnowledge', 'sendInternalEmail')
      * @returns { firstPos, count, total } où:
      *  - firstPos: index de la première occurrence (ou -1 si absente)
      *  - count: nombre d'occurrences de cette action
@@ -356,6 +426,25 @@ class AgentSimulator {
     isWorkerComplete(response) {
         return response.includes('[WORKER_COMPLETE]');
     }
+    isWorkerCompletionValid(parsed) {
+        const deliverable = (parsed.deliverable || '').trim();
+        const summary = (parsed.summary || '').trim();
+        if (!deliverable) {
+            return false;
+        }
+        // Rejeter les fausses clôtures qui ne sont qu'une enveloppe JSON sérialisée en texte.
+        const isWrappedJsonEnvelope = deliverable.startsWith('{')
+            && /"deliverable"\s*:/.test(deliverable)
+            && /"summary"\s*:/.test(deliverable);
+        if (isWrappedJsonEnvelope) {
+            return false;
+        }
+        // Rejeter les clôtures déclaratives sans résultat concret.
+        if (/^instruction envoy[ée]e?/i.test(summary)) {
+            return false;
+        }
+        return true;
+    }
     parseWorkerResult(response) {
         const match = response.match(/\[WORKER_COMPLETE\]\s*\n?([\s\S]*)/);
         if (match) {

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

@@ -1,36 +1,63 @@
 import { SimulationScenario } from "./simulator.types";
 /**
- * Génère le prompt du simulateur générique avec le scenario intégré
- *
- * Basé sur ClientSimulator avec Mirror Agent Model
- * Intègre directement les valeurs du scenario dans des tags XML
- *
- * @param scenario - Scenario de simulation avec persona, goals, result
- * @param instructionEx - Instructions additionnelles spécifiques à l'agent (ajoutées à la fin)
- * @returns Prompt complet avec plan de simulation intégré
+ * Section ACTEURS — décrit les 3 rôles de la boucle.
+ * Spécifique par agent : le descripteur de l'orchestrateur diffère.
+ */
+export declare const acteursSectionSimulatorPrompt = "# ACTEURS\nIl y a 3 acteurs dans cette boucle de test E2E :\n1. **Utilisateur** \u2014 celui qui a pos\u00E9 la question initiale (premier message). Il est HORS boucle.\n2. **Agent** \u2014 il poss\u00E8de les outils de l'entreprise et r\u00E9pond \u00E0 tes demandes. C'est lui qu'on teste.\n3. **Toi (Simulateur)** \u2014 tu pilotes l'Agent tour par tour selon <simulation_brief> et tu \u00E9values ses r\u00E9ponses. Ta personnalit\u00E9 est d\u00E9crite dans <persona_user>.";
+export declare const acteursSectionWorkerPrompt = "# ACTEURS\nIl y a 3 acteurs dans cette boucle de travail :\n1. **Utilisateur** \u2014 celui qui a pos\u00E9 la question initiale (premier message). Il est HORS boucle pendant l'ex\u00E9cution : tu ne dois jamais le solliciter ni attendre d'information de sa part.\n2. **Agent** \u2014 il dispose des outils de l'entreprise et ex\u00E9cute tes demandes.\n3. **Toi (Worker)** \u2014 tu pilotes l'Agent tour par tour afin d'accomplir la mission d\u00E9crite dans <worker_brief>.";
+/**
+ * Section DÉMARRAGE / premier tour — comportement au premier message.
+ * - Simulator : avertissement sur la nature du premier message (réponse Agent, pas utilisateur).
+ * - Worker : dérivation d'intention depuis les déclencheurs de la fiche de poste.
+ */
+export declare const starterSectionSimulatorPrompt = "\u26A0\uFE0F Le premier message que tu re\u00E7ois est d\u00E9j\u00E0 la r\u00E9ponse de l'Agent \u00E0 la question initiale de l'Utilisateur. Ce n'est PAS un message de l'utilisateur.";
+export declare const starterSectionWorkerPrompt = "# D\u00C9MARRAGE (premier tour uniquement)\nAvant d'envoyer ta premi\u00E8re demande \u00E0 l'Agent :\n1. Identifie si une intention est **explicite** dans le message [verbe + objet direct].\n2. Si non (texte brut, r\u00E9sum\u00E9 de mail, message ambigu) \u2192 parcours les champs `D\u00E9clencheur:` des **Activit\u00E9s** de ta `<worker_brief>`. S\u00E9lectionne l'activit\u00E9 dont le d\u00E9clencheur correspond le mieux au message : son champ `Travail:` d\u00E9finit ton objectif, son champ `B\u00E9n\u00E9ficiaire:` identifie le destinataire.\n3. Formule un plan d'action en 2-3 \u00E9tapes **(raisonnement interne \u2014 ne jamais l'envoyer \u00E0 l'Agent)**.\n4. Premi\u00E8re demande = \u00E9tape 1 du plan, cibl\u00E9e et sourc\u00E9e. Pas de pr\u00E9ambule ni num\u00E9rotation.";
+/**
+ * Section LIFECYCLE — budget de tours injecté à chaque tour via <execution-context>.
+ * - Simulator : inclut aussi `tools` (outils réellement appelés) pour validation E2E.
+ * - Worker : inclut les instructions de clôture au dernier tour (fallback utile).
+ */
+export declare const lifecycleSectionSimulatorPrompt = "# LIFECYCLE\n\u00C0 chaque tour, un tag `<execution-context>` est inject\u00E9 avec :\n- `turn` : tour actuel\n- `maxTurns` : budget total\n- `turnsRemaining` : tours restants\n- `tools` : noms exacts des outils **r\u00E9ellement appel\u00E9s** par l'Agent pendant ce tour\nUtilise cette info pour planifier : si peu de tours restent, privil\u00E9gie les questions qui valident directement les objectifs.\n**CRITIQUE**: Si un outil appara\u00EEt dans `tools`, il a **r\u00E9ellement \u00E9t\u00E9 ex\u00E9cut\u00E9**.\n**\u00C9QUIVALENCE M\u00C9TIER**: pour l'\u00E9valuation, `M-Files` = `GED` = outils `resolve*` / `lookupMfiles*`. Si l'objectif demande d'utiliser le GED ou M-Files et qu'un outil `resolve*` ou `lookupMfiles*` appara\u00EEt dans `tools`, consid\u00E8re que l'objectif GED/M-Files est satisfait.";
+export declare const lifecycleSectionWorkerPrompt = "# LIFECYCLE\n\u00C0 chaque tour, un tag `<execution-context>` est inject\u00E9 avec ton budget :\n- `turn` : tour actuel\n- `maxTurns` : budget total\n- `turnsRemaining` : tours restants\nUtilise cette info pour prioriser : si peu de tours restent, concentre-toi sur le livrable.\n**DERNIER TOUR** : quand `turnsRemaining` \u2264 1, tu DOIS conclure avec `[WORKER_COMPLETE]` en synth\u00E9tisant toutes les informations r\u00E9colt\u00E9es.\nSi l'information est insuffisante, fournis un **fallback utile** : meilleures hypoth\u00E8ses explicites + options + plan d'action concret (sans inventer de faits). Ne demande pas de tour suppl\u00E9mentaire.";
+/**
+ * Section SAFETY — règles anti-hallucination.
+ * Formulation différente selon le rôle (évaluateur vs exécutant).
  */
-export declare function GENERIC_SIMULATOR_PROMPT(scenario: SimulationScenario, instructionEx?: string): string;
+export declare const safetySectionSimulatorPrompt = "# SAFETY\n- N'invente pas de r\u00E9sultats d'outils.\n- Si l'Agent a produit une r\u00E9ponse visible dans la conversation, \u00E9value-la \u2014 ne d\u00E9clare jamais \"pas de r\u00E9ponse\".";
+export declare const safetySectionWorkerPrompt = "# SAFETY\n- N'invente pas de faits.\n- Si l'information est incertaine ou incompl\u00E8te, indique-le dans `summary`.";
 /**
- * 3 prompts variables de personnalité pré-définis à choisir manuellement
+ * Bloc CRITICAL final — rappel JSON strict après le trigger de sortie.
+ * Factorisé via fonction car seul le nom du trigger diffère.
  */
+export declare function buildCriticalBlock(trigger: string): string;
 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";
+export declare const PERSONA_RESULT_CLIENT = "R\u00E9daction claire et orient\u00E9e client, empathique, sans jargon interne, avec des conclusions directement actionnables.";
 /**
- * Persona collaborateur professionnel et méthodique
+ * Préfixe injecté au premier message Worker→Agent en mode autonome.
+ * Signale à l'Agent qu'il est piloté par un orchestrateur et doit éviter
+ * les questions de clarification destinées à un utilisateur humain.
  */
-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.";
+export declare const WORKER_AUTONOMOUS_PREFIX = "[MODE AUTONOME] Tu es pilot\u00E9 par un orchestrateur. Ne pose pas de question de clarification,  va droit au but, pas de bavardage ni de formules de politesse superflues.\n\n";
 /**
- * Prompt interne fixe du WorkerJob — system prompt pour le Worker LLM
+ * Génère le prompt du simulateur générique avec le scenario intégré.
  *
- * 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]
+ * @param scenario - Scénario de simulation avec persona, goals, result
+ * @param positionDescription - Instructions additionnelles (ajoutées à la fin)
+ */
+export declare function GENERIC_SIMULATOR_PROMPT(scenario: SimulationScenario, positionDescription?: string): string;
+/**
+ * Prompt interne fixe du WorkerJob — system prompt pour le Worker LLM.
  *
- * 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).
+ * Structure (inspirée OpenClaw) :
+ *   CONTEXT     → ACTEURS, CAPACITÉS AGENT, worker_brief (persona/soul)
+ *   PROCESS     → DÉMARRAGE, MISSION, BOUCLE DE DÉCISION, STYLE
+ *   CONSTRAINTS → CONTRAINTES (RÈGLES + BLOCAGE + NO-PROGRESS + INTERDICTIONS)
+ *   OUTPUT      → LIFECYCLE, SAFETY, VÉRIFICATION, TRIGGERS, FORMAT
  *
- * @param brief - Le cahier des charges du worker (= instructionEx de SimulatorConfig)
- * @param instructionEx - Instructions additionnelles (optionnel)
+ * @param positionDescription - Fiche de poste du collaborateur (= PERSONA_PROMPTS[key], tronquée à -- END --)
+ * @param personaResult - Style du deliverable final (orienté client)
+ * @param agentCapabilities - Capacités de l'Agent (firstLine de chaque tool.function.description)
  */
-export declare function WORKER_INTERNAL_PROMPT(brief: string, instructionEx?: string): string;
+export declare function WORKER_INTERNAL_PROMPT(positionDescription: string, personaResult?: string, agentCapabilities?: string): string;