palabre 0.7.0 → 0.8.0

package/dist/messages/tui.js

@@ -0,0 +1,192 @@
+export const tuiMessages = {
+    fr: {
+        tagline: "Orchestrez des conversations entre agents IA",
+        modeLabel: (mode) => mode === "ask" ? "Ask" : "Debat",
+        modeValue: (mode) => mode === "ask" ? "Ask" : "Debat",
+        noValue: "non definis",
+        lastAskAgent: "dernier agent ask",
+        roles: "Roles",
+        summary: "Synthese",
+        responses: "Reponses",
+        folder: "Dossier",
+        docs: "Docs",
+        commands: "commandes",
+        settings: "reglages",
+        changeMode: "changer de mode",
+        tipContext: "* Tip Ajoute du contexte avec --context <dossier> ou --files <fichier>.",
+        helpTitle: "Commandes TUI",
+        helpAsk: "passer en mode Ask pour collecter plusieurs reponses independantes",
+        helpDebate: "passer en mode Debat pour lancer une conversation entre deux agents",
+        helpAgents: "afficher et choisir les agents actifs",
+        helpRoles: "afficher les roles disponibles",
+        helpConfig: "configurer Palabre sans sortir de la TUI",
+        helpNew: "ouvrir l'assistant guide",
+        helpHelp: "afficher cette aide",
+        helpQuit: "quitter la TUI",
+        helpFallback: "Tout autre texte est utilise comme demande a envoyer aux agents.",
+        agentsTitle: "Agents Palabre",
+        activeMode: "Mode actif",
+        activeAgents: "Agents actifs",
+        availableAgents: "Agents disponibles",
+        example: "Exemple",
+        rolesTitle: "Roles Palabre",
+        currentConfig: "Config actuelle",
+        availableRoles: "Roles disponibles",
+        roleImplementer: "propose une solution concrete",
+        roleCritic: "challenge les hypotheses et demande des preuves",
+        roleArchitect: "structure les options et compromis",
+        roleScout: "explore les pistes et inconnues",
+        roleReviewer: "cherche risques et tests manquants",
+        roleSummarizer: "synthetise fidelement",
+        configTitle: "Configuration Palabre",
+        configFile: "Config",
+        interface: "Interface",
+        language: "Langue",
+        availableAgentsShort: "Agents dispo",
+        availableCommands: "Commandes disponibles",
+        noConfiguredAgents: "aucun agent configure",
+        or: "ou",
+        defaultModeCommand: (mode) => `utiliser ${mode === "ask" ? "Ask" : "Debat"} par defaut`,
+        modeConfigCommand: "changer de mode de configuration",
+        backCommand: "revenir a l'accueil",
+        quitCommand: "quitter",
+        subject: "Sujet",
+        configPrompt: "Config",
+        agentsPrompt: "Agents",
+        rolesPrompt: "Roles",
+        sessionDone: "Session terminee",
+        askResponse: (response, totalResponses) => `reponse ${response}/${totalResponses}`,
+        turnLabel: (turn) => `tour ${turn}`,
+        planTitle: "Plan de session",
+        planCollectAsk: "Collecter les reponses",
+        planLaunchDebate: "Lancer le debat",
+        planSummaryComparative: "Synthese comparative",
+        planSummaryDisabled: "Synthese desactivee",
+        planExport: "Export Markdown",
+        ptyNotice: (agents) => `Note: ${agents} utilise un pseudo-terminal; une fenetre peut apparaitre brievement.`,
+        unknownCommand: "Commande inconnue. Utilise /back pour revenir.",
+        turnsUsage: "Usage: /turns <nombre>",
+        summaryUsage: "Usage: /summary <agent|none>",
+        interfaceDefault: (value) => `Interface par defaut: ${value}.`,
+        languageUpdated: (value) => `Langue mise a jour: ${value}.`,
+        askConfigMode: "Configuration Ask.",
+        debateConfigMode: "Configuration Debat.",
+        askDefaultMode: "Ask devient le mode par defaut.",
+        debateDefaultMode: "Debat devient le mode par defaut.",
+        agentsUnchanged: "Agents inchanges.",
+        rolesUnchanged: "Roles inchanges.",
+        askTurnsNotice: "En mode Ask, le nombre de reponses depend des agents selectionnes avec /agents.",
+        turnsUpdated: (value) => `Tours mis a jour: ${value}.`,
+        askSummaryFallback: "Synthese Ask revenue au fallback.",
+        debateSummaryFallback: "Synthese Debat revenue au fallback.",
+        askSummaryAgent: (value) => `Synthese Ask: ${value}.`,
+        debateSummaryAgent: (value) => `Synthese Debat: ${value}.`,
+        askAgentsUpdated: (value) => `Agents Ask mis a jour: ${value}.`,
+        debateAgentsUpdated: (value) => `Agents Debat mis a jour: ${value}.`,
+        askRolesUpdated: (value) => `Roles Ask mis a jour: ${value}.`,
+        debateRolesUpdated: (value) => `Roles Debat mis a jour: ${value}.`,
+        rolesError: (message) => `Erreur roles: ${message}`,
+        agentsError: (message) => `Erreur agents: ${message}`,
+        noAskAgentsConfigured: "Aucun agent Ask configure.",
+        noDebateAgentsConfigured: "Agents Debat non definis.",
+        rolesCountError: (count, expected, agents) => `${count} role(s) saisi(s), ${expected} attendu(s). Saisis au moins ${expected} roles pour: ${agents}.`,
+        unknownRole: (role, available) => `Role inconnu: ${role}. Roles disponibles: ${available}.`,
+        debateAgentsUsage: "Usage: /agents <agentA> <agentB>",
+        askAgentsUsage: "Usage: /agents <agent...>"
+    },
+    en: {
+        tagline: "Orchestrate conversations between AI agents",
+        modeLabel: (mode) => mode === "ask" ? "Ask" : "Debate",
+        modeValue: (mode) => mode === "ask" ? "Ask" : "Debate",
+        noValue: "not set",
+        lastAskAgent: "last ask agent",
+        roles: "Roles",
+        summary: "Summary",
+        responses: "Responses",
+        folder: "Folder",
+        docs: "Docs",
+        commands: "commands",
+        settings: "settings",
+        changeMode: "change mode",
+        tipContext: "* Tip Add context with --context <folder> or --files <file>.",
+        helpTitle: "TUI Commands",
+        helpAsk: "switch to Ask mode to collect independent responses",
+        helpDebate: "switch to Debate mode for a conversation between two agents",
+        helpAgents: "show and choose active agents",
+        helpRoles: "show available roles",
+        helpConfig: "configure Palabre without leaving the TUI",
+        helpNew: "open the guided assistant",
+        helpHelp: "show this help",
+        helpQuit: "quit the TUI",
+        helpFallback: "Any other text is used as the request sent to agents.",
+        agentsTitle: "Palabre Agents",
+        activeMode: "Active mode",
+        activeAgents: "Active agents",
+        availableAgents: "Available agents",
+        example: "Example",
+        rolesTitle: "Palabre Roles",
+        currentConfig: "Current config",
+        availableRoles: "Available roles",
+        roleImplementer: "proposes a concrete solution",
+        roleCritic: "challenges assumptions and asks for evidence",
+        roleArchitect: "structures options and trade-offs",
+        roleScout: "explores paths and unknowns",
+        roleReviewer: "looks for risks and missing tests",
+        roleSummarizer: "summarizes faithfully",
+        configTitle: "Palabre Configuration",
+        configFile: "Config",
+        interface: "Interface",
+        language: "Language",
+        availableAgentsShort: "Agents",
+        availableCommands: "Available commands",
+        noConfiguredAgents: "no configured agent",
+        or: "or",
+        defaultModeCommand: (mode) => `use ${mode === "ask" ? "Ask" : "Debate"} as default`,
+        modeConfigCommand: "change configuration mode",
+        backCommand: "return to home",
+        quitCommand: "quit",
+        subject: "Subject",
+        configPrompt: "Config",
+        agentsPrompt: "Agents",
+        rolesPrompt: "Roles",
+        sessionDone: "Session complete",
+        askResponse: (response, totalResponses) => `response ${response}/${totalResponses}`,
+        turnLabel: (turn) => `turn ${turn}`,
+        planTitle: "Session plan",
+        planCollectAsk: "Collect responses",
+        planLaunchDebate: "Start debate",
+        planSummaryComparative: "Comparative summary",
+        planSummaryDisabled: "Summary disabled",
+        planExport: "Markdown export",
+        ptyNotice: (agents) => `Note: ${agents} uses a pseudo-terminal; a window may briefly appear.`,
+        unknownCommand: "Unknown command. Use /back to return.",
+        turnsUsage: "Usage: /turns <number>",
+        summaryUsage: "Usage: /summary <agent|none>",
+        interfaceDefault: (value) => `Default interface: ${value}.`,
+        languageUpdated: (value) => `Language updated: ${value}.`,
+        askConfigMode: "Ask configuration.",
+        debateConfigMode: "Debate configuration.",
+        askDefaultMode: "Ask is now the default mode.",
+        debateDefaultMode: "Debate is now the default mode.",
+        agentsUnchanged: "Agents unchanged.",
+        rolesUnchanged: "Roles unchanged.",
+        askTurnsNotice: "In Ask mode, the number of responses depends on agents selected with /agents.",
+        turnsUpdated: (value) => `Turns updated: ${value}.`,
+        askSummaryFallback: "Ask summary returned to fallback.",
+        debateSummaryFallback: "Debate summary returned to fallback.",
+        askSummaryAgent: (value) => `Ask summary: ${value}.`,
+        debateSummaryAgent: (value) => `Debate summary: ${value}.`,
+        askAgentsUpdated: (value) => `Ask agents updated: ${value}.`,
+        debateAgentsUpdated: (value) => `Debate agents updated: ${value}.`,
+        askRolesUpdated: (value) => `Ask roles updated: ${value}.`,
+        debateRolesUpdated: (value) => `Debate roles updated: ${value}.`,
+        rolesError: (message) => `Roles error: ${message}`,
+        agentsError: (message) => `Agents error: ${message}`,
+        noAskAgentsConfigured: "No Ask agent configured.",
+        noDebateAgentsConfigured: "Debate agents are not set.",
+        rolesCountError: (count, expected, agents) => `${count} role(s) entered, ${expected} expected. Enter at least ${expected} roles for: ${agents}.`,
+        unknownRole: (role, available) => `Unknown role: ${role}. Available roles: ${available}.`,
+        debateAgentsUsage: "Usage: /agents <agentA> <agentB>",
+        askAgentsUsage: "Usage: /agents <agent...>"
+    }
+};

package/dist/messages/update.js

@@ -13,7 +13,14 @@ export const updateMessages = {
                 lines.push("", "Installation depuis le repo source detectee.", "", `  cd "${options.projectRoot}"`, "  git pull --ff-only", "  pnpm install", "  pnpm build", "  pnpm link --global", "", "Pour executer ces etapes automatiquement:", "", "  palabre update --apply");
             }
             else {
-                lines.push("", "Installation package detectee.", "", "  pnpm add --global palabre@latest", "", "Si tu utilises npm:", "", "  npm install --global palabre@latest");
+                lines.push("", "Installation package detectee.", "", "  pnpm add --global palabre@latest");
+                if (options.latestVersion) {
+                    lines.push("", "Si pnpm garde une ancienne version malgré @latest:", "", `  pnpm add --global palabre@${options.latestVersion}`);
+                }
+                else {
+                    lines.push("", "Pour verifier la derniere version disponible:", "", "  pnpm view palabre version");
+                }
+                lines.push("", "Si tu utilises npm:", "", "  npm install --global palabre@latest");
             }
             return lines.join("\n");
         }
@@ -32,7 +39,14 @@ export const updateMessages = {
                 lines.push("", "Source repository installation detected.", "", `  cd "${options.projectRoot}"`, "  git pull --ff-only", "  pnpm install", "  pnpm build", "  pnpm link --global", "", "To run these steps automatically:", "", "  palabre update --apply");
             }
             else {
-                lines.push("", "Package installation detected.", "", "  pnpm add --global palabre@latest", "", "If you use npm:", "", "  npm install --global palabre@latest");
+                lines.push("", "Package installation detected.", "", "  pnpm add --global palabre@latest");
+                if (options.latestVersion) {
+                    lines.push("", "If pnpm keeps an older version despite @latest:", "", `  pnpm add --global palabre@${options.latestVersion}`);
+                }
+                else {
+                    lines.push("", "To check the latest available version:", "", "  pnpm view palabre version");
+                }
+                lines.push("", "If you use npm:", "", "  npm install --global palabre@latest");
             }
             return lines.join("\n");
         }

package/dist/new.js

@@ -21,6 +21,75 @@ export async function runNewWizard(config, messages) {
         console.log(messages.new.quitHint);
         console.log(messages.new.defaultHint);
         console.log("");
+        const mode = await askMode(rl, config.defaults?.mode ?? "debate", messages);
+        if (!mode)
+            return undefined;
+        if (mode === "ask") {
+            const askAgents = await askAgentList(rl, choices, config.defaults?.askAgents ?? defaultAskAgents(config), messages);
+            if (!askAgents)
+                return undefined;
+            const [agentA, agentB] = [askAgents[0], askAgents[1] ?? askAgents[0]];
+            if (!agentA || !agentB)
+                return undefined;
+            const topic = await askRequiredText(rl, messages.new.topic, messages);
+            if (!topic)
+                return undefined;
+            printCommandPreview({ mode, agentA, agentB, askAgents, topic }, messages);
+            console.log(messages.new.advancedHint);
+            const launchMinimal = await askYesNo(rl, messages.new.launchMinimal, true, messages);
+            if (launchMinimal === undefined)
+                return undefined;
+            if (launchMinimal) {
+                return {
+                    mode,
+                    agentA,
+                    agentB,
+                    askAgents,
+                    topic,
+                    files: [],
+                    context: [],
+                    showPrompt: false,
+                    plainOutput: false
+                };
+            }
+            const summaryEnabled = await askYesNo(rl, messages.new.summaryEnabled, true, messages);
+            if (summaryEnabled === undefined)
+                return undefined;
+            let summaryAgent;
+            let summaryModel;
+            if (summaryEnabled) {
+                summaryAgent = await askAgent(rl, choices, messages.new.summaryAgent, config.defaults?.askSummaryAgent ?? config.defaults?.summaryAgent ?? askAgents[askAgents.length - 1], messages);
+                if (!summaryAgent)
+                    return undefined;
+                summaryModel = await askOptionalText(rl, messages.new.summaryModelFor(summaryAgent));
+                if (summaryModel === undefined)
+                    return undefined;
+            }
+            const context = splitPaths(await askOptionalText(rl, messages.new.contextPaths));
+            const files = splitPaths(await askOptionalText(rl, messages.new.filesPaths));
+            const showPrompt = await askYesNo(rl, messages.new.showPrompt, false, messages);
+            if (showPrompt === undefined)
+                return undefined;
+            const plainOutput = await askYesNo(rl, messages.new.plainOutput, false, messages);
+            if (plainOutput === undefined)
+                return undefined;
+            const selection = {
+                mode,
+                agentA,
+                agentB,
+                askAgents,
+                topic,
+                summaryAgent,
+                summaryModel,
+                summaryEnabled,
+                files,
+                context,
+                showPrompt,
+                plainOutput
+            };
+            printCommandPreview(selection, messages);
+            return selection;
+        }
         const agentA = await askAgent(rl, choices, messages.new.agentA, config.defaults?.agentA, messages);
         if (!agentA)
             return undefined;
@@ -40,6 +109,7 @@ export async function runNewWizard(config, messages) {
                 agentA,
                 agentB,
                 topic,
+                mode,
                 files: [],
                 context: [],
                 showPrompt: false,
@@ -80,6 +150,7 @@ export async function runNewWizard(config, messages) {
             agentA,
             agentB,
             topic,
+            mode,
             modelA,
             modelB,
             turns,
@@ -98,6 +169,35 @@ export async function runNewWizard(config, messages) {
         rl.close();
     }
 }
+async function askMode(rl, defaultMode, messages) {
+    const choices = [
+        { value: "debate", label: messages.new.modeDebate },
+        { value: "ask", label: messages.new.modeAsk }
+    ];
+    const fallback = choices.find((choice) => choice.value === defaultMode)?.value ?? "debate";
+    console.log(messages.new.mode);
+    choices.forEach((choice, index) => {
+        const marker = choice.value === fallback ? "(*)" : "   ";
+        console.log(`  ${index + 1}) ${marker} ${choice.label}`);
+    });
+    while (true) {
+        const answer = await rl.question(`${messages.new.mode} [${fallback}]: `);
+        const value = answer.trim().toLowerCase();
+        if (isQuit(value))
+            return undefined;
+        if (!value)
+            return fallback;
+        const number = Number(value);
+        if (Number.isInteger(number) && number >= 1 && number <= choices.length) {
+            return choices[number - 1]?.value;
+        }
+        if (value === "debate" || value === "débat" || value === "debat")
+            return "debate";
+        if (value === "ask" || value === "demande" || value === "question")
+            return "ask";
+        console.log(messages.new.invalidModeChoice);
+    }
+}
 async function createQuestioner() {
     if (input.isTTY) {
         return createInterface({ input, output });
@@ -171,6 +271,44 @@ async function askAgent(rl, choices, label, defaultName, messages) {
         console.log(messages.new.invalidAgentChoice);
     }
 }
+async function askAgentList(rl, choices, defaultNames, messages) {
+    const availableNames = choices.map((choice) => choice.name);
+    const fallback = uniqueNames(defaultNames.filter((name) => availableNames.includes(name))).slice(0, 4);
+    const defaultSelection = fallback.length > 0 ? fallback : availableNames.slice(0, Math.min(2, availableNames.length));
+    console.log(messages.new.askAgents);
+    choices.forEach((choice, index) => {
+        const marker = defaultSelection.includes(choice.name) ? "(*)" : "   ";
+        console.log(`  ${index + 1}) ${marker} ${choice.name} - ${choice.status}`);
+    });
+    while (true) {
+        const answer = await rl.question(`${messages.new.askAgentsPrompt(defaultSelection.join(" "))}: `);
+        const value = answer.trim();
+        if (isQuit(value))
+            return undefined;
+        if (!value)
+            return defaultSelection;
+        const tokens = value.split(/[,\s]+/).map((token) => token.trim()).filter(Boolean);
+        const resolved = uniqueNames(tokens.map((token) => {
+            const number = Number(token);
+            if (Number.isInteger(number) && number >= 1 && number <= choices.length) {
+                return choices[number - 1]?.name;
+            }
+            return token;
+        }).filter((name) => Boolean(name)));
+        if (resolved.length === 0) {
+            console.log(messages.new.invalidAskAgentsChoice);
+            continue;
+        }
+        if (resolved.length > 4) {
+            console.log(messages.common.tooManyAskAgents(4));
+            continue;
+        }
+        if (resolved.every((name) => availableNames.includes(name))) {
+            return resolved;
+        }
+        console.log(messages.new.invalidAskAgentsChoice);
+    }
+}
 async function askRequiredText(rl, label, messages) {
     while (true) {
         const answer = await rl.question(`${label}: `);
@@ -230,6 +368,12 @@ function splitPaths(value) {
         .map((entry) => entry.trim())
         .filter(Boolean) ?? [];
 }
+function defaultAskAgents(config) {
+    return [config.defaults?.agentA, config.defaults?.agentB].filter((agent) => Boolean(agent));
+}
+function uniqueNames(names) {
+    return names.filter((name, index) => names.indexOf(name) === index);
+}
 function isQuit(value) {
     return ["q", "quit", "exit"].includes(value.toLowerCase());
 }
@@ -246,13 +390,23 @@ function printCommandPreview(selection, messages) {
 }
 function buildExplicitCommand(selection) {
     const args = ["palabre"];
-    args.push("--agent-a", selection.agentA);
-    args.push("--agent-b", selection.agentB);
-    args.push(quoteShellArg(selection.topic));
+    if (selection.mode === "ask") {
+        args.push("ask", quoteShellArg(selection.topic));
+        const askAgents = selection.askAgents && selection.askAgents.length > 0 ? selection.askAgents : [selection.agentA, selection.agentB];
+        args.push("--agents", ...askAgents);
+    }
+    else {
+        args.push("--agent-a", selection.agentA);
+        args.push("--agent-b", selection.agentB);
+        args.push(quoteShellArg(selection.topic));
+    }
     appendOptionalArgs(args, selection);
     return args.join(" ");
 }
 function buildShortCommand(selection) {
+    if (selection.mode === "ask") {
+        return undefined;
+    }
     const presetName = findPresetNameForPair(selection.agentA, selection.agentB);
     if (!presetName) {
         return undefined;
@@ -281,7 +435,7 @@ function appendOptionalArgs(args, selection) {
     if (selection.showPrompt)
         args.push("--show-prompt");
     if (selection.plainOutput)
-        args.push("--plain");
+        args.push("--terminal");
 }
 function quoteShellArg(value) {
     if (/^[A-Za-z0-9._/:\\-]+$/.test(value)) {

package/dist/orchestrator.js

@@ -1,6 +1,7 @@
 import { createAgent } from "./adapters/index.js";
 import { AdapterError } from "./errors.js";
 import { createTranslator } from "./i18n.js";
+export const MAX_ASK_AGENTS = 4;
 /**
  * Point d'entrée de l'orchestration.
  * Lance le ping-pong entre `agentA` et `agentB` pendant `options.turns` tours,
@@ -104,7 +105,7 @@ export async function runDebate(config, options, renderer, messages = createTran
         try {
             const cancellation = cancellationFailureIfAborted(options, messages, {
                 phase: "summary",
-                agent: options.summaryAgent ?? options.agentB,
+                agent: resolveSummaryAgentName(options),
                 turn: transcript.length + 1
             });
             if (cancellation) {
@@ -121,7 +122,7 @@ export async function runDebate(config, options, renderer, messages = createTran
         catch (error) {
             failure = toDebateFailure(error, {
                 phase: "summary",
-                agent: options.summaryAgent ?? options.agentB,
+                agent: resolveSummaryAgentName(options),
                 turn: transcript.length + 1
             });
             renderer?.error(failure);
@@ -135,6 +136,141 @@ export async function runDebate(config, options, renderer, messages = createTran
         failure
     };
 }
+/**
+ * Lance le mode ask : plusieurs agents répondent indépendamment au même sujet,
+ * puis un agent de synthèse résume fidèlement chaque réponse et les compare.
+ */
+export async function runAsk(config, options, renderer, messages = createTranslator("fr")) {
+    const askAgentNames = resolveAskAgentNames(options);
+    if (askAgentNames.length === 0) {
+        throw new Error(messages.common.noAgentDefined("ask agent"));
+    }
+    if (askAgentNames.length > MAX_ASK_AGENTS) {
+        throw new Error(messages.common.tooManyAskAgents(MAX_ASK_AGENTS));
+    }
+    const agentEntries = askAgentNames.map((name) => {
+        const agentConfig = withRuntimeOverrides(config.agents[name], modelForAgent(options, name), options.pullModels);
+        if (!agentConfig) {
+            throw new Error(messages.common.unknownAgent(name));
+        }
+        return [name, agentConfig];
+    });
+    warnIfOllamaHasNoContext(options, agentEntries.map(([name, agentConfig]) => [name, agentConfig]), renderer, messages);
+    renderer?.start(options, agentEntries.map(([name, agentConfig]) => ({
+        name,
+        role: agentConfig.role,
+        type: agentConfig.type
+    })));
+    const agents = agentEntries.map(([name, agentConfig]) => createAgent(name, agentConfig));
+    const transcript = [];
+    for (let index = 0; index < agents.length; index += 1) {
+        const current = agents[index];
+        const response = index + 1;
+        const cancellation = cancellationFailureIfAborted(options, messages, {
+            phase: "ask",
+            agent: current.name,
+            role: current.role,
+            turn: response
+        });
+        if (cancellation) {
+            renderer?.error(cancellation);
+            return {
+                options,
+                messages: transcript,
+                failure: cancellation
+            };
+        }
+        if (renderer?.askResponseStart) {
+            renderer.askResponseStart(response, agents.length, current.name, current.role);
+        }
+        else {
+            renderer?.turnStart(response, agents.length, current.name, current.role);
+        }
+        renderer?.thinkingStart(current.name, current.role);
+        let agentResponse;
+        try {
+            agentResponse = await current.generate({
+                topic: options.topic,
+                turn: response,
+                totalTurns: agents.length,
+                selfName: current.name,
+                peerName: "independent-agents",
+                selfRole: current.role,
+                mode: "ask",
+                language: options.language,
+                session: options.session,
+                files: options.files,
+                transcript: [],
+                signal: options.signal
+            });
+        }
+        catch (error) {
+            const failure = toDebateFailure(error, {
+                phase: "ask",
+                agent: current.name,
+                role: current.role,
+                turn: response
+            });
+            renderer?.error(failure);
+            return {
+                options,
+                messages: transcript,
+                failure
+            };
+        }
+        finally {
+            renderer?.thinkingEnd();
+        }
+        const message = {
+            agent: current.name,
+            role: current.role,
+            content: agentResponse.content,
+            createdAt: new Date().toISOString()
+        };
+        transcript.push(message);
+        if (renderer?.askResponseMessage) {
+            renderer.askResponseMessage(message.content);
+        }
+        else {
+            renderer?.message(message.content);
+        }
+    }
+    let summary;
+    let failure;
+    if (options.summaryEnabled) {
+        try {
+            const summaryAgentName = resolveSummaryAgentName(options);
+            const cancellation = cancellationFailureIfAborted(options, messages, {
+                phase: "summary",
+                agent: summaryAgentName,
+                turn: transcript.length + 1
+            });
+            if (cancellation) {
+                renderer?.error(cancellation);
+                return {
+                    options,
+                    messages: transcript,
+                    failure: cancellation
+                };
+            }
+            summary = await generateSummary(config, options, transcript, renderer, messages);
+        }
+        catch (error) {
+            failure = toDebateFailure(error, {
+                phase: "summary",
+                agent: resolveSummaryAgentName(options),
+                turn: transcript.length + 1
+            });
+            renderer?.error(failure);
+        }
+    }
+    return {
+        options,
+        messages: transcript,
+        summary,
+        failure
+    };
+}
 /**
  * Heuristique d'arrêt sur accord explicite.
  * Ne s'active qu'après un tour complet (nombre pair de messages) pour éviter les faux positifs.
@@ -189,7 +325,7 @@ function warnIfOllamaHasNoContext(options, agents, renderer, messages = createTr
  * @throws {Error} si l'agent de synthèse est absent de `config.agents`.
  */
 async function generateSummary(config, options, transcript, renderer, messages = createTranslator("fr")) {
-    const summaryAgentName = options.summaryAgent ?? options.agentB;
+    const summaryAgentName = resolveSummaryAgentName(options);
     const summaryModel = options.summaryModel ?? modelForAgent(options, summaryAgentName);
     const summaryConfig = withRuntimeOverrides(config.agents[summaryAgentName], summaryModel, options.pullModels);
     if (!summaryConfig) {
@@ -201,9 +337,9 @@ async function generateSummary(config, options, transcript, renderer, messages =
     const response = await summaryAgent.generate({
         topic: options.topic,
         turn: transcript.length + 1,
-        totalTurns: options.turns,
+        totalTurns: options.mode === "ask" ? transcript.length : options.turns,
         selfName: summaryAgent.name,
-        peerName: "transcript",
+        peerName: options.mode === "ask" ? "ask-responses" : "transcript",
         selfRole: summaryAgent.role,
         mode: "summary",
         language: options.language,
@@ -234,6 +370,21 @@ function cancellationFailureIfAborted(options, messages, context) {
         message: messages.orchestrator.cancelled
     };
 }
+function resolveAskAgentNames(options) {
+    const agents = options.askAgents && options.askAgents.length > 0
+        ? options.askAgents
+        : [options.agentA, options.agentB];
+    return agents.filter((agent, index) => Boolean(agent) && agents.indexOf(agent) === index);
+}
+function resolveSummaryAgentName(options) {
+    if (options.summaryAgent) {
+        return options.summaryAgent;
+    }
+    if (options.mode === "ask" && options.askAgents && options.askAgents.length > 0) {
+        return options.askAgents[options.askAgents.length - 1] ?? options.agentB;
+    }
+    return options.agentB;
+}
 function toDebateFailure(error, context) {
     if (error instanceof AdapterError) {
         return {